Initial commit
This commit is contained in:
Zhongwei Li
469
skills/leetcode-teacher/references/patterns.md
Normal file
469
skills/leetcode-teacher/references/patterns.md
Normal file
@@ -0,0 +1,469 @@
|
||||
# LeetCode Patterns Reference
|
||||
|
||||
The 20 essential coding patterns for technical interviews with templates and real product examples.
|
||||
|
||||
## Pattern 1: Two Pointers
|
||||
|
||||
**When to Use:** Find pairs, triplets, or process sorted arrays
|
||||
**Time:** O(n), **Space:** O(1)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def two_pointers(arr):
|
||||
left, right = 0, len(arr) - 1
|
||||
|
||||
while left < right:
|
||||
# Process current pair
|
||||
if condition:
|
||||
# Found solution
|
||||
return [left, right]
|
||||
elif arr[left] + arr[right] < target:
|
||||
left += 1
|
||||
else:
|
||||
right -= 1
|
||||
|
||||
return []
|
||||
```
|
||||
|
||||
### Real Example: Instagram Mutual Likes
|
||||
```python
|
||||
def find_mutual_likes(user_ids, target_sum):
|
||||
"""Find two users whose IDs sum to target"""
|
||||
left, right = 0, len(user_ids) - 1
|
||||
|
||||
while left < right:
|
||||
current_sum = user_ids[left] + user_ids[right]
|
||||
|
||||
if current_sum == target_sum:
|
||||
return [left, right]
|
||||
elif current_sum < target_sum:
|
||||
left += 1
|
||||
else:
|
||||
right -= 1
|
||||
|
||||
return []
|
||||
```
|
||||
|
||||
## Pattern 2: Sliding Window
|
||||
|
||||
**When to Use:** Find subarray/substring with property
|
||||
**Time:** O(n), **Space:** O(k)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def sliding_window(arr, k):
|
||||
window_start = 0
|
||||
max_sum = 0
|
||||
window_sum = 0
|
||||
|
||||
for window_end in range(len(arr)):
|
||||
window_sum += arr[window_end]
|
||||
|
||||
if window_end >= k - 1:
|
||||
max_sum = max(max_sum, window_sum)
|
||||
window_sum -= arr[window_start]
|
||||
window_start += 1
|
||||
|
||||
return max_sum
|
||||
```
|
||||
|
||||
### Real Example: Twitter Trending Topics
|
||||
```python
|
||||
def trending_in_window(tweets, time_window):
|
||||
"""Find most mentioned hashtag in time window"""
|
||||
hashtag_count = {}
|
||||
max_count = 0
|
||||
trending = ""
|
||||
|
||||
for i, tweet in enumerate(tweets):
|
||||
# Add new tweet
|
||||
if tweet.hashtag in hashtag_count:
|
||||
hashtag_count[tweet.hashtag] += 1
|
||||
else:
|
||||
hashtag_count[tweet.hashtag] = 1
|
||||
|
||||
# Remove old tweets outside window
|
||||
if i >= time_window:
|
||||
old_tag = tweets[i - time_window].hashtag
|
||||
hashtag_count[old_tag] -= 1
|
||||
if hashtag_count[old_tag] == 0:
|
||||
del hashtag_count[old_tag]
|
||||
|
||||
# Track max
|
||||
for tag, count in hashtag_count.items():
|
||||
if count > max_count:
|
||||
max_count = count
|
||||
trending = tag
|
||||
|
||||
return trending
|
||||
```
|
||||
|
||||
## Pattern 3: Fast & Slow Pointers
|
||||
|
||||
**When to Use:** Detect cycles, find middle element
|
||||
**Time:** O(n), **Space:** O(1)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def has_cycle(head):
|
||||
slow = fast = head
|
||||
|
||||
while fast and fast.next:
|
||||
slow = slow.next
|
||||
fast = fast.next.next
|
||||
|
||||
if slow == fast:
|
||||
return True
|
||||
|
||||
return False
|
||||
```
|
||||
|
||||
### Real Example: Package Manager Circular Dependency
|
||||
```python
|
||||
def detect_circular_dependency(package):
|
||||
"""Detect if package has circular dependencies"""
|
||||
slow = fast = package
|
||||
|
||||
while fast and fast.next_dependency:
|
||||
slow = slow.next_dependency
|
||||
fast = fast.next_dependency.next_dependency
|
||||
|
||||
if slow == fast:
|
||||
return True # Circular dependency found!
|
||||
|
||||
return False
|
||||
```
|
||||
|
||||
## Pattern 4: Merge Intervals
|
||||
|
||||
**When to Use:** Overlapping intervals, scheduling
|
||||
**Time:** O(n log n), **Space:** O(n)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def merge_intervals(intervals):
|
||||
if not intervals:
|
||||
return []
|
||||
|
||||
intervals.sort(key=lambda x: x[0])
|
||||
merged = [intervals[0]]
|
||||
|
||||
for current in intervals[1:]:
|
||||
last = merged[-1]
|
||||
|
||||
if current[0] <= last[1]:
|
||||
# Overlapping, merge
|
||||
merged[-1] = [last[0], max(last[1], current[1])]
|
||||
else:
|
||||
# Non-overlapping
|
||||
merged.append(current)
|
||||
|
||||
return merged
|
||||
```
|
||||
|
||||
### Real Example: Google Calendar Free Slots
|
||||
```python
|
||||
def find_free_slots(calendars, duration):
|
||||
"""Find free meeting slots for all attendees"""
|
||||
# Merge all busy times
|
||||
busy = []
|
||||
for calendar in calendars:
|
||||
busy.extend(calendar.busy_times)
|
||||
|
||||
busy.sort()
|
||||
merged_busy = merge_intervals(busy)
|
||||
|
||||
# Find gaps >= duration
|
||||
free_slots = []
|
||||
for i in range(len(merged_busy) - 1):
|
||||
gap_start = merged_busy[i][1]
|
||||
gap_end = merged_busy[i + 1][0]
|
||||
|
||||
if gap_end - gap_start >= duration:
|
||||
free_slots.append([gap_start, gap_end])
|
||||
|
||||
return free_slots
|
||||
```
|
||||
|
||||
## Pattern 5: Binary Search (Modified)
|
||||
|
||||
**When to Use:** Search in O(log n), find boundary
|
||||
**Time:** O(log n), **Space:** O(1)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def binary_search_modified(arr, target):
|
||||
left, right = 0, len(arr) - 1
|
||||
|
||||
while left <= right:
|
||||
mid = (left + right) // 2
|
||||
|
||||
if arr[mid] == target:
|
||||
return mid
|
||||
elif arr[mid] < target:
|
||||
left = mid + 1
|
||||
else:
|
||||
right = mid - 1
|
||||
|
||||
return -1
|
||||
```
|
||||
|
||||
### Real Example: GitHub Find Bug Introduction Version
|
||||
```python
|
||||
def find_first_bad_version(versions):
|
||||
"""Binary search to find when bug was introduced"""
|
||||
left, right = 0, len(versions) - 1
|
||||
first_bad = -1
|
||||
|
||||
while left <= right:
|
||||
mid = (left + right) // 2
|
||||
|
||||
if is_bad_version(versions[mid]):
|
||||
first_bad = mid
|
||||
right = mid - 1 # Look for earlier bad version
|
||||
else:
|
||||
left = mid + 1
|
||||
|
||||
return first_bad
|
||||
```
|
||||
|
||||
## Pattern 6: Top K Elements
|
||||
|
||||
**When to Use:** Find top/bottom K items
|
||||
**Time:** O(n log k), **Space:** O(k)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
import heapq
|
||||
|
||||
def top_k_elements(nums, k):
|
||||
# Min heap of size k
|
||||
min_heap = []
|
||||
|
||||
for num in nums:
|
||||
heapq.heappush(min_heap, num)
|
||||
|
||||
if len(min_heap) > k:
|
||||
heapq.heappop(min_heap)
|
||||
|
||||
return min_heap
|
||||
```
|
||||
|
||||
### Real Example: Reddit Top Posts
|
||||
```python
|
||||
def get_top_k_posts(posts, k):
|
||||
"""Get top K posts by upvotes"""
|
||||
min_heap = []
|
||||
|
||||
for post in posts:
|
||||
heapq.heappush(min_heap, (post.upvotes, post))
|
||||
|
||||
if len(min_heap) > k:
|
||||
heapq.heappop(min_heap)
|
||||
|
||||
return [post for (upvotes, post) in sorted(min_heap, reverse=True)]
|
||||
```
|
||||
|
||||
## Pattern 7: BFS (Breadth-First Search)
|
||||
|
||||
**When to Use:** Shortest path, level-order traversal
|
||||
**Time:** O(V + E), **Space:** O(V)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
from collections import deque
|
||||
|
||||
def bfs(root):
|
||||
if not root:
|
||||
return []
|
||||
|
||||
result = []
|
||||
queue = deque([root])
|
||||
|
||||
while queue:
|
||||
level_size = len(queue)
|
||||
|
||||
for _ in range(level_size):
|
||||
node = queue.popleft()
|
||||
result.append(node.val)
|
||||
|
||||
if node.left:
|
||||
queue.append(node.left)
|
||||
if node.right:
|
||||
queue.append(node.right)
|
||||
|
||||
return result
|
||||
```
|
||||
|
||||
### Real Example: LinkedIn Degrees of Connection
|
||||
```python
|
||||
def degrees_of_connection(user1, user2):
|
||||
"""Find shortest connection path between users"""
|
||||
if user1 == user2:
|
||||
return 0
|
||||
|
||||
visited = {user1}
|
||||
queue = deque([(user1, 0)])
|
||||
|
||||
while queue:
|
||||
current_user, degree = queue.popleft()
|
||||
|
||||
for connection in current_user.connections:
|
||||
if connection == user2:
|
||||
return degree + 1
|
||||
|
||||
if connection not in visited:
|
||||
visited.add(connection)
|
||||
queue.append((connection, degree + 1))
|
||||
|
||||
return -1 # Not connected
|
||||
```
|
||||
|
||||
## Pattern 8: DFS (Depth-First Search)
|
||||
|
||||
**When to Use:** Path finding, backtracking
|
||||
**Time:** O(V + E), **Space:** O(V)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def dfs(node, visited=None):
|
||||
if visited is None:
|
||||
visited = set()
|
||||
|
||||
if node in visited:
|
||||
return
|
||||
|
||||
visited.add(node)
|
||||
process(node)
|
||||
|
||||
for neighbor in node.neighbors:
|
||||
dfs(neighbor, visited)
|
||||
|
||||
return visited
|
||||
```
|
||||
|
||||
### Real Example: File System Path Finding
|
||||
```python
|
||||
def find_all_paths(start_dir, target_file):
|
||||
"""Find all paths to target file"""
|
||||
paths = []
|
||||
|
||||
def dfs(current_dir, path):
|
||||
if current_dir.name == target_file:
|
||||
paths.append(path + [current_dir.name])
|
||||
return
|
||||
|
||||
for subdir in current_dir.subdirectories:
|
||||
dfs(subdir, path + [current_dir.name])
|
||||
|
||||
dfs(start_dir, [])
|
||||
return paths
|
||||
```
|
||||
|
||||
## Pattern 9: Dynamic Programming
|
||||
|
||||
**When to Use:** Optimization, counting problems
|
||||
**Time:** Varies (often O(n²)), **Space:** O(n) or O(n²)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def dp_solution(n):
|
||||
# Initialize DP array
|
||||
dp = [0] * (n + 1)
|
||||
dp[0] = base_case
|
||||
|
||||
# Fill DP array
|
||||
for i in range(1, n + 1):
|
||||
dp[i] = transition(dp[i-1], dp[i-2], ...)
|
||||
|
||||
return dp[n]
|
||||
```
|
||||
|
||||
### Real Example: Minimum Venmo Transactions
|
||||
```python
|
||||
def min_transactions(debts):
|
||||
"""Minimum transactions to settle all debts"""
|
||||
# Calculate net balance for each person
|
||||
balance = {}
|
||||
for payer, payee, amount in debts:
|
||||
balance[payer] = balance.get(payer, 0) - amount
|
||||
balance[payee] = balance.get(payee, 0) + amount
|
||||
|
||||
# Remove zero balances
|
||||
amounts = [v for v in balance.values() if v != 0]
|
||||
|
||||
def dfs(idx):
|
||||
# Skip settled accounts
|
||||
while idx < len(amounts) and amounts[idx] == 0:
|
||||
idx += 1
|
||||
|
||||
if idx == len(amounts):
|
||||
return 0
|
||||
|
||||
min_trans = float('inf')
|
||||
|
||||
for i in range(idx + 1, len(amounts)):
|
||||
# Try settling idx with i
|
||||
if amounts[idx] * amounts[i] < 0: # Different signs
|
||||
amounts[i] += amounts[idx]
|
||||
min_trans = min(min_trans, 1 + dfs(idx + 1))
|
||||
amounts[i] -= amounts[idx] # Backtrack
|
||||
|
||||
return min_trans
|
||||
|
||||
return dfs(0)
|
||||
```
|
||||
|
||||
## Pattern 10: Backtracking
|
||||
|
||||
**When to Use:** Generate all combinations, permutations
|
||||
**Time:** Exponential, **Space:** O(n)
|
||||
|
||||
### Template (Python)
|
||||
```python
|
||||
def backtrack(path, choices):
|
||||
if is_solution(path):
|
||||
result.append(path[:])
|
||||
return
|
||||
|
||||
for choice in choices:
|
||||
# Make choice
|
||||
path.append(choice)
|
||||
|
||||
# Recurse
|
||||
backtrack(path, remaining_choices)
|
||||
|
||||
# Undo choice (backtrack)
|
||||
path.pop()
|
||||
```
|
||||
|
||||
### Real Example: Slack Channel Combinations
|
||||
```python
|
||||
def generate_team_combinations(members, team_size):
|
||||
"""Generate all possible teams of given size"""
|
||||
teams = []
|
||||
|
||||
def backtrack(start, current_team):
|
||||
if len(current_team) == team_size:
|
||||
teams.append(current_team[:])
|
||||
return
|
||||
|
||||
for i in range(start, len(members)):
|
||||
current_team.append(members[i])
|
||||
backtrack(i + 1, current_team)
|
||||
current_team.pop()
|
||||
|
||||
backtrack(0, [])
|
||||
return teams
|
||||
```
|
||||
|
||||
## Summary
|
||||
|
||||
Master these 10 core patterns (plus 10 more in advanced practice) and you'll be able to solve 90%+ of LeetCode problems. Focus on:
|
||||
|
||||
1. **Recognition**: "I've seen this pattern before"
|
||||
2. **Template**: "I know the code structure"
|
||||
3. **Adaptation**: "I can modify for this specific problem"
|
||||
4. **Optimization**: "I can improve time/space complexity"
|
||||
|
||||
Practice each pattern 5-10 times until it becomes second nature!
|
||||
Reference in New Issue
Block a user