| 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) |
