CodeStruct

The Hook: The "LeetCode Grind" Problem

Start by resonating with your audience (students and devs).

• The Reality: We all know the struggle. Grinding hundreds of LeetCode problems, memorizing patterns, but failing to understand the visual mechanics of how a Binary Search Tree actually rebalances.

• The Gap: Most platforms (HackerRank, LeetCode) test your coding, but they don't teach the concepts effectively. They are "one-size-fits-all."

• The Question: What if a platform could not only visualize the algorithm but also adapt to your specific learning style using AI?

What is CodeStruct?

Introduce your solution clearly.

• Elevator Pitch: CodeStruct is an intelligent DSA learning platform that combines interactive visualizations with Data Mining techniques to create a personalized learning roadmap.

• The "Pre & In" Methodology:

  • Pre-Phase: Diagnostic assessment to classify the user (Weak, Moderate, Strong).

  • In-Phase: Custom roadmap + Visualizers (Algorithm Composer).

Under the Hood: The "Intelligence" (Data Mining & ML)

This is the most impressive part for technical recruiters. It proves you aren't just using APIs; you are building logic.

I built a three-stage Data Mining engine to power the recommendations (using scikit-learn and mlxtend):

A. Grouping Learners (Clustering):

Using K-Means Clustering, I analyzed user performance across 7 metrics (Stack, Recursion, BST, etc.) to group learners into distinct profiles:

• Cluster 0: Fundamental gaps (Needs basic revision).

• Cluster 1: Strong conceptual grasp (Ready for advanced trees).

• Cluster 2: Mixed proficiency.

B. Predicting Success (Classification):

I trained a Gaussian Naive Bayes model to predict a user's future skill level based on their initial interactions. This allows the system to proactively flag users who might struggle with complex topics like Closed Hash Tables.

C. Finding Hidden Patterns (Association Rules):

Using the Apriori Algorithm, the system discovers relationships between topics.

• The Insight: My model found that "Users weak in BST are 85% likely to fail at B-Trees."

• The Action: If a user fails a BST quiz, the system automatically locks the B-Tree module and recommends a specific revision path.

Implementation & Tech Stack

The architecture separates the interactive frontend from the heavy data-processing backend, connected via high-performance APIs.

• Frontend (The Visual Layer): Angular

  • Built with Angular to handle the complex state management required for the "Visual Algorithm Composer."

  • Delivers a responsive, component-based UI for the interactive graph/tree animations and the learner dashboard.

• Backend API (The Bridge): FastAPI

  • Chosen for its speed and native support for Python, allowing seamless integration with the data mining engine.

  • Exposes endpoints that receive user test scores and return personalized roadmap recommendations in real-time.

• Machine Learning Engine (The Brain): Python & Scikit-Learn

  • Data Processing: Pandas is used for cleaning and preprocessing the raw learner datasets.

  • Model Hosting: The pre-trained models (exported via joblib) are loaded directly into the FastAPI backend to serve predictions:

    • K-Means (Scikit-Learn): Clusters users into skill groups (Weak/Moderate/Strong).

    • Gaussian Naive Bayes: Predicts future proficiency probabilities.

    • Apriori (Mlxtend): Generates rule-based content recommendations (e.g., "If Weak in BST → Recommend Tree Traversal").

• Database (The Memory): MySQL

  • Stores structured relational data, including user profiles, quiz scores, and historical interaction logs.

  • Acts as the source of truth for the "Pre-Phase" analysis, feeding historical data into the ML pipeline for retraining.

Architecture Flow

Key Insights & Challenges

Share what you learned from the data (from your provided text):

• The Data Truth: Learners consistently scored high on Basics (Stacks/Queues) but performance dropped sharply on Non-linear structures (Heaps/Graphs).

• The Engineering Challenge: Synchronizing the Python ML models (exported via joblib) with the real-time web application was a challenge in handling library versions and serialization.

Future Scope: The "AI Tutor"

Wrap up with your vision.

• Generative AI: Integrating an LLM to act as a conversational tutor (CodeStruct AI) that can explain why code failed, not just that it failed.

• Interactive Canvas: A "Whiteboard" mode where users draw a tree, and the code generates automatically.

Conclusion

CodeStruct isn't just a study tool; it's an attempt to make computer science education adaptive. By combining standard web development with data mining, we can move away from rote memorization toward deep, visual understanding.