Skip to content
Python Central Hub

Your DSA Interview Roadmap

This course exists because the alternative is worse. The standard advice is “grind LeetCode”, and the standard result is four hundred solved problems and no ability to solve the four hundred and first — because solving problems and learning patterns are different activities, and only one of them transfers.

So the organising unit here is the pattern, not the problem. Twenty phases, each teaching a small number of patterns with an interactive visualization, a template you memorise, a dry run you can reproduce on a whiteboard, and a ladder of real LeetCode problems that exercise exactly that pattern.

Pick a plan, not a page

Section titled “Pick a plan, not a page”

Be honest about your timeline. The wrong plan is the main reason people stall.

You havePlanCoverSkip
1–2 weeksEmergencyPhases 3, 5, 9, 10, 12 only. One pass, templates memorised, ~60 problems.Everything else. Accept the gaps.
4–6 weeksSprintPhases 1–14. All the interview-weight patterns, ~150 problems.Phases 16–17 (competitive-programming tail).
3 monthsStandardPhases 1–15 and 18–20 in order, ~300 problems, plus timed mocks in the last two weeks.Phase 17 unless you are targeting ByteDance.
6 months+CompleteAll 20 phases, every problem set, competitive programming included.Nothing.

What each phase is for

Section titled “What each phase is for”
PhaseWhat it gives youSkippable?
01 FoundationsBig-O you can defend out loud, recurrences, the call stackNo — complexity analysis is graded explicitly at Google
02 Python for DSAcollections, heapq, bisect, fast IO, and where Python is secretly slowNo if Python is your interview language
03 Core data structuresArrays, strings, linked lists, stacks, queues, hash tables, heaps, trees, tries, union-find, graphsNo. This is the floor.
04 Sorting and searchingThe sorts, Timsort, and the binary-search template that actually worksNo — binary search variants are everywhere
05 Array and string patternsSliding window, two pointers, prefix sums, monotonic stack, Kadane’sNo. Highest-frequency phase in the course.
06 Search and selectionBinary search on the answer, quickselect, top-K, two heaps, k-way mergeNo
07 Intervals and greedyMerge intervals, sweep line, greedy schedulingNo — and unusually heavy at Uber
08 Linked list patternsFast/slow pointers, in-place reversal, dummy headsNo — cheap to learn, still asked constantly
09 Tree patternsTree BFS and DFS, BST properties, LCA, construction, serializationNo
10 Graph patternsBFS, DFS, topological sort, cycle detection, shortest paths, union-find, gridsNo
11 Recursion and backtrackingSubsets, permutations, combinations, divide and conquerNo
12 Dynamic programmingRecursion → memo → table, knapsack, LIS, LCS, edit distance, grids, bitmaskNo
13 Bit manipulation and mathXOR tricks, bit hacks, number theory, geometryPartly — XOR patterns yes, competitive number theory no
14 Design problemsLRU/LFU, iterators, randomised structures, trackers and feedsNo — near-guaranteed at Bloomberg and Amazon
15 SimulationStateful iteration, parsing, the tedious-but-real implementation problemsRarely taught, regularly asked
16 Advanced graphsMST, max flow, SCC, bridgesYes for most; no for ByteDance
17 Advanced CPSegment trees, Fenwick, sparse tables, string algorithms, DP optimisationsYes unless you are doing contests or targeting ByteDance
18 Templates and cheatsheetsEverything condensed for the night beforeUse as reference throughout
19 Interview strategyThe seven-step loop, communication, contest strategyNo — this is the part most people skip and then lose rounds on
20 Problem setsMixed graded sets, in-browser judgeNo — mixed practice is where recognition gets tested
21 Company guidesNine interview loops, what each one actually tests, and a comparison matrixOnly for companies you are actually interviewing at

The same phases, with live counts

Section titled “The same phases, with live counts”

The table above is the editorial view — what each phase buys you and whether you can skip it. This is the mechanical one, generated from the course itself, so it cannot fall behind when a page is added:

153 pages across 24 phases. The 17-phase teaching sequence reaches 444 distinct problems; the rest are reference surfaces you dip into rather than work through.

The teaching sequence

In order — later phases assume earlier ones. Phases 01 and 02 carry no problem ladders because they teach language and analysis rather than patterns.

01 Foundations 6 pages 02 Python for DSA & CP 4 pages 03 Core Data Structures 12 pages · 54 problems 04 Sorting & Searching 7 pages · 32 problems 05 Arrays & Strings 14 pages · 108 problems 06 Search & Selection 6 pages · 29 problems 07 Intervals & Greedy 5 pages · 33 problems 08 Linked Lists 4 pages · 23 problems 09 Trees 8 pages · 58 problems 10 Graphs 12 pages · 47 problems 11 Recursion & Backtracking 4 pages · 24 problems 12 Dynamic Programming 12 pages · 58 problems 13 Bit Manipulation & Math 4 pages · 27 problems 14 Design Problems 7 pages · 48 problems 15 Simulation & Implementation 1 page · 6 problems 16 Advanced Graph Algorithms 3 pages · 20 problems 17 Advanced CP Topics 5 pages · 17 problems

Reference and practice

Not a sequence. Use these throughout — the cheatsheets the night before, the problem sets for mixed recognition practice, the company guides when a specific loop is imminent.

00 Start Here 8 pages 18 Templates and Cheatsheets 4 pages 19 Interview and Contest Strategy 5 pages 20 Problem Sets 5 pages 21 Company Guides 10 pages 22 Low Level Design 5 pages 23 Concurrency 2 pages

Two things worth reading off it. Phases 01 and 02 show no problem count, because they teach analysis and the language rather than patterns — there is nothing to drill, which is also why they are the two phases most people can compress. And 05 Arrays & Strings is the largest single block of practice in the course, which is the quantitative version of the “highest frequency phase” claim in the table above.

Where the public sheets fit

Section titled “Where the public sheets fit”

You have probably seen NeetCode 150, Blind 75, Striver’s A2Z, or LeetCode’s own Top Interview 150. They are good lists. They are also lists — they tell you what to solve and not how the pattern works, which is why this course teaches patterns and then hands you the sheets as practice.

All of them are tracked here, mapped onto these phases, with your progress shared across every one of them:

375 problems listed across 3 sheets
224 distinct problems once duplicates are removed
40% of the combined list is duplication
50 problems appear in 3 or more sheets

Read the last figure first. Those 50 problems are what the sheet authors independently agree on, which makes them the highest-value problems on this site — and the ones to do before anything else, whichever sheet you eventually commit to.

How much any two sheets share

Sheet A Sheet B Shared Share of the smaller sheet
NeetCode 150 LeetCode Top Interview 150 77 51%
NeetCode 150 Blind 75 74 99%
Blind 75 LeetCode Top Interview 150 50 67%

The consensus problems

50 problems
12 easy33 medium5 hard

Every problem below appears in at least 3 of the sheets. Finish these and you have covered the core of all of them simultaneously.

How to actually use a page

Section titled “How to actually use a page”

Every topic page follows the same spine, in this order, for a reason:

  1. The cue — how you recognise the pattern from the problem statement alone. This is the skill that transfers; the rest is mechanics.
  2. Visual intuition — a step-through visualization you can pause, scrub and step backwards through. Stop on the frame you do not understand.
  3. The template — memorise this. Not the idea of it; the code.
  4. Dry run — a hand trace. Reproduce it on paper before you trust yourself.
  5. Complexity — say it out loud, every time, before you are asked.
  6. Variant map — the mutations interviewers stack on the base pattern.
  7. Pitfalls — the specific ways the solution comes back wrong.
  8. Interviewer follow-ups — the questions that separate “pass” from “strong hire”.
  9. Practice ladder — real problems, easiest first, with sheet membership and reported companies. Tick them off; progress saves in your browser.
  10. Exercises — write the code here, in the browser, before leaving the page.
  11. Self-check — five questions. If any takes more than a few seconds, reread.
  12. Recall card — five lines to revise from a week later.

What this course does not cover

Section titled “What this course does not cover”

Said plainly, so you can plan around it:

  • System design at scale — distributed systems, sharding, consistency. Needed for L5+ and senior roles; not here.
  • Language trivia beyond Python — no Java or C++ specifics.
  • Behavioural preparation in depth — Phase 19 covers the coding-round communication that gets scored alongside your code, and Amazon’s Leadership Principles specifically, but this is not a behavioural-interview course.
  • Take-home projects and domain rounds — ML, frontend, infrastructure specialisations have their own tracks on this site.

Next: How to Use This Course — the study loop, spaced revision, and what to do when you get stuck on a problem for forty minutes.

pch.coffeeTagline

pch.coffeeCta

pch.feedbackHeading

pch.feedbackSubheading