The Fifteen Patterns, Recapped

The Real Skill You Built

This course was never really about memorizing solutions to specific problems — LeetCode has thousands of problems, and no amount of memorization covers them all. It was about building a much smaller, much more durable skill: recognizing which of a handful of underlying patterns a new, unfamiliar problem is actually an instance of.

That recognition is why a problem you have never seen before can still feel approachable. You are not starting from zero — you are asking "does this look like a sliding window, a two-pointer sweep, a graph traversal, a DP table, or something else from the toolkit?" and the answer usually comes fast now.

The Pattern Map

• Arrays & hashing — frequency maps, prefix sums, and turning O(n²) lookups into O(1) ones.
• Two pointers & sliding window — shrinking a brute-force nested loop into a single linear pass.
• Stacks & binary search — matching/nesting problems, and searching sorted (or sorted-enough) spaces in O(log n).
• Linked lists & trees — pointer manipulation, traversal orders, and recursive tree reasoning.
• Graphs & backtracking — BFS/DFS traversal, and systematically exploring a search space while pruning dead ends early.
• Dynamic programming & greedy — recognizing overlapping subproblems versus provably-safe local choices.
• Advanced patterns — merge intervals, cyclic sort, two heaps, top-K elements, k-way merge, and bitwise XOR tricks for the problems the first six modules don't quite cover.

Keeping It Sharp

Pattern recognition is a live skill, not a one-time download — it fades if it isn't exercised. The most reliable way to keep it sharp is simple and a little unglamorous: keep solving new problems on a regular cadence, and before writing any code, force yourself to name which pattern from this map the problem matches. Over time that naming step gets faster, then automatic, and eventually you stop noticing you're doing it at all.