/leetcode-teacher

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, tim