|
|
import gradio as gr |
|
|
import json |
|
|
from typing import Dict, List, Tuple, Set |
|
|
|
|
|
class DSALearningRoadmap: |
|
|
def __init__(self): |
|
|
self.topics_data = { |
|
|
"Arrays": { |
|
|
"difficulty": "Beginner", |
|
|
"prerequisites": [], |
|
|
"description": "Linear data structure storing elements in contiguous memory locations", |
|
|
"key_concepts": ["Indexing", "Traversal", "Insertion", "Deletion", "Searching"], |
|
|
"learning_path": [ |
|
|
"Understand array basics and memory layout", |
|
|
"Learn array operations (CRUD)", |
|
|
"Practice basic array problems", |
|
|
"Master array traversal patterns", |
|
|
"Solve sliding window problems" |
|
|
], |
|
|
"time_estimate": "1-2 weeks", |
|
|
"connects_to": ["Strings", "Sorting", "Searching", "Dynamic Programming", "Two Pointers"], |
|
|
"important_problems": [ |
|
|
"Two Sum", "Maximum Subarray", "Rotate Array", "Merge Sorted Arrays", "Find Duplicates" |
|
|
] |
|
|
}, |
|
|
"Strings": { |
|
|
"difficulty": "Beginner", |
|
|
"prerequisites": ["Arrays"], |
|
|
"description": "Sequence of characters, often implemented as character arrays", |
|
|
"key_concepts": ["String manipulation", "Pattern matching", "Substring operations", "String comparison"], |
|
|
"learning_path": [ |
|
|
"Learn string basics and operations", |
|
|
"Practice string manipulation problems", |
|
|
"Master substring and pattern matching", |
|
|
"Learn string algorithms (KMP, Rabin-Karp)", |
|
|
"Solve advanced string problems" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Arrays", "Hashing", "Tries", "Dynamic Programming"], |
|
|
"important_problems": [ |
|
|
"Valid Palindrome", "Longest Substring Without Repeating Characters", "Group Anagrams", "String to Integer", "Implement strStr()" |
|
|
] |
|
|
}, |
|
|
"Linked Lists": { |
|
|
"difficulty": "Beginner", |
|
|
"prerequisites": ["Arrays"], |
|
|
"description": "Linear data structure where elements are stored in nodes connected via pointers", |
|
|
"key_concepts": ["Pointers", "Node operations", "Traversal", "Insertion", "Deletion"], |
|
|
"learning_path": [ |
|
|
"Understand pointers and node structure", |
|
|
"Learn basic linked list operations", |
|
|
"Practice traversal and manipulation", |
|
|
"Master different types (singly, doubly, circular)", |
|
|
"Solve complex linked list problems" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Stacks", "Queues", "Trees", "Graphs", "Hashing"], |
|
|
"important_problems": [ |
|
|
"Reverse Linked List", "Merge Two Sorted Lists", "Detect Cycle", "Remove Nth Node", "Intersection of Two Linked Lists" |
|
|
] |
|
|
}, |
|
|
"Stacks": { |
|
|
"difficulty": "Beginner", |
|
|
"prerequisites": ["Arrays", "Linked Lists"], |
|
|
"description": "LIFO (Last In First Out) data structure", |
|
|
"key_concepts": ["Push", "Pop", "Peek", "Stack overflow", "Applications"], |
|
|
"learning_path": [ |
|
|
"Learn stack concept and operations", |
|
|
"Implement stack using arrays and linked lists", |
|
|
"Practice basic stack problems", |
|
|
"Learn stack applications (expression evaluation, parsing)", |
|
|
"Master advanced stack problems" |
|
|
], |
|
|
"time_estimate": "1-2 weeks", |
|
|
"connects_to": ["Queues", "Recursion", "Trees", "Graphs", "Dynamic Programming"], |
|
|
"important_problems": [ |
|
|
"Valid Parentheses", "Min Stack", "Evaluate Reverse Polish Notation", "Largest Rectangle in Histogram", "Daily Temperatures" |
|
|
] |
|
|
}, |
|
|
"Queues": { |
|
|
"difficulty": "Beginner", |
|
|
"prerequisites": ["Arrays", "Linked Lists"], |
|
|
"description": "FIFO (First In First Out) data structure", |
|
|
"key_concepts": ["Enqueue", "Dequeue", "Front", "Rear", "Circular queue"], |
|
|
"learning_path": [ |
|
|
"Learn queue concept and operations", |
|
|
"Implement queue using arrays and linked lists", |
|
|
"Practice basic queue problems", |
|
|
"Learn different types (circular, priority, deque)", |
|
|
"Master BFS and queue applications" |
|
|
], |
|
|
"time_estimate": "1-2 weeks", |
|
|
"connects_to": ["Stacks", "Trees", "Graphs", "BFS", "Priority Queues"], |
|
|
"important_problems": [ |
|
|
"Implement Queue using Stacks", "Sliding Window Maximum", "Design Circular Queue", "Rotting Oranges", "First Unique Character" |
|
|
] |
|
|
}, |
|
|
"Recursion": { |
|
|
"difficulty": "Intermediate", |
|
|
"prerequisites": ["Arrays", "Stacks"], |
|
|
"description": "Problem-solving technique where a function calls itself", |
|
|
"key_concepts": ["Base case", "Recursive case", "Call stack", "Memoization", "Tail recursion"], |
|
|
"learning_path": [ |
|
|
"Understand recursion concept and base cases", |
|
|
"Practice simple recursive problems", |
|
|
"Learn recursive patterns and techniques", |
|
|
"Master backtracking using recursion", |
|
|
"Optimize recursive solutions" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Dynamic Programming", "Trees", "Graphs", "Backtracking", "Divide and Conquer"], |
|
|
"important_problems": [ |
|
|
"Fibonacci Sequence", "Factorial", "Tower of Hanoi", "Generate Parentheses", "Permutations" |
|
|
] |
|
|
}, |
|
|
"Sorting": { |
|
|
"difficulty": "Intermediate", |
|
|
"prerequisites": ["Arrays", "Recursion"], |
|
|
"description": "Algorithms to arrange elements in a specific order", |
|
|
"key_concepts": ["Comparison sorting", "Time complexity", "Space complexity", "Stability", "In-place sorting"], |
|
|
"learning_path": [ |
|
|
"Learn basic sorting algorithms (bubble, selection, insertion)", |
|
|
"Master efficient sorting algorithms (merge, quick, heap)", |
|
|
"Understand time and space complexity analysis", |
|
|
"Practice sorting-based problems", |
|
|
"Learn specialized sorting techniques" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Arrays", "Divide and Conquer", "Heaps", "Searching", "Trees"], |
|
|
"important_problems": [ |
|
|
"Merge Intervals", "Sort Colors", "Kth Largest Element", "Meeting Rooms", "Largest Number" |
|
|
] |
|
|
}, |
|
|
"Searching": { |
|
|
"difficulty": "Intermediate", |
|
|
"prerequisites": ["Arrays", "Recursion", "Sorting"], |
|
|
"description": "Algorithms to find specific elements in data structures", |
|
|
"key_concepts": ["Linear search", "Binary search", "Search space", "Invariants", "Applications"], |
|
|
"learning_path": [ |
|
|
"Learn linear search and its applications", |
|
|
"Master binary search and its variants", |
|
|
"Practice search in rotated/modified arrays", |
|
|
"Learn search in 2D arrays and matrices", |
|
|
"Solve complex search problems" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Arrays", "Sorting", "Trees", "Graphs", "Two Pointers"], |
|
|
"important_problems": [ |
|
|
"Binary Search", "Find First and Last Position", "Search in Rotated Array", "Find Peak Element", "Search 2D Matrix" |
|
|
] |
|
|
}, |
|
|
"Trees": { |
|
|
"difficulty": "Intermediate", |
|
|
"prerequisites": ["Linked Lists", "Recursion", "Stacks", "Queues"], |
|
|
"description": "Hierarchical data structure with nodes connected by edges", |
|
|
"key_concepts": ["Root", "Leaves", "Height", "Depth", "Traversals", "Binary trees"], |
|
|
"learning_path": [ |
|
|
"Learn tree terminology and concepts", |
|
|
"Master tree traversals (inorder, preorder, postorder)", |
|
|
"Practice binary tree problems", |
|
|
"Learn binary search trees (BST)", |
|
|
"Solve advanced tree problems" |
|
|
], |
|
|
"time_estimate": "3-4 weeks", |
|
|
"connects_to": ["Graphs", "Heaps", "Tries", "Dynamic Programming", "DFS", "BFS"], |
|
|
"important_problems": [ |
|
|
"Maximum Depth of Binary Tree", "Validate Binary Search Tree", "Lowest Common Ancestor", "Binary Tree Level Order Traversal", "Serialize and Deserialize Binary Tree" |
|
|
] |
|
|
}, |
|
|
"Graphs": { |
|
|
"difficulty": "Advanced", |
|
|
"prerequisites": ["Trees", "Queues", "Stacks", "Recursion"], |
|
|
"description": "Non-linear data structure consisting of vertices and edges", |
|
|
"key_concepts": ["Vertices", "Edges", "Directed/Undirected", "Weighted/Unweighted", "Representation"], |
|
|
"learning_path": [ |
|
|
"Learn graph terminology and representation", |
|
|
"Master graph traversals (DFS, BFS)", |
|
|
"Practice basic graph problems", |
|
|
"Learn shortest path algorithms", |
|
|
"Solve complex graph problems" |
|
|
], |
|
|
"time_estimate": "4-5 weeks", |
|
|
"connects_to": ["Trees", "DFS", "BFS", "Dynamic Programming", "Greedy Algorithms"], |
|
|
"important_problems": [ |
|
|
"Clone Graph", "Number of Islands", "Course Schedule", "Shortest Path in Binary Matrix", "Word Ladder" |
|
|
] |
|
|
}, |
|
|
"Dynamic Programming": { |
|
|
"difficulty": "Advanced", |
|
|
"prerequisites": ["Arrays", "Recursion", "Trees"], |
|
|
"description": "Optimization technique using memoization to solve overlapping subproblems", |
|
|
"key_concepts": ["Optimal substructure", "Overlapping subproblems", "Memoization", "Tabulation", "State transitions"], |
|
|
"learning_path": [ |
|
|
"Understand DP concepts and when to use", |
|
|
"Learn basic DP patterns (fibonacci, climbing stairs)", |
|
|
"Practice 1D DP problems", |
|
|
"Master 2D DP problems", |
|
|
"Solve complex DP problems" |
|
|
], |
|
|
"time_estimate": "4-6 weeks", |
|
|
"connects_to": ["Arrays", "Strings", "Trees", "Graphs", "Greedy Algorithms"], |
|
|
"important_problems": [ |
|
|
"Climbing Stairs", "House Robber", "Coin Change", "Longest Common Subsequence", "Edit Distance" |
|
|
] |
|
|
}, |
|
|
"Hashing": { |
|
|
"difficulty": "Intermediate", |
|
|
"prerequisites": ["Arrays", "Strings"], |
|
|
"description": "Technique for fast data retrieval using hash functions", |
|
|
"key_concepts": ["Hash functions", "Hash tables", "Collision resolution", "Load factor", "Applications"], |
|
|
"learning_path": [ |
|
|
"Learn hash function concepts", |
|
|
"Understand hash table implementation", |
|
|
"Practice basic hashing problems", |
|
|
"Learn collision resolution techniques", |
|
|
"Master advanced hashing applications" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Arrays", "Strings", "Sets", "Maps", "Caching"], |
|
|
"important_problems": [ |
|
|
"Two Sum", "Group Anagrams", "First Non-Repeating Character", "Longest Substring Without Repeating Characters", "Design HashSet" |
|
|
] |
|
|
}, |
|
|
"Heaps": { |
|
|
"difficulty": "Advanced", |
|
|
"prerequisites": ["Trees", "Arrays", "Sorting"], |
|
|
"description": "Complete binary tree with heap property (min-heap or max-heap)", |
|
|
"key_concepts": ["Heap property", "Heapify", "Priority queue", "Heap operations", "Applications"], |
|
|
"learning_path": [ |
|
|
"Learn heap concepts and properties", |
|
|
"Implement heap operations", |
|
|
"Practice basic heap problems", |
|
|
"Master priority queue applications", |
|
|
"Solve complex heap problems" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Trees", "Sorting", "Graphs", "Greedy Algorithms", "Priority Queues"], |
|
|
"important_problems": [ |
|
|
"Kth Largest Element", "Merge K Sorted Lists", "Top K Frequent Elements", "Find Median from Data Stream", "Task Scheduler" |
|
|
] |
|
|
}, |
|
|
"Tries": { |
|
|
"difficulty": "Advanced", |
|
|
"prerequisites": ["Trees", "Strings"], |
|
|
"description": "Tree-like data structure for storing strings efficiently", |
|
|
"key_concepts": ["Prefix tree", "Autocomplete", "Word search", "Memory optimization", "Applications"], |
|
|
"learning_path": [ |
|
|
"Learn trie structure and operations", |
|
|
"Implement basic trie functionality", |
|
|
"Practice word-based problems", |
|
|
"Master prefix matching applications", |
|
|
"Solve complex trie problems" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Trees", "Strings", "DFS", "Backtracking"], |
|
|
"important_problems": [ |
|
|
"Implement Trie", "Word Search II", "Design Add and Search Words", "Longest Word in Dictionary", "Replace Words" |
|
|
] |
|
|
}, |
|
|
"Two Pointers": { |
|
|
"difficulty": "Intermediate", |
|
|
"prerequisites": ["Arrays", "Strings", "Sorting"], |
|
|
"description": "Technique using two pointers to solve problems efficiently", |
|
|
"key_concepts": ["Left-right pointers", "Fast-slow pointers", "Sliding window", "Meet in middle", "Optimization"], |
|
|
"learning_path": [ |
|
|
"Learn two-pointer technique basics", |
|
|
"Practice left-right pointer problems", |
|
|
"Master fast-slow pointer technique", |
|
|
"Learn sliding window applications", |
|
|
"Solve complex two-pointer problems" |
|
|
], |
|
|
"time_estimate": "2-3 weeks", |
|
|
"connects_to": ["Arrays", "Strings", "Linked Lists", "Sorting", "Searching"], |
|
|
"important_problems": [ |
|
|
"Two Sum II", "3Sum", "Container With Most Water", "Trapping Rain Water", "Longest Substring Without Repeating Characters" |
|
|
] |
|
|
}, |
|
|
"Greedy Algorithms": { |
|
|
"difficulty": "Advanced", |
|
|
"prerequisites": ["Sorting", "Arrays", "Graphs"], |
|
|
"description": "Problem-solving technique making locally optimal choices", |
|
|
"key_concepts": ["Greedy choice", "Local optimization", "Proof techniques", "Activity selection", "Optimization"], |
|
|
"learning_path": [ |
|
|
"Learn greedy algorithm concepts", |
|
|
"Practice basic greedy problems", |
|
|
"Master interval scheduling problems", |
|
|
"Learn graph-based greedy algorithms", |
|
|
"Solve complex greedy problems" |
|
|
], |
|
|
"time_estimate": "3-4 weeks", |
|
|
"connects_to": ["Sorting", "Graphs", "Dynamic Programming", "Heaps"], |
|
|
"important_problems": [ |
|
|
"Activity Selection", "Fractional Knapsack", "Minimum Spanning Tree", "Huffman Coding", "Gas Station" |
|
|
] |
|
|
}, |
|
|
"Backtracking": { |
|
|
"difficulty": "Advanced", |
|
|
"prerequisites": ["Recursion", "Trees", "Arrays"], |
|
|
"description": "Algorithmic technique for finding solutions by exploring all possibilities", |
|
|
"key_concepts": ["State space", "Pruning", "Constraint satisfaction", "Recursive exploration", "Optimization"], |
|
|
"learning_path": [ |
|
|
"Learn backtracking concepts", |
|
|
"Practice basic backtracking problems", |
|
|
"Master constraint satisfaction problems", |
|
|
"Learn optimization techniques", |
|
|
"Solve complex backtracking problems" |
|
|
], |
|
|
"time_estimate": "3-4 weeks", |
|
|
"connects_to": ["Recursion", "Trees", "Graphs", "Dynamic Programming"], |
|
|
"important_problems": [ |
|
|
"N-Queens", "Sudoku Solver", "Word Search", "Combination Sum", "Palindrome Partitioning" |
|
|
] |
|
|
}, |
|
|
"Divide and Conquer": { |
|
|
"difficulty": "Advanced", |
|
|
"prerequisites": ["Recursion", "Sorting", "Arrays"], |
|
|
"description": "Problem-solving technique dividing problems into smaller subproblems", |
|
|
"key_concepts": ["Divide", "Conquer", "Combine", "Recurrence relations", "Master theorem"], |
|
|
"learning_path": [ |
|
|
"Learn divide and conquer concepts", |
|
|
"Practice basic divide and conquer problems", |
|
|
"Master sorting algorithms using D&C", |
|
|
"Learn advanced applications", |
|
|
"Analyze time complexity" |
|
|
], |
|
|
"time_estimate": "3-4 weeks", |
|
|
"connects_to": ["Recursion", "Sorting", "Trees", "Dynamic Programming"], |
|
|
"important_problems": [ |
|
|
"Merge Sort", "Quick Sort", "Maximum Subarray", "Closest Pair of Points", "Strassen's Matrix Multiplication" |
|
|
] |
|
|
} |
|
|
} |
|
|
|
|
|
def get_topic_roadmap(self, topic_name: str) -> str: |
|
|
"""Generate detailed roadmap for a specific topic""" |
|
|
if topic_name not in self.topics_data: |
|
|
return "❌ Topic not found! Please select a valid topic." |
|
|
|
|
|
topic = self.topics_data[topic_name] |
|
|
|
|
|
|
|
|
roadmap = f""" |
|
|
# 🎯 {topic_name} Learning Roadmap |
|
|
|
|
|
## 📊 Overview |
|
|
**Difficulty Level:** {topic['difficulty']} |
|
|
**Estimated Time:** {topic['time_estimate']} |
|
|
**Description:** {topic['description']} |
|
|
|
|
|
## 🔗 Prerequisites |
|
|
""" |
|
|
|
|
|
if topic['prerequisites']: |
|
|
roadmap += "**You should learn these topics first:**\n" |
|
|
for prereq in topic['prerequisites']: |
|
|
roadmap += f"• {prereq}\n" |
|
|
else: |
|
|
roadmap += "**Great news!** This is a foundational topic - no prerequisites needed! 🎉\n" |
|
|
|
|
|
roadmap += f""" |
|
|
## 🗺️ Learning Path |
|
|
**Follow this step-by-step approach:** |
|
|
|
|
|
""" |
|
|
|
|
|
for i, step in enumerate(topic['learning_path'], 1): |
|
|
roadmap += f"{i}. {step}\n" |
|
|
|
|
|
roadmap += f""" |
|
|
## 🔑 Key Concepts to Master |
|
|
""" |
|
|
for concept in topic['key_concepts']: |
|
|
roadmap += f"• {concept}\n" |
|
|
|
|
|
roadmap += f""" |
|
|
## 💡 Important Problems to Practice |
|
|
""" |
|
|
for problem in topic['important_problems']: |
|
|
roadmap += f"• {problem}\n" |
|
|
|
|
|
roadmap += f""" |
|
|
## 🌐 Connected Topics |
|
|
**After mastering {topic_name}, you'll be ready for:** |
|
|
""" |
|
|
for connected in topic['connects_to']: |
|
|
roadmap += f"• {connected}\n" |
|
|
|
|
|
return roadmap |
|
|
|
|
|
def get_prerequisites_chain(self, topic_name: str) -> str: |
|
|
"""Get the complete prerequisite chain for a topic""" |
|
|
if topic_name not in self.topics_data: |
|
|
return "❌ Topic not found!" |
|
|
|
|
|
visited = set() |
|
|
chain = [] |
|
|
|
|
|
def dfs_prerequisites(topic): |
|
|
if topic in visited or topic not in self.topics_data: |
|
|
return |
|
|
|
|
|
visited.add(topic) |
|
|
|
|
|
|
|
|
for prereq in self.topics_data[topic]['prerequisites']: |
|
|
dfs_prerequisites(prereq) |
|
|
|
|
|
chain.append(topic) |
|
|
|
|
|
dfs_prerequisites(topic_name) |
|
|
|
|
|
if len(chain) <= 1: |
|
|
return f"🎉 **{topic_name}** is a foundational topic - you can start learning it right away!" |
|
|
|
|
|
result = f"📚 **Complete Learning Path to Master {topic_name}:**\n\n" |
|
|
|
|
|
for i, topic in enumerate(chain, 1): |
|
|
difficulty = self.topics_data[topic]['difficulty'] |
|
|
time_est = self.topics_data[topic]['time_estimate'] |
|
|
|
|
|
if i == len(chain): |
|
|
result += f"🎯 **{i}. {topic}** (Your Target!) \n" |
|
|
else: |
|
|
result += f"📖 **{i}. {topic}** \n" |
|
|
|
|
|
result += f" *Difficulty: {difficulty} | Time: {time_est}*\n\n" |
|
|
|
|
|
total_topics = len(chain) |
|
|
result += f"**Total Topics to Cover:** {total_topics}\n" |
|
|
result += f"**Estimated Total Time:** {self._estimate_total_time(chain)}\n" |
|
|
|
|
|
return result |
|
|
|
|
|
def _estimate_total_time(self, chain: List[str]) -> str: |
|
|
"""Estimate total time needed for a chain of topics""" |
|
|
total_weeks = 0 |
|
|
for topic in chain: |
|
|
time_str = self.topics_data[topic]['time_estimate'] |
|
|
|
|
|
weeks = time_str.split()[0].split('-') |
|
|
avg_weeks = (int(weeks[0]) + int(weeks[-1])) / 2 |
|
|
total_weeks += avg_weeks |
|
|
|
|
|
return f"{int(total_weeks)} weeks" |
|
|
|
|
|
def get_topic_connections(self, topic_name: str) -> str: |
|
|
"""Show how a topic connects to other topics""" |
|
|
if topic_name not in self.topics_data: |
|
|
return "❌ Topic not found!" |
|
|
|
|
|
topic = self.topics_data[topic_name] |
|
|
|
|
|
result = f"🔗 **Topic Interconnections for {topic_name}**\n\n" |
|
|
|
|
|
|
|
|
result += "**📚 Prerequisites (Learn these first):**\n" |
|
|
if topic['prerequisites']: |
|
|
for prereq in topic['prerequisites']: |
|
|
result += f"• {prereq}\n" |
|
|
else: |
|
|
result += "• None - This is a foundational topic! 🎉\n" |
|
|
|
|
|
|
|
|
result += f"\n**➡️ What {topic_name} enables:**\n" |
|
|
for connected in topic['connects_to']: |
|
|
result += f"• {connected}\n" |
|
|
|
|
|
|
|
|
dependents = [] |
|
|
for other_topic, other_data in self.topics_data.items(): |
|
|
if topic_name in other_data['prerequisites']: |
|
|
dependents.append(other_topic) |
|
|
|
|
|
if dependents: |
|
|
result += f"\n**🎯 Topics that require {topic_name}:**\n" |
|
|
for dependent in dependents: |
|
|
result += f"• {dependent}\n" |
|
|
|
|
|
return result |
|
|
|
|
|
def get_difficulty_based_roadmap(self, difficulty: str) -> str: |
|
|
"""Get all topics for a specific difficulty level""" |
|
|
topics_by_difficulty = { |
|
|
'Beginner': [], |
|
|
'Intermediate': [], |
|
|
'Advanced': [] |
|
|
} |
|
|
|
|
|
for topic_name, topic_data in self.topics_data.items(): |
|
|
topics_by_difficulty[topic_data['difficulty']].append(topic_name) |
|
|
|
|
|
if difficulty not in topics_by_difficulty: |
|
|
return "❌ Invalid difficulty level!" |
|
|
|
|
|
result = f"📊 **{difficulty} Level DSA Topics**\n\n" |
|
|
|
|
|
topics = topics_by_difficulty[difficulty] |
|
|
if not topics: |
|
|
result += "No topics found for this difficulty level." |
|
|
return result |
|
|
|
|
|
for i, topic in enumerate(topics, 1): |
|
|
topic_data = self.topics_data[topic] |
|
|
result += f"**{i}. {topic}**\n" |
|
|
result += f" *Time: {topic_data['time_estimate']}*\n" |
|
|
result += f" *{topic_data['description']}*\n\n" |
|
|
|
|
|
return result |
|
|
|
|
|
def get_all_topics_overview(self) -> str: |
|
|
"""Get overview of all topics with their relationships""" |
|
|
result = "🗺️ **Complete DSA Topics Overview**\n\n" |
|
|
|
|
|
|
|
|
by_difficulty = {'Beginner': [], 'Intermediate': [], 'Advanced': []} |
|
|
for topic, data in self.topics_data.items(): |
|
|
by_difficulty[data['difficulty']].append(topic) |
|
|
|
|
|
for difficulty in ['Beginner', 'Intermediate', 'Advanced']: |
|
|
result += f"## {difficulty} Topics\n" |
|
|
for topic in by_difficulty[difficulty]: |
|
|
result += f"• **{topic}** ({self.topics_data[topic]['time_estimate']})\n" |
|
|
result += "\n" |
|
|
|
|
|
result += "**💡 Tips:**\n" |
|
|
result += "• Start with Beginner topics if you're new to DSA\n" |
|
|
result += "• Each topic builds upon previous knowledge\n" |
|
|
result += "• Practice problems regularly to reinforce concepts\n" |
|
|
result += "• Focus on understanding connections between topics\n" |
|
|
|
|
|
return result |
|
|
|
|
|
|
|
|
dsa_system = DSALearningRoadmap() |
|
|
|
|
|
|
|
|
all_topics = list(dsa_system.topics_data.keys()) |
|
|
difficulty_levels = ['All', 'Beginner', 'Intermediate', 'Advanced'] |
|
|
|
|
|
def generate_roadmap(topic_name): |
|
|
"""Generate roadmap for selected topic""" |
|
|
return dsa_system.get_topic_roadmap(topic_name) |
|
|
|
|
|
def show_prerequisites_chain(topic_name): |
|
|
"""Show complete prerequisite chain""" |
|
|
return dsa_system.get_prerequisites_chain(topic_name) |
|
|
|
|
|
def show_topic_connections(topic_name): |
|
|
"""Show topic interconnections""" |
|
|
return dsa_system.get_topic_connections(topic_name) |
|
|
|
|
|
def show_difficulty_roadmap(difficulty): |
|
|
"""Show topics by difficulty""" |
|
|
if difficulty == 'All': |
|
|
return dsa_system.get_all_topics_overview() |
|
|
return dsa_system.get_difficulty_based_roadmap(difficulty) |
|
|
|
|
|
|
|
|
with gr.Blocks(title="🎯 DSA Learning Roadmap", theme=gr.themes.Default()) as app: |
|
|
gr.Markdown(""" |
|
|
# 🎯 DSA Learning Roadmap Generator |
|
|
|
|
|
**Solve the problem of not knowing DSA prerequisites!** |
|
|
|
|
|
This tool helps you understand: |
|
|
- 📚 What to learn before tackling any DSA topic |
|
|
- 🗺️ Step-by-step learning paths |
|
|
- 🔗 How topics interconnect with each other |
|
|
- ⏱️ Time estimates for mastering each topic |
|
|
|
|
|
Select any topic below to get your personalized roadmap! |
|
|
""") |
|
|
|
|
|
with gr.Tabs(): |
|
|
|
|
|
with gr.TabItem("📖 Topic Roadmap"): |
|
|
gr.Markdown("### Get detailed roadmap for any DSA topic") |
|
|
|
|
|
topic_dropdown = gr.Dropdown( |
|
|
choices=all_topics, |
|
|
label="🎯 Select a DSA Topic", |
|
|
value="Arrays", |
|
|
info="Choose any topic to get a complete learning roadmap" |
|
|
) |
|
|
|
|
|
generate_btn = gr.Button("🚀 Generate Roadmap", variant="primary") |
|
|
roadmap_output = gr.Markdown(label="📋 Your Learning Roadmap") |
|
|
|
|
|
generate_btn.click( |
|
|
fn=generate_roadmap, |
|
|
inputs=topic_dropdown, |
|
|
outputs=roadmap_output |
|
|
) |
|
|
|
|
|
|
|
|
topic_dropdown.change( |
|
|
fn=generate_roadmap, |
|
|
inputs=topic_dropdown, |
|
|
outputs=roadmap_output |
|
|
) |
|
|
|
|
|
|
|
|
with gr.TabItem("🔗 Prerequisites Chain"): |
|
|
gr.Markdown("### See the complete learning path to master any topic") |
|
|
|
|
|
prereq_dropdown = gr.Dropdown( |
|
|
choices=all_topics, |
|
|
label="🎯 Select Target Topic", |
|
|
value="Dynamic Programming", |
|
|
info="See everything you need to learn before mastering this topic" |
|
|
) |
|
|
|
|
|
prereq_btn = gr.Button("📚 Show Learning Path", variant="primary") |
|
|
prereq_output = gr.Markdown(label="📋 Complete Learning Path") |
|
|
|
|
|
prereq_btn.click( |
|
|
fn=show_prerequisites_chain, |
|
|
inputs=prereq_dropdown, |
|
|
outputs=prereq_output |
|
|
) |
|
|
|
|
|
prereq_dropdown.change( |
|
|
fn=show_prerequisites_chain, |
|
|
inputs=prereq_dropdown, |
|
|
outputs=prereq_output |
|
|
) |
|
|
|
|
|
|
|
|
with gr.TabItem("🌐 Topic Connections"): |
|
|
gr.Markdown("### Understand how topics connect to each other") |
|
|
|
|
|
connection_dropdown = gr.Dropdown( |
|
|
choices=all_topics, |
|
|
label="🎯 Select Topic", |
|
|
value="Trees", |
|
|
info="See how this topic connects to other DSA concepts" |
|
|
) |
|
|
|
|
|
connection_btn = gr.Button("🔗 Show Connections", variant="primary") |
|
|
connection_output = gr.Markdown(label="📋 Topic Interconnections") |
|
|
|
|
|
connection_btn.click( |
|
|
fn=show_topic_connections, |
|
|
inputs=connection_dropdown, |
|
|
outputs=connection_output |
|
|
) |
|
|
|
|
|
connection_dropdown.change( |
|
|
fn=show_topic_connections, |
|
|
inputs=connection_dropdown, |
|
|
outputs=connection_output |
|
|
) |
|
|
|
|
|
|
|
|
with gr.TabItem("📊 By Difficulty"): |
|
|
gr.Markdown("### Browse topics by difficulty level") |
|
|
|
|
|
difficulty_dropdown = gr.Dropdown( |
|
|
choices=difficulty_levels, |
|
|
label="📈 Select Difficulty Level", |
|
|
value="All", |
|
|
info="View topics grouped by difficulty" |
|
|
) |
|
|
|
|
|
difficulty_btn = gr.Button("📊 Show Topics", variant="primary") |
|
|
difficulty_output = gr.Markdown(label="📋 Topics by Difficulty") |
|
|
|
|
|
difficulty_btn.click( |
|
|
fn=show_difficulty_roadmap, |
|
|
inputs=difficulty_dropdown, |
|
|
outputs=difficulty_output |
|
|
) |
|
|
|
|
|
difficulty_dropdown.change( |
|
|
fn=show_difficulty_roadmap, |
|
|
inputs=difficulty_dropdown, |
|
|
outputs=difficulty_output |
|
|
) |
|
|
|
|
|
|
|
|
gr.Markdown(""" |
|
|
--- |
|
|
### 💡 How to Use This Tool: |
|
|
1. **Topic Roadmap**: Get detailed learning plan for any specific topic |
|
|
2. **Prerequisites Chain**: See exactly what to learn before your target topic |
|
|
3. **Topic Connections**: Understand how topics relate to each other |
|
|
4. **By Difficulty**: Browse topics based on your current skill level |
|
|
|
|
|
### 🎯 Pro Tips: |
|
|
- Start with **Beginner** topics if you're new to DSA |
|
|
- Follow the **Prerequisites Chain** for optimal learning order |
|
|
- Practice the **Important Problems** listed in each roadmap |
|
|
- Use **Topic Connections** to plan your learning journey |
|
|
|
|
|
**Happy Learning! 🚀** |
|
|
""") |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
app.launch(share=True) |
