--- name: leetcode-teacher description: Interactive LeetCode-style teacher for technical interview preparation. Generates coding playgrounds with real product challenges, teaches patterns and techniques, supports Python/TypeScript/Kotlin/Swift, and provides progressive difficulty training for data structures and algorithms. --- # LeetCode Teacher An interactive technical interview preparation teacher that generates engaging coding playgrounds with real-world product challenges, pattern recognition training, and multi-language support. ## What This Skill Does Transforms technical interview prep into interactive, practical experiences: - **Interactive Code Playgrounds** - Browser-based coding environments with instant feedback - **Multi-Language Support** - Python, TypeScript, Kotlin, Swift - **Real Product Challenges** - Practical scenarios from real companies - **Pattern Recognition** - Learn the 20 essential coding patterns - **Progressive Difficulty** - Easy ā†’ Medium ā†’ Hard ā†’ Expert - **Instant Feedback** - Run tests in real-time with detailed explanations - **Technique Teaching** - Master problem-solving approaches ## Why This Skill Matters **Traditional LeetCode practice:** - Abstract, disconnected problems - No pattern recognition guidance - Trial and error approach - Intimidating for beginners - Limited language options **With this skill:** - Real product scenarios - Pattern-based learning - Guided problem-solving - Progressive difficulty curve - Multi-language practice - Interactive, fun interface ## Core Principles ### 1. Pattern-First Learning - Recognize problem patterns - Apply proven templates - Build intuition through practice - Master one pattern at a time ### 2. Real Product Context - Instagram feed ranking - Uber trip matching - Netflix recommendation - Slack message search - Amazon inventory management ### 3. Progressive Difficulty - Start with fundamentals - Build complexity gradually - Unlock advanced patterns - Track skill progression ### 4. Multi-Language Mastery - Practice in your target language - Compare implementations - Learn language-specific tricks - Interview in any language ### 5. Interactive Learning - Write code in browser - Run tests instantly - Get hints when stuck - See optimal solutions - Track progress ## Problem Patterns Covered ### Array & String Patterns **1. Two Pointers** ``` Pattern: Use two pointers to scan array Use when: Need to find pairs, triplets, or subarrays Example: "Find Instagram users who like each other" Complexity: O(n) time, O(1) space ``` **2. Sliding Window** ``` Pattern: Maintain a window that slides through array Use when: Need to find subarray with certain property Example: "Find trending topics in last N tweets" Complexity: O(n) time, O(k) space ``` **3. Fast & Slow Pointers** ``` Pattern: Two pointers moving at different speeds Use when: Detect cycles, find middle element Example: "Detect circular dependency in package manager" Complexity: O(n) time, O(1) space ``` ### Tree & Graph Patterns **4. Tree BFS** ``` Pattern: Level-order traversal using queue Use when: Need level-by-level processing Example: "Show friends by degree of connection" Complexity: O(n) time, O(w) space (w = max width) ``` **5. Tree DFS** ``` Pattern: Preorder, inorder, or postorder traversal Use when: Need to explore all paths Example: "Find all paths in file system" Complexity: O(n) time, O(h) space (h = height) ``` **6. Graph BFS** ``` Pattern: Explore neighbors level by level Use when: Shortest path, level-based exploration Example: "Find shortest connection path on LinkedIn" Complexity: O(V + E) time, O(V) space ``` **7. Graph DFS** ``` Pattern: Explore as far as possible before backtracking Use when: Path finding, cycle detection Example: "Detect circular references in social graph" Complexity: O(V + E) time, O(V) space ``` **8. Topological Sort** ``` Pattern: Order nodes by dependencies Use when: Task scheduling, build systems Example: "Order courses based on prerequisites" Complexity: O(V + E) time, O(V) space ``` ### Dynamic Programming Patterns **9. 0/1 Knapsack** ``` Pattern: Include or exclude each item Use when: Optimization with constraints Example: "Select best ads within budget" Complexity: O(n * capacity) time and space ``` **10. Unbounded Knapsack** ``` Pattern: Can use item unlimited times Use when: Coin change, combinations Example: "Minimum transactions to reach balance" Complexity: O(n * target) time and space ``` **11. Fibonacci Numbers** ``` Pattern: Current state depends on previous states Use when: Climbing stairs, tiling problems Example: "Ways to navigate through app screens" Complexity: O(n) time, O(1) space optimized ``` **12. Longest Common Subsequence** ``` Pattern: Compare two sequences Use when: Diff tools, edit distance Example: "Find similar code snippets" Complexity: O(m * n) time and space ``` ### Other Essential Patterns **13. Modified Binary Search** ``` Pattern: Binary search on sorted or rotated array Use when: Search in O(log n) Example: "Find version when bug was introduced" Complexity: O(log n) time, O(1) space ``` **14. Top K Elements** ``` Pattern: Use heap to track K largest/smallest Use when: Finding top items Example: "Get top K trending hashtags" Complexity: O(n log k) time, O(k) space ``` **15. K-Way Merge** ``` Pattern: Merge K sorted arrays/lists Use when: Combining sorted data Example: "Merge activity feeds from K users" Complexity: O(n log k) time, O(k) space ``` **16. Backtracking** ``` Pattern: Try all possibilities with pruning Use when: Generate permutations, combinations Example: "Generate all valid parentheses combinations" Complexity: Varies, often exponential ``` **17. Union Find** ``` Pattern: Track connected components Use when: Network connectivity, grouping Example: "Find connected friend groups" Complexity: O(Ī±(n)) amortized per operation ``` **18. Intervals** ``` Pattern: Merge, insert, or find overlapping intervals Use when: Calendar scheduling, time ranges Example: "Find free meeting slots" Complexity: O(n log n) time, O(n) space ``` **19. Monotonic Stack** ``` Pattern: Maintain increasing/decreasing stack Use when: Next greater/smaller element Example: "Stock price span calculation" Complexity: O(n) time, O(n) space ``` **20. Trie** ``` Pattern: Prefix tree for string operations Use when: Autocomplete, prefix matching Example: "Implement search autocomplete" Complexity: O(m) time per operation (m = word length) ``` ## Real Product Challenge Examples ### Easy Level **Instagram: Like Counter** ``` Real Scenario: Count how many times user's posts were liked today Pattern: Hash Map Data Structure: Dictionary/HashMap Languages: Python, TypeScript, Kotlin, Swift ``` **Slack: Unread Messages** ``` Real Scenario: Find first unread message in channel Pattern: Linear Search with Flag Data Structure: Array Teaches: Early termination ``` **Uber: Calculate Fare** ``` Real Scenario: Compute trip cost based on distance and time Pattern: Simple Calculation Data Structure: Numbers Teaches: Math operations, rounding ``` ### Medium Level **Netflix: Top N Recommendations** ``` Real Scenario: Find top N movies by rating Pattern: Top K Elements (Heap) Data Structure: Priority Queue Teaches: Heap operations, partial sorting ``` **Amazon: Inventory Management** ``` Real Scenario: Find products running low in stock Pattern: Filtering with Threshold Data Structure: Array + HashMap Teaches: Multi-criteria filtering ``` **Twitter: Trending Hashtags** ``` Real Scenario: Find most used hashtags in time window Pattern: Sliding Window + Frequency Count Data Structure: Queue + HashMap Teaches: Time-based window management ``` **LinkedIn: Degrees of Connection** ``` Real Scenario: Find connection path between two users Pattern: BFS Data Structure: Graph (Adjacency List) Teaches: Shortest path, level tracking ``` ### Hard Level **Google Calendar: Find Meeting Slots** ``` Real Scenario: Find free time slots for all attendees Pattern: Interval Merging Data Structure: Array of Intervals Teaches: Sorting, merging overlapping intervals ``` **Spotify: Playlist Shuffle** ``` Real Scenario: True random shuffle avoiding artist repetition Pattern: Modified Fisher-Yates Data Structure: Array Teaches: Randomization with constraints ``` **GitHub: Merge Conflict Resolution** ``` Real Scenario: Find longest common subsequence in files Pattern: Dynamic Programming (LCS) Data Structure: 2D Array Teaches: DP state definition, optimization ``` **Airbnb: Search Ranking** ``` Real Scenario: Rank listings by multiple weighted criteria Pattern: Custom Sorting + Heap Data Structure: Priority Queue with Comparator Teaches: Complex comparisons, tie-breaking ``` ## Interactive Playground Example ### Python Playground ```html šŸš€ LeetCode Teacher - Two Sum (Instagram Likes)

šŸŽÆ Two Sum

Easy Pattern: Hash Map Array

šŸ“± Real Product Scenario: Instagram Likes

You're building Instagram's "Mutual Likes" feature. Given an array of user IDs who liked your post and a target sum, find two users whose IDs add up to the target.

Problem:

Given an array of integers nums and an integer target, return indices of two numbers that add up to target.

Example:

Input: nums = [2, 7, 11, 15], target = 9
Output: [0, 1]
Explanation: nums[0] + nums[1] = 2 + 7 = 9

Constraints:

  • 2 ā‰¤ nums.length ā‰¤ 10ā“
  • Only one valid answer exists
  • Can't use the same element twice
0
Tests Run
0
Passed
0
Attempts

šŸ’» Your Solution (Python)

Click "Run Tests" to test your solution...
``` **Features:** - Interactive code editor - Real-time test execution - Progressive hints - Visual test results - Pattern badges - Progress tracking ## Language Support ### Python ```python # Hash Map pattern def two_sum(nums: List[int], target: int) -> List[int]: seen = {} for i, num in enumerate(nums): complement = target - num if complement in seen: return [seen[complement], i] seen[num] = i return [] ``` ### TypeScript ```typescript // Hash Map pattern function twoSum(nums: number[], target: number): number[] { const seen = new Map(); for (let i = 0; i < nums.length; i++) { const complement = target - nums[i]; if (seen.has(complement)) { return [seen.get(complement)!, i]; } seen.set(nums[i], i); } return []; } ``` ### Kotlin ```kotlin // Hash Map pattern fun twoSum(nums: IntArray, target: Int): IntArray { val seen = mutableMapOf() nums.forEachIndexed { i, num -> val complement = target - num if (seen.containsKey(complement)) { return intArrayOf(seen[complement]!!, i) } seen[num] = i } return intArrayOf() } ``` ### Swift ```swift // Hash Map pattern func twoSum(_ nums: [Int], _ target: Int) -> [Int] { var seen = [Int: Int]() for (i, num) in nums.enumerated() { let complement = target - num if let j = seen[complement] { return [j, i] } seen[num] = i } return [] } ``` ## Problem Difficulty Progression ### Level 1: Fundamentals (Easy) - Arrays and strings - Basic hash maps - Simple two pointers - Linear search **Goal:** Build confidence, learn syntax ### Level 2: Pattern Recognition (Easy-Medium) - Sliding window - Two pointers advanced - Fast & slow pointers - Basic trees **Goal:** Recognize patterns ### Level 3: Core Algorithms (Medium) - BFS and DFS - Binary search variations - Basic DP - Heaps **Goal:** Master common patterns ### Level 4: Advanced Techniques (Medium-Hard) - Advanced DP - Graph algorithms - Backtracking - Tries **Goal:** Handle complex scenarios ### Level 5: Interview Ready (Hard) - System design integration - Optimization problems - Complex DP - Advanced graphs **Goal:** Ace any interview ## Learning Techniques Taught ### 1. Pattern Recognition ``` See problem ā†’ Identify pattern ā†’ Apply template ā†’ Optimize ``` ### 2. Time/Space Analysis ``` Always analyze: - Time complexity: O(?) - Space complexity: O(?) - Can we do better? ``` ### 3. Test-Driven Development ``` 1. Read problem 2. Write test cases 3. Think of edge cases 4. Code solution 5. Run tests 6. Optimize ``` ### 4. Optimization Journey ``` Brute Force ā†’ Identify bottleneck ā†’ Apply pattern ā†’ Optimize space ``` ### 5. Interview Communication ``` - State assumptions - Ask clarifying questions - Think out loud - Explain trade-offs - Discuss alternatives ``` ## Reference Materials All included in `/references`: - **patterns.md** - 20 essential patterns with templates - **data_structures.md** - Arrays, linked lists, trees, graphs, heaps - **problem_templates.md** - Code templates for each pattern - **complexity_guide.md** - Big O analysis and optimization ## Scripts All in `/scripts`: - **generate_playground.sh** - Create interactive coding environment - **generate_problem.sh** - Generate specific problem type - **generate_session.sh** - Create full practice session ## Best Practices ### DO: āœ… Start with brute force, then optimize āœ… Write test cases first āœ… Analyze time/space complexity āœ… Practice the same pattern multiple times āœ… Explain your approach out loud āœ… Use real product context to remember āœ… Code in your target interview language ### DON'T: āŒ Jump to optimal solution immediately āŒ Skip complexity analysis āŒ Memorize solutions without understanding āŒ Practice only easy problems āŒ Ignore edge cases āŒ Code in silence (practice explaining) āŒ Give up after one attempt ## Gamification ### Achievement System - šŸŒŸ **Pattern Master**: Solve 10 problems with same pattern - šŸ”„ **Streak**: 7 days in a row - āš” **Speed Demon**: Solve in under 15 minutes - šŸŽÆ **First Try**: Pass all tests on first attempt - šŸ† **100 Club**: Solve 100 problems - šŸ’Ž **Optimization**: Improve O(nĀ²) to O(n) - šŸ§  **No Hints**: Solve without any hints ### Progress Tracking - Problems solved by difficulty - Patterns mastered - Languages practiced - Success rate - Average time per problem - Streak counter ## Summary This skill transforms technical interview prep by: - **Real Product Context** - Learn through practical scenarios - **Pattern Recognition** - Master the 20 essential patterns - **Multi-Language** - Practice in Python, TypeScript, Kotlin, Swift - **Interactive** - Code in browser with instant feedback - **Progressive** - Build from fundamentals to expert - **Fun** - Gamified with achievements and progress tracking - **Practical** - Techniques that work in real interviews **"Master the patterns, ace the interview."** šŸš€ --- **Usage:** Ask for a specific pattern to practice, difficulty level, or real product scenario, and get an instant interactive coding playground!