Interview Prep

Decide if any value appears at least twice. Hashset as a presence detector.

Partition a list of strings into anagram buckets.

Longest run of consecutive integers in an unsorted array in O(n). The "only start counting at sequence heads" trick.

Compute "product of all other elements" without division and in O(n).

Return the K most frequent values without sorting everything.

Find indices of two numbers summing to a target. The "have I seen the complement?" pattern.

Decide if two strings are permutations of each other.

Decide whether a partially filled Sudoku board violates any rule.

Find two lines that form the container holding the most water. Two-pointer convergence on a sorted-shape argument.

Find all unique triples that sum to zero. Sort + two-pointer extension of Two Sum.

Total water trapped between elevation bars. Famous for having five elegant solutions.

Maximize profit from one buy-then-sell. Single pass with a running minimum.

The canonical sliding-window problem. Maintain a moving window of distinct chars.

Maximum of every length-k window in an array. The monotonic-deque pattern.

A stack supporting push, pop, top, and getMin all in O(1). The auxiliary-stack trick.

Decide whether a string of brackets is properly nested. The canonical stack problem.

Largest axis-aligned rectangle under a histogram in O(n). The reference monotonic-stack problem.

Find a target in a sorted array that has been rotated by an unknown amount. Modified binary search.

Find the median of two sorted arrays in O(log min(m, n)). The famous "I can’t do this on the whiteboard" Google problem.

Merge two sorted linked lists into one sorted list. The dummy-node pattern.

Reverse a singly linked list in place. The pointer-juggling primitive.

Merge k sorted linked lists into one sorted list. Min-heap of heads.

O(1) get and put for a fixed-size cache. Build the doubly-linked-list-plus-hashmap from scratch.

Compute the maximum depth of a binary tree. Recursive tree fundamentals.

Return the values of a binary tree level by level. The canonical BFS-on-a-tree problem.

Find the deepest node that has both p and q in its subtree. Elegant 5-line recursion once you see it.

Decide whether a binary tree is a valid BST. The classic "recursion with bounds" pattern.

Maximum sum of any path (need not pass through root). The "return one, track another" tree-DP pattern.

Encode a binary tree to a string and decode it back. Demonstrates traversal + parsing in one problem.

Build a trie with insert, search, and startsWith. The fundamental string-indexed dictionary.

Find the k-th largest in O(n) average with quickselect, or O(n log k) with a min-heap. Two solutions worth knowing.

Support add(x) and findMedian() on a growing stream. Two heaps split below/above the median.

Generate all well-formed parenthesis strings of length 2n. The canonical "count remaining" backtracking.

Generate all n! permutations of an array. Backtracking with a "used" set; sibling of Subsets.

Generate all 2^n subsets of an array. The reference template for every backtracking problem.

Decide whether a word can be spelled by a path through neighboring cells. DFS with mark-and-unmark backtracking.

Decide if all courses can be completed given prerequisites. Topological sort with cycle check.

Count connected components of land cells in a grid. Grid-DFS in its purest form.

Find the shortest transformation sequence between two words via one-letter swaps. BFS on an implicit graph.

Count ways to climb n stairs taking 1 or 2 at a time. The simplest non-trivial DP.

Max non-adjacent subarray sum. The simplest linear DP after Fibonacci.

Find the contiguous subarray with the largest sum. Kadane's algorithm in 4 lines.

Minimum coins to make a target amount. Greedy fails; DP nails it.

Decide whether a string can be segmented into a sequence of dictionary words. DP over prefix lengths.

Minimum edits to turn one string into another. The textbook 2D DP.

Find the longest palindrome substring. Center-expansion in O(n²); Manacher in O(n).

Implement regex matching with . and *. 2D DP that everyone gets wrong on the first try.

Collapse overlapping intervals into a minimal cover. Sort + linear sweep — the intervals primitive.

Derive the famous (p − y) gradient of softmax + cross-entropy and explain why fusing them is critical for numerical stability.

Compute running mean and variance in one pass without numerical instability. The Welford recurrence.

Sample k items uniformly from a stream of unknown length. Foundational streaming ML.

Implement the sigmoid, compute its derivative, and explain why σ(x)(1−σ(x)) makes backprop cheap.

Implement softmax without overflowing on large logits. The log-sum-exp trick.

Forward + backward pass on a 2-layer MLP by hand. The autograd primitive every ML candidate should be able to write from scratch.

Implement inverted dropout (forward + backward) and explain why the scale factor lives in training, not inference.

Implement Lloyd's algorithm in pure NumPy. The unsupervised baseline.

Implement layer norm (forward + backward) and explain how it differs from batch norm. Foundational transformer component.

Implement scaled dot-product attention and a single-head self-attention block. The transformer's load-bearing primitive.

Extend single-head attention to multi-head with split/concat. The complete transformer attention block.

Implement PCA via SVD: center, decompose, project. The dimensionality-reduction primitive every ML engineer must know.