133 sheets, grouped by topic and ranked by how often the pattern actually shows up in a FAANG software-engineering loop. Read the Start here ladder first; the catalogue below is for lookup.
The same stars appear on individual sections inside each sheet, so you can skim a 4,000-line doc and still see which templates are the ones to memorise.
12 sheets in reading order. Together they cover the large majority of what a coding round will actually ask.
The highest-frequency surface in any interview loop. Master the four pattern families here before anything else.
Array fundamentals — in-place rewriting, rotation, partitioning, and the index-as-hash trick. Owns the operations; the pattern families (windows, pointers, prefix sums) each have their own file.
Windows that grow and shrink on a condition — fixed-size, variable-size, at-most-k, and exactly-k by subtraction; owns the expand/contract loop and the six canonical window templates.
The everyday string catalogue — character-level two-pointer scans, frequency and anagram signatures, run-length grouping, tokenising, parsing and in-place rewriting — while the worked-solution archive, the language-level string API, palindromes, substring search and two-sequence DP each live in their own sheet.
The two-pointer family on arrays and strings — opposite-ends convergence, fast/slow, expand-from-centre and the read/write partition, with one canonical template for each; window problems that grow and shrink on a condition live elsewhere.
The worked-solution archive behind array.md: thirteen problems that are genuinely about rewriting an array in place or using its indices as storage, grouped by the trick each one turns on.
The worked-solution archive behind matrix.md: seventeen problems grouped by the geometry or technique each one turns on — traversal order, in-place transformation, staircase search, grid search, 2D DP, and row-pair compression.
The 2D grid as its own topic — traversal geometry (spiral, diagonal, rotate, transpose), in-place marking, and index↔coordinate arithmetic.
The k-sum family specifically — 2Sum through kSum, the sort-then-converge recursion, and duplicate handling.
The palindrome family — expand-from-center, two-pointer verification, palindromic DP, and Manacher — and how to tell which a problem needs.
Prefix / running sums — subarray sums, 2D prefix sums, prefix + hashmap counting.
The six prefix-sum templates that borrow another structure or another identity: the complement trick, the monotonic deque for arrays with negatives, row-pair compression for 2D, prefix XOR, the sparse difference array via a hash map, and the prefix-sum-on-a-tree counting map.
The sliding-window techniques a first pass should skip: deque-maintained window extrema, the at-most-K-distinct family, exactly-K counting beyond one worked instance, and the windows whose key is not a character — complement, word-level chunks, index-bounded value buckets and sorted intervals; the six must-know templates stay in the main sheet.
The worked sliding-window LeetCode catalogue, one canonical solution per problem per language, each filed under the template it instantiates; the templates, the concepts and the decision tables stay in the main sliding-window sheet.
The worked string LeetCode archive, one canonical solution per problem per language, each filed under the parent sheet's template that it instantiates; the concepts, the pattern catalogue and the templates themselves stay in the main string sheet.
The worked two-pointer LeetCode catalogue, one canonical solution per problem per language, grouped by the template it instantiates; the concepts, pointer types and templates themselves stay in the main two-pointer sheet.
Digit-by-digit addition across the four input shapes an interviewer will hand you: strings, integers, arrays, and linked lists.
O(1) range update, O(n) rebuild — the inverse of a prefix sum.
The worked-solution archive behind prefix_sum.md: the eight problems the templates do not already solve end to end, grouped by which prefix-sum shape they need.
Substring search only — KMP's failure function, Rabin-Karp rolling hash, and the built-in-indexOf-vs-KMP-vs-hash decision.
The language mechanics of strings: Python slicing and methods, Java String and StringBuilder, character classification and case conversion, char arithmetic, the split/join traps and the build-performance rules — not the algorithms that use them.
Heavier string machinery — suffix structures, Z-algorithm, Manacher, and string-DP — the parts too specialised for the main string doc.
O(1) lookup and LIFO/FIFO discipline — the structures that turn an O(n^2) scan into O(n).
Key→value problem patterns — lookup, grouping, index maps, prefix-sum maps, remapping.
LIFO fundamentals and the canonical stack templates: bracket matching, min-stack, the short monotonic-stack form, explicit-stack traversal and the scope/context ledger.
The worked-solution archive for the hash-map family: one canonical solution per problem, the pattern-specific templates that are really single-problem deep dives, and the ordered-map (Java TreeMap / Python SortedDict) reference.
Cross-collection chooser — which Java / Python container for which job, and the API gotchas of each.
Next greater / previous smaller / span / histogram problems — the stack stays sorted so each element is pushed and popped once.
FIFO fundamentals — BFS queues, deques, circular buffers, queue-backed designs.
The stack-based expression family: the calculators (LC 224 / 227 / 772), decode-string style nesting (LC 394) and postfix / sequential-operand evaluation (LC 150, 682), with the pre_op delay-insert trick that makes operator precedence fall out of a plain stack.
The worked-solution archive behind stack.md: one canonical solution per problem per language for the monotonic, greedy-removal, adjacent-duplicate, bracket-family, traversal and design problems, grouped by the template each one exercises.
Hashing internals and counting idioms — hash design, collisions, frequency maps, rolling hash, custom keys.
Sliding-window max/min in O(1) amortised, using a deque that stays monotonic.
Membership, dedup and set algebra — problems where you only need presence, not an associated value.
The worked-solution archive behind set.md: fourteen problems grouped by what the set is being used for — a memory of what has been seen, set algebra, an O(1) index that replaces a scan, or a component inside a larger algorithm.
Pointer surgery. Low conceptual depth, high implementation-precision bar.
Pointer surgery on singly and doubly linked lists — reversal, merging, reordering, dummy-head technique, and cycle handling.
The worked-solution archive behind linked_list.md: one canonical solution per problem per language for the reversal, merging, splitting, copying, flattening and list-sorting problems, grouped by the technique each one exercises.
Two pointers over linked-list nodes — fast/slow cycle detection, middle finding, k-th from end, and offset pointers. No array indexing.
Recursive structure plus ordered access. Roughly a quarter of all tree/heap-tagged interview questions come from these five sheets.
Binary-tree-specific reasoning: which direction DFS state flows (down vs up), plus the 11 structural templates built on that.
Ordered trees only — what the left < root < right invariant buys you (O(log n) search, sorted inorder, range pruning, order statistics).
Both the heap (the structure) and the priority queue (the ADT it implements), in Python and Java. Formerly split across heap.md + priority_queue.md, which solved the same problems twice.
Tree concepts, tree types and traversal-order strategy — the why and which, plus the advanced techniques that are not per-pattern templates (Morris threading, binary lifting, re-rooting). The templates themselves live in tree2.md.
Lowest common ancestor, node-to-node distance, parent-map (bidirectional) traversal and the root-to-leaf path templates — every tree problem whose answer is a path or a meeting point rather than a shape.
The heap patterns a first pass should skip: lazy deletion, sweep-line "alive" heaps, regret greedy, resource-pool allocators, grid best-first search, and the structures beyond a plain binary heap; the six must-know templates stay in the parent sheet.
The BST material a first pass should skip: order-statistic (rank) queries, the lazy O(h)-space iterator, in-order drop detection for a corrupted BST, the full construction-variant catalogue, and the detach/bounds variations that go beyond the canonical delete and validate templates.
The worked-solution archive for the BST templates taught in bst.md — one canonical solution per problem per language — plus the root-to-leaf and node-to-node path family that is filed with BST but needs no ordering at all.
The worked-solution archive for the heap / priority-queue family: one canonical solution per problem per language, with the reasoning, traces and gotchas written out in full.
Building a binary tree from something flat: two traversal arrays, an index range over one array, or a parenthesised / infix string — the inverse direction of every tree problem that only reads a tree.
A numbered, copy-paste template per tree pattern, in Python and Java — the single home for tree templates. Template-first, no theory: which traversal a problem wants is tree.md's question.
Turning a tree into a string and back — subtree fingerprints for identity and duplicate detection, and the full encode/decode codec family (parenthesis, comma plus null marker, depth prefix).
The prefix tree — insert/search/startsWith, node layout choices, and the problems where sharing prefixes is the whole trick (autocomplete, word search, XOR trie).
The language mechanics of heaps: every heapq and PriorityQueue call you need, how to fake a max-heap, how to peek without popping, and the traps that come with a partially-ordered container; the algorithms that use them live in the heap sheets.
The worked-solution archive for the tree patterns taught elsewhere: one canonical solution per problem per language, grouped by what the problem asks for rather than by technique.
Root→leaf path problems where the path itself is the state and must be undone on the way back up.
The worked-solution archive behind trie.md: five problems, from building the structure to the grid search where a trie turns "once per word" into one walk.
Redirect only. This file has been merged into heap.md; it exists to point old links at the right sections.
Traversal, connectivity and ordering. BFS/DFS are must-know; the weighted shortest-path trio is mostly L5+ territory.
The main BFS reference: the queue templates, level-by-level expansion, grid and multi-source BFS, and why first visit equals shortest path on an unweighted graph; the heavier variants and the long tail of worked problems live in their own sheets.
The main DFS reference: the ten core depth-first templates — tree traversal, grid flood fill, path finding, backtracking, tree modification, post-order aggregation, boundary elimination, shape signatures and weighted-edge traversal — with the recognition table that picks between them.
Graph representation, traversal, connectivity, cycle detection and the general graph-problem catalogue.
The worked-solution archive behind Dijkstra.md: eleven problems in both languages, grouped by the shape of the search state, since that is what decides whether you need dist[], a second state dimension, or a plain visited[].
Single-source shortest path with non-negative weights, via a priority queue.
Ordering a DAG — Kahn's BFS, DFS post-order, cycle detection, and the scheduling problems built on them.
The worked-solution archive behind topology_sorting.md: eight problems in both languages, grouped by the shape of the dependency they encode rather than by problem number.
Disjoint set union — connectivity, component counting, cycle detection in undirected graphs, with path compression and union by rank.
The graph techniques a first interview pass should skip: Tarjan's low-link family (strongly connected components, bridges, articulation points), Euler paths and circuits, max flow / min cut, and the bipartite extras — Union-Find detection, maximum matching and greedy k-colouring.
The BFS techniques a first pass should skip: bidirectional BFS, 0-1 BFS with a deque, multi-source beyond the canonical template, BFS over implicit state spaces, and all-shortest-path DAG enumeration — the must-know queue templates stay in the main sheet.
The worked-solution archive for BFS: one canonical solution per grid, state-space, tree-mutation and leaf-trimming problem, plus the LC 994 walkthrough on where to increment time — it teaches no new templates.
The rare and hard DFS techniques a first pass should skip: two-grid validation, edge-direction tracking, cross-component pair counting, Euler paths, Tarjan low-link bridges, trie-backed wildcard search, depth-indexed stack DFS, and the post-order rollups on N-ary and parent-array trees.
The worked-solution archive for dfs.md: one canonical solution per problem for the DFS problems the core templates cover, plus the pattern-and-difficulty index of the whole DFS problem set.
The worked-solution archive for graph.md: one canonical solution per problem for the grid, clone, connectivity, ratio-graph, implicit-DAG and DSU-by-attribute problems, with no template or theory material of its own.
Decision doc only — which shortest-path algorithm for which problem shape, and where the naive choice is wrong. No full implementations.
Decision doc only — topological sort vs union-find: what each answers, where the naive choice is wrong, and problems solvable by both.
The worked-solution archive behind union_find.md: nineteen problems grouped by what a node represents — a vertex, a grid cell, a variable carrying a ratio, or a tree node — since that is the only thing that changes between them.
Single-source shortest path that tolerates negative weights, and detects negative cycles. Also the k-hop-bounded variant.
All-pairs shortest path by DP over intermediate vertices — O(V³), dense graphs, transitive closure.
Halving a monotonic space, and what sorting buys you. Binary search on the answer is the single most under-practised tier-5 skill.
Halving a monotonic search space — the loop-invariant reasoning behind l <= r vs l < r, the boundary (lower/upper bound) templates, rotated arrays, and floating-point and 2D search.
Binary searching a range of candidate answers against a monotone feasibility predicate — the canFinish / isValid framing, the minimise-maximum vs maximise-minimum decision, the [max(nums), sum(nums)] boundary recipe, and counting predicates over a value domain.
The worked-problem archive for binary_search.md — one canonical solution per problem for the index-space templates, with the traces and pitfalls that do not fit on the main sheet.
The card-game algorithm behind O(N log N) longest increasing subsequence: the piles, the tails array they collapse to, recovering the subsequence itself, and the problem family that reduces to it.
Partition-based selection: finding the Kth largest, Kth smallest or K closest element in O(n) average time by recursing into only one side of a QuickSort partition, including pivot strategies and an outline of the O(n) worst-case Median of Medians.
Sorting algorithms and sort-adjacent techniques — comparison sorts and their stability, counting/bucket/radix, quickselect, custom comparators, and cyclic sort.
Divide-and-conquer beyond merge sort — the recursion-with-merge shapes (count-while-sorting, closest pair, matrix D&C, D&C on expressions) and their recurrences.
The hardest tier-5 block. Start from recursion, memoise, then tabulate.
用中文把 0/1 背包從「物品重量價值」一路講到 LC 494／416 的解題流程，重點放在 state 怎麼定義、「拿或不拿」的轉移、以及為什麼內層 loop 一定要倒序；完全背包（Unbounded）與排列／組合的 loop 順序規則不在這裡展開。
Systematic search with undo: the choose/explore/un-choose skeleton, start_idx control, duplicate skipping, pruning, and exactly one canonical template per must-know shape — the long tail of worked solutions and the hard-tier state-carrying templates live in its two satellites.
The main DP sheet — state design, the pattern catalogue, and one canonical template per must-know DP family; the worked-solution archive, the rare techniques, and the five heaviest sub-topics live in their own sheets and are linked from here.
The knapsack family in full: 0/1 vs unbounded vs bounded vs group, the subset-sum reduction, why the 0/1 inner loop runs backward, and the loop-order rule that separates combinations from permutations.
Hard-tier backtracking that carries extra state through the recursion — a Trie node, the previous operand, a deletion budget — plus constraint propagation, memoised search and the generic partitioning templates a first pass should skip; none of the must-know shapes are repeated here.
The DP appendix — techniques a first pass should skip: game-theory / minimax DP, tree and re-rooting DP, interval and string DP deep dives, probability and step-indexed counting DP, monotonic-queue and stack-carried DP, and the long-form derivations trimmed out of the main sheet.
Why a bottom-up DP's loop nesting and direction are forced by its own transition, the four ways a wrong order fails, and LC 139 Word Break worked in five orders — including the one that looks right, passes "leetcode", and silently fails the problem's own Example 2.
Template index — one short section per classic DP pattern (Kadane, LIS, MCM, LCS, knapsack, state machine, grid, bitmask, digit, tree DP, regex, interval scheduling, split, memoised DAG).
Recursion as a mechanism — base case, state passed down vs returned up, call-stack cost, and converting to iteration. The pattern families that use recursion each have their own file.
The mechanical pipeline: recursion → memoisation → tabulation → space-optimised, applied to one problem at a time.
DP over one or two strings: the dp[m+1][n+1] two-sequence grid, prefix-based (1-indexed) table design, and the worked patterns for LCS, edit distance, interleaving and wildcard/parenthesis matching.
The long tail of worked backtracking solutions (LC 17, 39, 79, 78, 90, 77, 46, 22, 93, 139, 140, 207) with their recursion traces and near-miss variations, one canonical solution per problem per language — it teaches no templates of its own, every section points back to the one it instantiates.
DP where the state is a subset encoded in an integer: mask operations, submask enumeration, TSP and assignment templates, and the n <= 20 sizing rule.
The worked-solution archive behind dp.md: one canonical Java / Python solution per classic DP problem plus the problems-by-pattern index, with no templates or theory of its own.
The maximum-subarray family in depth — Kadane and its variants (product, circular, with deletion, 2D).
Problems where a monotonic stack carries a DP value: "how many rounds does this element survive", largest-rectangle-style area DP, and the maximal-square / count-squares grid recurrences.
The LC 121/122/123/188/309/714 buy-and-sell family, unified under one dp[i][k][hold] state machine.
Counting how many numbers in a range satisfy a digit-level property: the tight/started/position state, the universal top-down template, and the count(R) - count(L-1) range trick.
Sort-then-scan, and the exchange argument that proves it correct.
Taking the locally best choice and the exchange argument that proves it safe — interval scheduling, jump games, task assignment — plus how to spot when greedy fails and DP is required.
Sort-then-merge interval problems — merge, insert, count overlaps, minimum removals.
The worked-solution archive behind greedy.md: fourteen problems grouped by the shape of the greedy choice — extend a reach, accumulate and reset, interleave by frequency, sort and take, or commit while scanning.
Line sweep — turn each interval into +1 / -1 events, sort by coordinate, sweep once.
The worked-solution archive behind scanning_line.md: six problems grouped by what the sweep is actually counting — overlap depth, a weighted sum, a heap of live jobs, or the intersection of two sorted lists.
One idea only — the interval-overlap predicate: closed [a,b] vs half-open [a,b), and which one each LC problem needs.
Reach for these only when a problem needs updates *and* range queries — otherwise a prefix sum is enough.
The Fenwick tree specifically — i & -i index arithmetic, point update + prefix query, and the problems it is the tidiest answer to.
Range query + range update structures — the segment tree, lazy propagation, and the BIT-vs-segment-tree-vs-merge-sort decision.
What to do when the input does not fit in RAM: bit vectors, bucket-then-refine passes, sharding a file by hash, and external merge sort — the techniques that still return an exact answer by paying with extra passes.
Algorithms constrained to one pass and sub-linear memory — reservoir sampling, Boyer-Moore majority, weighted random pick, and approximate counting.
Small, self-contained topics. Cheap to learn, occasionally decisive.
How integers are represented in bits (two's complement, fixed width, shifts) and the operations and tricks built on that — masks, XOR identities, lowest set bit, subset enumeration, and bitmask DP.
The worked-solution archive behind bit_manipulation.md: nineteen problems grouped by which property of the bit operators they lean on — XOR cancelling pairs, clearing the lowest set bit, carry-free arithmetic, an integer standing in for a subset, or a hand-built mask editing a bit field.
Numeric manipulation in interviews — digit extraction, overflow-safe arithmetic, base conversion, roots, and pow. Formula-level counting lives next door.
Counting and number theory as they appear in interviews — modular arithmetic, GCD/LCM, sieves, nCr, reservoir sampling, and basic geometry.
The four moves that solve brainteaser-style questions: counting how much information one test buys, balancing the worst case, finding the invariant, and using linearity of expectation. It teaches the moves, not a riddle list.
"Design a X" and low-level-design rounds — judged on operation complexity and class modelling, not cleverness.
The worked-solution archive behind design.md: twenty LC "design a X" problems in full, grouped by the structure pair each one forces rather than by problem number.
LC "design a X" problems — reading the required operations off the problem and picking the structure combination that makes every one of them O(1) or O(log n); the worked designs themselves live in the examples sheet.
The low-level-design round — class modelling, SOLID, and the design patterns interviewers actually ask for (strategy, observer, factory, state), with worked designs.
The iterator contract — hasNext/next with lazy state, flattening, peeking, and merging — one idea, in isolation.
The distributed-systems patterns that get asked as coding questions — consistent hashing, token-bucket and leaky-bucket rate limiting, and the load-balancing algorithms — with runnable implementations and the trade-offs an interviewer follows up on.
The handful of Java concurrency problems that appear at L4+ — ordered printing, producer/consumer, read-write coordination and deadlock avoidance — plus the primitives they need.
Problems where the answer is the faithful step-by-step execution — state machines, robot/grid walks, game rounds, iterative rewriting — plus how to keep such code shrinkable.
Language mechanics, not algorithms. Read for speed and to stop losing submissions to avoidable traps.
The Java library APIs for holding data: arrays and 2D arrays, lists, maps, queues, heaps, stacks and pairs — how to initialise, copy, iterate and index each one, and the traps in doing so.
Java String and StringBuilder work — converting to and from char[], slicing, parsing, building and mutating — together with everything comparator-shaped: array, collection and map sorting, and the return-value rules that decide the order.
The Java language semantics that decide whether a correct algorithm produces a correct answer: characters as integers, value vs reference, and integer arithmetic. The library APIs live in two companion sheets.
The two things that produce most wrong answers in Python solutions that are otherwise correct: where an insertion actually lands, and whether an index range means a count or a distance.
The library-by-library reference: heapq, sortedcontainers, bisect, collections, itertools, functools and datetime — the calls, their complexity, and the idiom each one exists to replace.
The Python language idioms that come up while solving problems — the cost of the built-in operations, copying, string handling, sort keys, integer arithmetic, comprehensions and scope — grouped by what you are trying to do. The standard library and the index arithmetic have their own sheets.
Python behaviours that silently cost you a passing submission — mutable defaults, closure late-binding, integer caching, copy semantics — plus the GIL and Python's concurrency story.
How to triage a question and state its complexity. Read before your first mock.
Lookup tables — Big-O of every common data structure and classic algorithm, plus the math intuitions behind them.
The top-level map: given a problem, which pattern (and therefore which cheatsheet) does it want. Index and triage only — no templates here.
Walkthroughs — how to argue the complexity of an actual LC solution, one classic per technique.
20 self-test drills — read the snippet, state the complexity, check yourself.
Redirect. The six-step interview loop moved into lc_pattern.md, which is the page you actually open when starting a problem.
A pointer to the wisdompeak problem taxonomy, and a map from its 29 categories to the cheatsheet in this repo that teaches each one. The taxonomy itself is not mirrored here.
No sheet matches that filter.
How to use this: pick the sheet, read its Scope line to confirm it owns your problem, then jump straight to the starred sections. Every sheet links to its neighbours rather than repeating them.
Source: doc/cheatsheet on GitHub — ratings and grouping live in data/cheatsheet_meta.json.