leetcode-teacher

What this skill does

# 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 R