Coding-round questions organised by the pattern they test rather than by problem name, so you learn transferable techniques instead of memorising individual puzzles.
21 published across 16 topics.
Data structures and algorithms fundamentals54 short answers on one page, for revising rather than studying.In-place manipulation, prefix sums, and the string-scanning problems that open most coding rounds.
Two passes over the array do it: a left-to-right pass writes the product of everything before each index into the output, then a right-to-left pass multiplies in a running product of everything after it. Linear time, no working array beyond the output, and it is unbothered by zeros.
Reverse the whole array, then reverse the first k elements and the remaining n minus k separately. Three linear reversals rotate in place with no second array, cost n swaps, and the whole thing collapses if you forget to reduce k modulo n first.
Trading memory for time with hash maps and sets, plus the collision and ordering caveats interviewers probe.
Keep a running prefix sum and a map from prefix-sum value to how many times it has occurred; at each index the number of subarrays ending there is the count already recorded for sum minus k. That is O(n) time for O(n) memory, and the map is what lets it tolerate negative numbers where a sliding window cannot.
Linear-time techniques for subarray and pair-finding problems that naively look quadratic.
Maintain a sliding window with a map from character to its last seen index; when a duplicate appears inside the current window, jump the left boundary past that previous occurrence rather than shrinking one step at a time, giving a single-pass O(n) solution.
Sort the array, fix each element as an anchor, then converge two pointers inwards from both ends of the remaining range. The sort is asymptotically free against the O of n squared scan, and it is what lets you skip duplicate values positionally instead of deduplicating a set of results afterwards.
Pointer surgery: reversal, cycle detection, merging, and the off-by-one errors that reveal carelessness.
Advance one pointer by one node and another by two; if they ever coincide there is a cycle. Then reset one pointer to the head and step both one node at a time, and they meet at the cycle's entry. O(n) time, O(1) space, and the arithmetic behind the second phase is what the follow-up asks for.
Monotonic stacks, deques, and the parsing and next-greater-element families.
Scan left to right holding a stack of indices whose answers are still unknown, kept strictly decreasing by value. Each new element resolves and pops everything smaller than it, then pushes itself. Every index is pushed once and popped at most once, so the scan is O(n) despite the inner loop.
Traversals, recursion versus iteration, balancing, and lowest-common-ancestor problems.
Recurse post-order and return the node whose left and right subtrees each report back one target; if only one side reports back, propagate that result upwards. This is O(n) time and O(h) stack. A BST lets you descend by value comparison instead, and parent pointers reduce it to list intersection.
Every node must fall inside an open interval inherited from its ancestors, not merely compare correctly against its own two children. Recurse carrying a low and high bound, tightening one of them at each descent, or walk in-order and require the sequence to be strictly increasing.
BFS, DFS, topological sort, shortest paths, and union-find, including spotting a graph problem in disguise.
Choose BFS when the question asks for the fewest steps in an unweighted graph or when you need results in distance order; choose DFS when you are asking a structural question such as connectivity, cycles or topological order, or when the graph is deep and narrow.
An order exists only if the graph is acyclic, so ordering and cycle detection are one algorithm. Kahn's method emits nodes whose in-degree has reached zero and reports a cycle when it emits fewer than n; the DFS form reverses post-order and catches a back edge into the current stack.
Top-K, streaming medians, and merges where partial ordering beats full sorting.
Count occurrences, then push counts through a min-heap capped at size k, evicting the smallest whenever the heap overflows. That is O(n log k) rather than the O(n log n) of a full sort, it needs only k items resident at once, and it works on a stream you cannot re-read.
State definition, transitions, and the memoisation-to-tabulation conversion most candidates fumble.
The quadratic dynamic programme asks for the best chain ending at each index. The faster version keeps one array where slot j holds the smallest possible tail of an increasing subsequence of length j plus one; that array stays sorted, so each element is placed by binary search for O of n log n.
Dynamic programming applies when subproblems overlap and optimal substructure holds. Define the state as the minimum set of parameters that makes the remaining decisions independent of the path taken to reach them, then tabulate by filling states in the reverse of the recursion's dependency order.
Exchange arguments and proving a locally optimal choice is globally safe.
A greedy choice is safe when you can show at least one optimal solution contains it, usually via an exchange argument that swaps an optimum's first choice for yours without losing anything. Interval scheduling by earliest finish time admits that swap; coin change with arbitrary denominations does not.
Permutations, combinations, constraint satisfaction, and pruning to keep search tractable.
Backtracking builds each candidate incrementally and undoes the last choice on return; duplicates are suppressed by sorting and skipping a repeated value whose identical predecessor is unused. The tree holds under e times n factorial nodes, so pruning only pays when it removes subtrees near the root.
Binary search on answers, custom comparators, and sorting internals still asked about.
When you cannot construct the answer but can cheaply test a candidate, and that test is monotone, binary search the answer's numeric range instead of the input. The feasibility check here is greedy day-packing, giving O(n log S) time, and the whole implementation hinges on one loop invariant.
Merging, overlap detection, and sweep-line scheduling problems.
Sorting by start time is what reduces the merge to a single scan carrying one scalar, the end of the open block; sorting by end breaks it, and sorting by end is instead correct for maximum non-overlapping selection. Both run in O(n log n), and equal timestamps decide the answer.
Masks, XOR tricks, and the low-level questions in systems-leaning interviews.
XOR-folding the array leaves the unpaired value because a^a is 0 and XOR is commutative and associative, giving O(n) time and O(1) space under a precondition worth stating. That specific trick is narrow; masks used as integer sets are the part of bit manipulation that earns real work.
Prefix trees, autocomplete, and pattern matching for search-heavy roles.
A trie stores one node per character, so finding a prefix is a walk of length k and its completions are the subtree below it. It costs far more memory than the strings themselves, so a hash map still wins for exact lookup and a sorted array with binary search wins for a static dictionary.
Deriving and defending time and space bounds, including amortised reasoning.
Doubling capacity means n appends trigger resizes at capacities 1, 2, 4 and so on, whose copy costs form a geometric series summing to under 2n, so the total is linear and the per-append average is constant.