// the roadmap
Learn, in the right order.
Start with Foundations, then work the tracks top to bottom. Each track teaches a pattern the later ones assume you have.
Coding Foundations
The mental models everything else is built on: complexity, memory, hash maps, recursion, and a repeatable way to attack any problem.
Big-O Notation, Minus the FearFree sampleBig-O is not math class. It's a one-word answer to "what happens when the input gets big?" Learn the five classes that cover 95% of real code.12 minArrays: What the Memory Actually Looks LikeEvery array fact you've memorized (O(1) indexing, O(n) insert-at-front, amortized append) falls out of one picture: a row of boxes at consecutive addresses.13 minHash Maps: The O(1) MachineHow a hash function turns 'have I seen this?' into array indexing, why collisions don't scare anyone, and the value→index pattern that unlocks half the easy problems.14 minRecursion: Trusting the Smaller ProblemRecursion isn't a function mysteriously calling itself. It's a contract: handle the smallest case, and trust the smaller call to handle the rest.14 minA Framework for Any Coding ProblemStop hoping for flashes of insight. A seven-step loop, restate, example, brute force, find the waste, pick the structure, code, test aloud. That works on problems you've never seen.15 minChoosing the Right Data StructureData structures aren't a menu to browse. They're answers to questions. Ask what your algorithm repeatedly needs, and the structure picks itself.13 min
Arrays & Hashing6
Where every interview starts. Master the memory-for-speed trade and the value→index pattern that unlocks half of this list.
#1 Two SumNo account neededThe classic warm-up that secretly teaches the most important trade in all of interviewing: spend memory to buy speed.#217 Contains DuplicateThe smallest possible showcase of the set: one pass, one membership check, and an O(n²) problem collapses to O(n).#242 Valid AnagramTwo strings are anagrams exactly when their letter counts match. The problem is a lesson in choosing the right canonical form.#49 Group AnagramsValid Anagram, industrialized: pick a canonical form, use it as a hash key, and grouping happens for free.#347 Top K Frequent ElementsCount, then rank, and the ranking step is where you show range: sort, heap, or the O(n) bucket trick that exploits a bounded key.#238 Product of Array Except SelfDivision is banned, so you learn the real lesson: any 'everything except me' quantity splits into a prefix from the left and a suffix from the right.
Two Pointers3
When the input is sorted (or can be), two indices walking toward each other replace a whole extra data structure.
#125 Valid PalindromeThe gentlest introduction to two pointers, and a quiet test of whether you handle messy input without copying it.#11 Container With Most WaterConverging pointers with a real proof obligation: you must argue that moving the shorter wall never discards the best answer.#15 3SumFix one element and the problem collapses into Two Sum on a sorted array. The real fight is emitting each triplet exactly once.
Stack3
Last-in, first-out is the natural shape of nesting, undo, and "most recent thing that matters" problems.
#20 Valid ParenthesesNo account neededThe canonical stack problem: nested structure means last-opened, first-closed, and there's exactly one data structure built for that.#155 Min StackA design problem with one beautiful idea: if a query is expensive to recompute, snapshot the answer at every moment it could change.#739 Daily TemperaturesYour first monotonic stack, the pattern behind every 'next greater element' problem. Learn the invariant once and a whole family of Hards becomes mechanical.
Binary Search2
Halving the search space is easy; not writing an off-by-one is the actual skill. Build the discipline here.
#704 Binary SearchEveryone 'knows' binary search; almost everyone ships an off-by-one. This is about writing it with a discipline that makes bugs impossible, not unlikely.#33 Search in Rotated Sorted ArrayBinary search where the array has been cut and swapped. The rescue is one sharp observation: split anywhere, and at least one half is still perfectly sorted.
Linked Lists3
Pointer surgery under pressure: reversing, merging, and Floyd's famous tortoise-and-hare cycle check.
#206 Reverse Linked ListThe pointer-surgery kata. Three pointers, one loop, zero allocations, and the muscle memory you'll reuse inside a dozen harder list problems.#21 Merge Two Sorted ListsThe merge step of merge sort, on pointers, and the home of the dummy-head technique, the single best trick for deleting edge cases from list code.#141 Linked List CycleFloyd's tortoise and hare: detect an infinite loop in O(1) space, and actually understand *why* the two runners are guaranteed to collide.
Trees3
Recursion's home turf. Learn to trust the subtree and the hard problems collapse into three-line functions.
#226 Invert Binary TreeThe famous 'Homebrew author got rejected over this' problem. It's four lines, and the cleanest possible introduction to trusting recursion on trees.#104 Maximum Depth of Binary TreeOne line of recursion that teaches the 'answer from my children's answers' pattern. The template half the Trees track is built on.#98 Validate Binary Search TreeThe problem everyone gets wrong the first time, because the obvious 'check each node against its children' idea is a trap. The fix is passing bounds down.
Dynamic Programming3
Overlapping subproblems, cached. The memoize → tabulate → compress arc, from Fibonacci in disguise to coin change.
#70 Climbing StairsIt's Fibonacci in a trench coat, and the cleanest possible tour of the whole DP arc: recursion → memoization → tabulation → two variables.#198 House RobberThe canonical take-or-skip DP. One binary decision per element, a two-term recurrence, and the same O(1)-space squeeze as Climbing Stairs.#322 Coin ChangeThe problem that permanently cures greedy overconfidence. Making change with arbitrary denominations demands real DP, one array, one honest recurrence.
Graphs & Design2
Flood fill your first grid, then build the data structure interviewers love most: an LRU cache from raw parts.
#200 Number of IslandsThe gateway graph problem: a grid is a graph in disguise, and counting islands is counting connected components with a flood-fill.#146 LRU CacheThe design interview's favorite: O(1) get and put with least-recently-used eviction. Hash map for lookup, doubly linked list for order, neither works alone.
The whole roadmap is free.
Signing in unlocks every lesson and every explainer. No card, no trial, no catch, and nothing stored about you.