You now have the whole toolkit — 24 patterns, each with a template, a diagram, and a tested practice set. This final lesson is about turning that knowledge into a pass. Recognition is the skill, and recognition only comes from deliberate, timed practice against a curated list. Here is exactly how to do that.
The two canonical lists
Almost everyone who clears a MAANG coding round works through one of two famous lists. You do not need to grind 500 random problems; you need the right ~75–150.
- Blind 75 — the original essential list (75 problems) that a Meta engineer compiled. It has at least one problem per major pattern. If you only have a few weeks, do these.
- NeetCode 150 — Blind 75 plus 75 more, organised by exactly the categories this course teaches. This is the gold-standard list today. If you have 6–8 weeks, do all 150.
The good news: this course is structured around the same categories as NeetCode 150, and every lesson ships a companion practice page drawn from these lists, with tested solutions. Work the course and you are working the list.
How the course maps to NeetCode 150
| NeetCode 150 category | Course lesson(s) |
|---|---|
| Arrays & Hashing | Hash Maps & Frequency, Prefix Sums |
| Two Pointers | Two Pointers |
| Sliding Window | Sliding Window |
| Stack | Monotonic Stack |
| Binary Search | Binary Search |
| Linked List | Linked-List Reversal, Fast & Slow Pointers |
| Trees | Tree BFS, Tree DFS |
| Tries | Tries |
| Heap / Priority Queue | Heaps / Top-K |
| Backtracking | Backtracking |
| Graphs | Graphs |
| Advanced Graphs | Advanced Graphs |
| 1-D Dynamic Programming | Dynamic Programming I |
| 2-D Dynamic Programming | Dynamic Programming II |
| Greedy | Greedy |
| Intervals | Merge Intervals |
| Math & Geometry | Math & Geometry |
| Bit Manipulation | Bit Manipulation |
Beyond the list, the course adds material the harder interviews reach for: a data-structures reference, Advanced DP, String Algorithms, and designing a data structure (LRU/LFU and friends).
The 8-week schedule
Roughly 1–2 hours a day, 5–6 days a week. Each day: read the pattern (if new), then solve 2–4 problems from its practice page — timed (25–35 min each). If you blow the time, read the approach, understand it, and re-solve it from scratch the next day.
| Week | Focus | Patterns |
|---|---|---|
| 1 | Foundations | How interviews work, Big-O, Two Pointers, Sliding Window |
| 2 | Arrays & linked structures | Hash Maps, Prefix Sums, Fast & Slow, Linked-List Reversal |
| 3 | Stacks & search | Monotonic Stack, Binary Search, Merge Intervals |
| 4 | Trees & heaps | Tree BFS, Tree DFS, Heaps / Top-K, Tries |
| 5 | Recursion & graphs | Backtracking, Graphs, Advanced Graphs |
| 6 | Dynamic programming | DP I (1-D), DP II (2-D), Advanced DP |
| 7 | The rest + design | Greedy, Bit Manipulation, Math & Geometry, Design a Data Structure, String Algorithms |
| 8 | Mocks & review | Mixed timed sets + 1 mock interview every 2–3 days |
Every week, spend one session on a mixed set — 4–5 problems drawn at random across patterns you’ve covered — with the pattern name hidden. This trains the one skill that actually gets tested: recognising which pattern a cold problem needs.
In the room
The pattern knowledge is half the battle; the other half is the method from Lesson 1. On every question:
- Clarify inputs, output, constraints, and edge cases before coding.
- Work a small example by hand to see the structure.
- Name the pattern out loud and state your plan — “this is read-heavy with overlapping sub-problems, so I’ll use 1-D DP” — before you write a line.
- Code cleanly, thinking aloud.
- Test yourself on edge cases and fix bugs before they point them out.
Read the constraints for the intended complexity: n ≤ 20 hints backtracking/bitmask; n ≤ 10⁵ hints O(n log n); a sorted input hints binary search or two pointers.
Final-week checklist
- You can write each pattern’s template from memory in under a couple of minutes.
- You’ve done at least one timed mock per pattern-heavy area (trees, graphs, DP).
- You can estimate the time/space complexity of your solution out loud.
- You have 3–4 behavioural stories ready (and, for Amazon, mapped to Leadership Principles).
- For senior/staff roles, you’ve prepared the system design round separately.
You’ve finished the course
That’s all 24 patterns plus the design and study material — the toolkit that covers the large majority of coding-interview questions, and the plan to turn it into a pass. The path is simple and it works: learn the template, do the reps on the practice pages, and name the pattern out loud before you code. Recognition is the whole skill, and it only comes from deliberate practice.
Pair this with the Cracking the System Design Interview course for the design rounds, the staff engineer track for senior interviews, and the AI FAANG interview coach article to see how all of this is being graded by machines now. Good luck — you’ve got this.