16-Week Study Plan · Interview Practice

Phases

Phase	Weeks	DSA Focus Area	Key Concepts	System Design Topic	Difficulty Mix	Cumulative Problems
Phase 1	Wks 1–2	Foundations	Arrays, Strings, Hashing, Two Pointers, Sliding Window	Scalability & Basics	80% Easy / 20% Med	60
Phase 2	Wks 3–4	Linear Structures	Linked Lists, Stacks, Queues, Monotonic Structures	Storage & Caching	60% Easy / 40% Med	120
Phase 3	Wks 5–6	Trees & Graphs	Binary Trees, BST, Tries, Graph BFS/DFS, Union-Find	Distributed Systems Intro	40% Easy / 50% Med / 10% Hard	200
Phase 4	Wks 7–8	Recursion & DP	Backtracking, 1D DP, 2D DP, Greedy	Design Deep Dives I	20% Easy / 60% Med / 20% Hard	280
Phase 5	Wks 9–10	Advanced Algorithms	Heaps, Advanced Graphs, Intervals, Bit Manipulation	Design Deep Dives II	10% Easy / 60% Med / 30% Hard	350
Phase 6	Wks 11–12	Hard & Patterns	Hard DP, Advanced Trees, Segment Trees, Math	Design Deep Dives III	5% Easy / 50% Med / 45% Hard	410
Phase 7	Wks 13–14	Mock & Review	Mixed company-tagged sets, timed contests	Full Mock System Designs	Company-Specific Mix	460
Phase 8	Wks 15–16	Final Sprint	Weak-area revisit, top 75 NeetCode revisit	Behavioral + SD Combos	Interview-Intensity	500+

Weekly schedule

Week 1: Arrays & Hashing
Phase 1 · target 25 problems
System design:
Scalability 101: vertical vs horizontal, CAP theorem basics
Deep dive:
Understand SLA, SLO, SLI; latency vs throughput
Goal:
Nail HashMap O(1) lookups
Checkpoint:
Can you solve Two Sum 5 ways?
0 of 7 solved
- Two SumEasy
- Valid AnagramEasy
- Contains DuplicateEasy
- Group AnagramsMed.
- Top K Frequent ElementsMed.
- Product of Array Except SelfMed.
- Longest Consecutive SequenceMed.
Week 2: Two Pointers + Sliding Window
Phase 1 · target 20 problems
System design:
Load Balancers deep dive: L4 vs L7, algorithms
Deep dive:
Design a simple API gateway
Goal:
Master variable-window pattern
Checkpoint:
Solve Min Window Substring from scratch
0 of 6 solved
- Valid PalindromeEasy
- 3SumMed.
- Container With Most WaterMed.
- Best Time to Buy and Sell StockEasy
- Longest Substring Without Repeating CharactersMed.
- Minimum Window SubstringHard
Week 3: Stack + Queues
Phase 2 · target 20 problems
System design:
Caching: Redis internals, eviction, cache patterns
Deep dive:
Design a distributed cache (Redis-like)
Goal:
Monotonic stack mastery
Checkpoint:
Implement LRU Cache from memory
0 of 6 solved
- Valid ParenthesesEasy
- Min StackMed.
- Daily TemperaturesMed.
- Car FleetMed.
- Largest Rectangle in HistogramHard
- Sliding Window MaximumHard
Week 4: Linked Lists
Phase 2 · target 20 problems
System design:
Databases: SQL indexing, query planning, ACID
Deep dive:
Design URL shortener
Goal:
Pointer manipulation fluency
Checkpoint:
No bugs in LL reversal
0 of 6 solved
- Reverse Linked ListEasy
- Merge Two Sorted ListsEasy
- Reorder ListMed.
- Remove Nth Node From End of ListMed.
- LRU CacheMed.
- Merge k Sorted ListsHard
Week 5: Binary Search
Phase 3 · target 20 problems
System design:
NoSQL: DynamoDB, Cassandra, consistency models
Deep dive:
Design a KV store
Goal:
Master search on answer
Checkpoint:
Solve Median Two Arrays without hints
0 of 6 solved
- Binary SearchEasy
- Search in Rotated Sorted ArrayMed.
- Find Minimum in Rotated Sorted ArrayMed.
- Search a 2D MatrixMed.
- Koko Eating BananasMed.
- Median of Two Sorted ArraysHard
Week 6: Trees — BFS/DFS
Phase 3 · target 20 problems
System design:
API Design: REST principles, pagination, versioning
Deep dive:
Design Twitter API
Goal:
Tree recursion mental model
Checkpoint:
Implement iterative in-order traversal
0 of 8 solved
- Invert Binary TreeEasy
- Maximum Depth of Binary TreeEasy
- Diameter of Binary TreeEasy
- Binary Tree Level Order TraversalMed.
- Binary Tree Right Side ViewMed.
- Balanced Binary TreeEasy
- Same TreeEasy
- Subtree of Another TreeEasy
Week 7: BST + Trie
Phase 3 · target 20 problems
System design:
Message Queues: Kafka architecture, partitions, consumer groups
Deep dive:
Design notification system
Goal:
BST in-order = sorted; Trie prefix power
Checkpoint:
Build Trie from scratch
0 of 6 solved
Week 8: Graphs — BFS/DFS
Phase 3 · target 25 problems
System design:
Consistent Hashing + Sharding
Deep dive:
Design distributed cache with sharding
Goal:
DFS/BFS template mastery
Checkpoint:
Topological sort both BFS & DFS
0 of 7 solved
- Number of IslandsMed.
- Clone GraphMed.
- Course ScheduleMed.
- Course Schedule IIMed.
- Pacific Atlantic Water FlowMed.
- Rotting OrangesMed.
- Word LadderHard
Week 9: 1D DP
Phase 4 · target 25 problems
System design:
Rate Limiting deep dive: token bucket, leaky bucket
Deep dive:
Design API rate limiter
Goal:
Define dp[i] precisely before coding
Checkpoint:
Coin Change bottom-up and top-down
0 of 9 solved
- Climbing StairsEasy
- House RobberMed.
- House Robber IIMed.
- Longest Increasing SubsequenceMed.
- Coin ChangeMed.
- Word BreakMed.
- Decode WaysMed.
- Palindromic SubstringsMed.
- Maximum Product SubarrayMed.
Week 10: Backtracking + Greedy
Phase 4 · target 25 problems
System design:
Blob Storage + CDN: S3, CloudFront, presigned URLs
Deep dive:
Design photo sharing (Instagram)
Goal:
Decision tree visualization
Checkpoint:
N-Queens with pruning from memory
0 of 9 solved
- SubsetsMed.
- Combination SumMed.
- Combination Sum IIMed.
- PermutationsMed.
- Palindrome PartitioningMed.
- N-QueensHard
- Jump GameMed.
- Jump Game IIMed.
- Gas StationMed.
Week 11: 2D DP
Phase 4 · target 20 problems
System design:
Search systems: Elasticsearch, inverted index, ranking
Deep dive:
Design type-ahead / autocomplete
Goal:
DP table transitions clarity
Checkpoint:
Edit Distance with DP table drawn out
0 of 8 solved
- Unique PathsMed.
- Longest Common SubsequenceMed.
- Edit DistanceMed.
- Interleaving StringMed.
- Burst BalloonsHard
- Best Time to Buy and Sell Stock IIIHard
- Best Time to Buy and Sell Stock IVHard
- Distinct SubsequencesHard
Week 12: Heaps + Intervals
Phase 5 · target 20 problems
System design:
Real-time systems: WebSockets, long-polling, SSE
Deep dive:
Design chat application (WhatsApp)
Goal:
Heap invariants; interval sweep line
Checkpoint:
Implement heap from scratch in Java
0 of 6 solved
- K Closest Points to OriginMed.
- Task SchedulerMed.
- Find Median from Data StreamHard
- Merge k Sorted ListsHard
- Non-overlapping IntervalsMed.
- Meeting Rooms IIMed.
Week 13: Advanced Graphs
Phase 5 · target 20 problems
System design:
Video Streaming: HLS, DASH, transcoding pipeline
Deep dive:
Design YouTube
Goal:
Dijkstra vs BFS: weighted vs unweighted
Checkpoint:
Implement Union-Find with path compression
0 of 7 solved
- Path With Minimum EffortMed.
- Redundant ConnectionMed.
- Number of Connected ComponentsMed.
- Min Cost to Connect All PointsMed.
- Network Delay TimeMed.
- Cheapest Flights Within K StopsMed.
- Alien DictionaryHard
Week 14: Hard DP + Bit Manip
Phase 6 · target 15 problems
System design:
Distributed transactions: Saga, 2PC; Observability stack
Deep dive:
Design booking system (Airbnb/Hotels)
Goal:
Hard DP pattern recognition
Checkpoint:
Solve 3 hard DP in one sitting timed
0 of 6 solved
- Regular Expression MatchingHard
- Wildcard MatchingHard
- Counting BitsEasy
- Single NumberEasy
- Single Number IIMed.
- Sum of Two IntegersMed.
Week 15: Mock Interviews — Mixed
Phase 7 · target 20 problems
System design:
Full mock SDs: 60-min timed — Uber, Google Drive, Twitter
Deep dive:
Practice talking through design out loud
Goal:
Interview simulation under pressure
Checkpoint:
Complete 2 full mock interviews
FAANG-tagged problems: Amazon 40, Google 40, Meta 30, Microsoft 30 — timed 45-min sessions per problem Start a mock interview or work through your review queue.
Week 16: Final Sprint + Revision
Phase 8 · target 20+ problems
System design:
Review all SD building blocks; practice trade-off discussions
Deep dive:
Behavioral + SD combos
Goal:
Confidence & polish
Checkpoint:
Can you do any problem in under 25 min?
Re-solve all flagged retry problems; NeetCode 75 speed run; any weak areas Start a mock interview or work through your review queue.

Daily routine

Time Block	Duration	Activity	What To Do	Notes
Block 1	30 min	Warm-up / Review	Re-read yesterday's notes, review 2–3 solved problems	Active recall, not passive reading
Block 2	60 min	New DSA Topic	Study concept deeply → understand intuition → code from scratch	No copy-paste; understand WHY
Block 3	30 min	Practice Problems	Solve 2–4 problems on current topic (timed: 20–25 min each)	Track in Problem Log sheet
Block 4	60 min	System Design	Study 1 SD concept + design a system end-to-end with trade-offs	Use the SD sheet as checklist
Buffer	—	Spaced Repetition	Flag hard problems for re-attempt in 3/7/14 days	Use the Retry Tracker sheet

Pattern recognition cheatsheet

Pattern	Recognize When…	Template / Approach	Time Complexity	Space Complexity	Gotchas
Sliding Window (Variable)	Max/min subarray satisfying a constraint; 'longest substring with...'	Expand right pointer always; shrink left when constraint violated; track window state with map/int	O(n)	O(k) window size	Define precisely when to shrink; avoid over-shrinking
Two Pointers (Opposite Ends)	Sorted array + pair/triplet sum; palindrome check; container problems	lo=0, hi=n-1; move based on comparison to target; sort first if needed	O(n log n) with sort	O(1)	Sort destroys index — use values; watch duplicate skipping in 3Sum
Fast & Slow Pointers	Cycle detection, finding middle, kth from end	slow=head, fast=head; slow moves 1, fast moves 2; check fast==slow for cycle	O(n)	O(1)	For find duplicate: Floyd's cycle = detect, find entry = cycle start
BFS (Level Order / Shortest Path)	Shortest path in unweighted graph; level-by-level processing	Queue with (node, dist/level); mark visited before enqueue not after dequeue	O(V+E)	O(V)	Mark visited at enqueue time to avoid TLE
DFS + Backtracking	Generate all combinations/permutations/subsets; constraint satisfaction	Choose → recurse → unchoose; prune early; track current path	O(2^n) or O(n!)	O(n) stack depth	Draw decision tree first; add index param to avoid reuse
Monotonic Stack (Decreasing)	Next Greater Element; temperatures; histogram rectangle	Maintain decreasing stack; pop when current > stack top; record answer at pop time	O(n)	O(n)	Know whether to store index vs value in stack
Binary Search on Answer	'Minimum maximum' or 'Maximum minimum'; feasibility function exists	lo=min_val, hi=max_val; binary search; write isValid(mid) function	O(n log(range))	O(1)	isValid() must be monotonic; think about lo/hi edge cases
Top-K with Heap	Kth largest/smallest; K most frequent; K closest	Min-heap of size K for Kth largest; pop when size>K; heap top = answer	O(n log k)	O(k)	Min-heap for top-K largest (counter-intuitive); max-heap for Kth smallest
1D DP — Knapsack	Include/exclude decision; optimal value with constraint	dp[i] = max/min considering first i items; dp[i] = max(dp[i-1], dp[i-w]+val)	O(n*W)	O(n) or O(W) optimized	Traverse inner loop backwards for 0/1 (avoid reuse)
2D DP — Two Sequences	LCS, Edit Distance, Interleaving — comparing two strings/arrays	dp[i][j] = answer for s1[:i] and s2[:j]; fill row by row	O(m*n)	O(m*n) or O(n) optimized	Define dp[0][j] and dp[i][0] base cases carefully
Union-Find	Connected components; dynamic connectivity; cycle in undirected graph	find() with path compression; union() with rank; detect cycle if find(u)==find(v) before union	O(α(n)) ≈ O(1)	O(n)	Always implement both path compression AND union by rank
Trie	Prefix matching; word search; autocomplete	TrieNode has children[26] and isEnd; insert char by char; search/startsWith iterate	O(L) per op	O(L*N) total nodes	Use HashMap<Character, TrieNode> for flexible char sets
Graph Topological Sort	Dependency ordering; course scheduling; build order	BFS (Kahn's): in-degree array + queue; DFS: post-order reversal	O(V+E)	O(V+E)	Cycle = no valid topological order; check result size == V
Dijkstra's Algorithm	Shortest path in weighted graph with non-negative weights	Min-heap (dist, node); relax neighbors; skip stale entries	O((V+E) log V)	O(V)	Does NOT work with negative edges; use Bellman-Ford then
Interval Merge/Overlap	Merging overlapping intervals; scheduling conflicts	Sort by start; if curr.start <= prev.end → merge (update end); else add to result	O(n log n)	O(n)	Sort by start for merge; sort by end for greedy scheduling

16-Week Interview Plan

Phases

Weekly schedule

Week 1: Arrays & Hashing

Week 2: Two Pointers + Sliding Window

Week 3: Stack + Queues

Week 4: Linked Lists

Week 5: Binary Search

Week 6: Trees — BFS/DFS

Week 7: BST + Trie

Week 8: Graphs — BFS/DFS

Week 9: 1D DP

Week 10: Backtracking + Greedy

Week 11: 2D DP

Week 12: Heaps + Intervals

Week 13: Advanced Graphs

Week 14: Hard DP + Bit Manip

Week 15: Mock Interviews — Mixed

Week 16: Final Sprint + Revision

Daily routine

Pattern recognition cheatsheet