Coding Patterns

The two dozen patterns behind interview problems, learned so you can spot them cold.

29 open lessons · practice and review with a pass

Part 0: Foundations

Cost before code, then a warm-up track of easy problems for anyone rusty.

• Cost before code: How fast does the work grow when the input grows?
• Arrays, strings and recursion: What does the loop know after each step?

Part I: Linear scans

One pass over an array or string, with the right thing remembered.

• Arrays and hashing: How do you trade memory for a second pass you never have to make?
• Two pointers: When can you throw away a candidate without ever looking at it?
• Sliding window: How do you check every contiguous run without restarting at each one?
• Prefix sums and difference arrays: How do you answer any range question in O(1) after one pass?

Part II: Invariants

Keep one condition true and the answer falls out.

• Stack and monotonic stack: How do you find, for every element, the next one that beats it?
• Binary search: Where is the boundary between false and true?

Part III: Linked structures

Pointer recursion, then priority.

• Linked lists: How do you rewire a list without losing it?
• Trees: What does each subtree need to return so its parent can decide?
• Heaps: How do you keep the best k without sorting everything?

Part IV: Sort, choose, enumerate

Order the input, make safe choices, or try them all.

• Intervals and sweep: What order makes overlapping ranges easy?
• Greedy: When is the locally best choice provably safe?
• Backtracking: How do you enumerate every option without missing or repeating one?
• Tries: How do many words share their prefixes?

Part V: Graphs

Traversal, then order, then connectivity, then weights.

• BFS and DFS on graphs: How do you explore everything reachable exactly once?
• Topological sort: In what order can dependent tasks run?
• Union-find: Are these two things connected yet?
• Shortest paths and MST: What is the cheapest way through a weighted graph?

Part VI: Dynamic programming

From the easiest DP to spot to the hardest.

• Dynamic programming in 1D: What is the answer for a prefix, given the answers for shorter ones?
• DP on grids and strings: What is the answer for two prefixes at once?
• Knapsack: Which items fit a capacity or hit a sum?
• LIS and state machines: How do you carry the right few states forward?
• Interval, tree and bitmask DP: What if the order of operations, a tree, or a set is the state?

Part VII: Toolbox

Independent breadth: bits, maths, matrices, strings, design.

• Bits and maths: What do the bits know that the numbers hide?
• Matrices, string matching and design: Which O(1) operations does the class need, and what makes them O(1)?

Part +: Optional deep dives

For roles that lean on competitive programming.

• Range queries: What if the array changes between queries?
• Advanced graphs: Bridges, Euler paths and all-pairs distances.
• Advanced DP: Digit DP, bitmask DP over sets, interval triangulation.

Open the course