Blind 75

The Blind 75 is a curated list of 75 LeetCode problems by Yangshun Tay (2018). Mastering these gives you the recurring patterns behind 90% of FAANG…

The Blind 75 is a curated list of 75 LeetCode problems created by Yangshun Tay in 2018. It covers the most frequently asked coding interview questions…

Extracted from How to Rock the Coding Interview by Yangshun Tay (Google, Airbnb, Dropbox offers) and the Blind 75 series by Uluc Ozdenvar.

"Sorted? → Binary search or two pointers. Unsorted? → HashMap. Contiguous? → Kadane or sliding window."

Store each value’s index as you walk the array; the partner you need is target - current, which you can look up in O(1) with a map.

Either extend the best subarray ending at the previous index, or start fresh at the current element—whichever gives a larger sum.

A negative number can turn a small (most negative) running product into the largest product, so track both the max and min product ending at each index.

Compare mid to the right boundary: if nums[mid] > nums[right], the minimum lies in the right half; otherwise it lies in the left half (including mid).

At each mid, one half [left, mid] or [mid, right] is sorted; use that ordering to decide whether target can lie in that half.

Fix one element, then run sorted two-sum on the rest to find pairs that sum to the negative of the fixed value—total \(O(n^2)\) with deduplication.

Start with the widest container; moving the taller line never improves area, so always move the shorter pointer inward.

Track the minimum price seen so far while walking forward; the best profit at index i is prices[i] - minSoFar.

Walk the array, adding each value to a HashSet. If a value is already there, you found a duplicate.

For each index i, answer[i] = (product of everything to the left) * (product of everything to the right). Build these two passes in O(n) and combine.

"Pairs cancel → XOR. Lowest set bit → n & -n. Drop lowest set bit → n & (n-1)."

XOR gives sum without carry; AND (shifted) isolates carry—repeat until carry disappears.

Each n & (n - 1) clears the lowest set bit—count how many times you can do that before n becomes 0.

count[i] = count[i >> 1] + (i & 1) — the count for i is the count for half of i, plus whether the last bit is 1.

XOR every index with every value; pairs (i, nums[i]) for present numbers cancel—what remains is the missing index.

For each bit of n, shift the answer left and merge the next bit from n—you walk n from LSB to MSB while building the reversed word.

"What is the smallest piece of the answer I can compute? Now express the bigger answer in terms of smaller pieces."

A string is breakable if some prefix is a dictionary word and the remainder is also breakable—so you reuse answers for suffixes.

Distinct sequences count permutations: ways to reach sum t equals the sum over coins of ways to reach t - coin.

At each house, your best loot is either skip this house (take previous best) or rob this house plus best from two steps back—never two adjacent.

The circle forbids robbing both first and last; solve line House Robber twice—once excluding the last house, once excluding the first—and take the max.

Ways to decode a prefix equal ways after one valid digit plus ways after one valid two-digit letter, with careful handling of '0'.

Track the farthest index reachable from the start; if you ever reach an index beyond current reach, fail; if reach ≥ last index, succeed.

If last characters match, LCS is 1 + LCS of prefixes without both lasts; if not, take the better of dropping one side.

Ways to reach step n = ways to reach n-1 + ways to reach n-2. Problem walkthrough from the Blind 75 pattern set — Java templates, complexity analysis and…

dp[a] = fewest coins to make amount a. For each amount, try every coin and take the minimum.

For each i, the LIS ending at i is 1 + max(dp[j] for j < i where nums[j] < nums[i]).

dp[i][j] = ways to reach cell (i, j) = dp[i-1][j] + dp[i][j-1]. Robot only moves right or down.

"Level-by-level → BFS. Explore-everything → DFS. Ordering → Topo. Grouping → Union-Find."

Map each original node to its clone once, then wire neighbors by looking up clones in that map so you never duplicate nodes or get stuck in cycles.

If you can order all courses respecting prerequisites, the prerequisite graph is a DAG; if there is a cycle, some course depends on itself indirectly and…

Water flows downhill to lower or equal heights; instead of simulating from every cell outward, start from ocean borders and mark everywhere water can flow…

Each '1' cell is land; 4-directionally connected '1' cells form one island — count connected components by sinking visited land to avoid recounting.

Treat each number as a node with edges to n-1 and n+1; avoid O(n²) by only starting a streak at n when n-1 is missing.

An undirected graph on n labeled nodes 0..n-1 is a tree iff it is connected and has exactly n-1 edges with no cycles — equivalently: n-1 edges + connected +…

Start with n isolated nodes; each edge merges two components — track how many components remain, or count DFS/BFS launches from unvisited nodes.

Compare adjacent words to extract ordered letter edges; a valid alphabet is a topological order of that graph — impossible if there is a cycle or a prefix…

"Top-K → size-K heap. K-way merge → heap of K heads. Streaming median → two heaps balanced."

Always pick the smallest current head among k lists using a min-heap ordered by node value (tie-break by list id).

Count frequencies, then either use a min-heap of size k on frequencies or bucket indices by frequency for O(n) time.

Keep lower half in a max-heap and upper half in a min-heap; sizes differ by at most 1; median from tops.

"Intervals → sort first. Merge → by start. Greedy non-overlap → by end. Rooms count → heap of ends."

After sorting by start, each interval either extends the current merged block or starts a new one.

To fit maximum non-overlapping intervals, always keep the interval that ends earliest—it leaves the most room for the future.

Split the existing intervals into three groups relative to newInterval: those that end before, those that overlap, and those that start after. Merge the…

At any moment, the number of rooms in use equals the number of meetings whose start ≤ now < end. Process meetings by start time; reuse a room whenever the…

"Head might change → dummy node. Find position → slow/fast. Reverse → 3 pointer dance (prev, curr, next)."

Change each node’s next to point to the previous node while walking forward; track prev and curr.

If a tortoise and hare move at 1 and 2 steps per tick, they meet inside the cycle if and only if a cycle exists.

Advance a “fast” pointer n+1 steps ahead of “slow” behind a dummy; when fast hits null, slow is just before the node to remove.

Split the list in half, reverse the second half, then zip-merge first and second halves alternately.

Walk both lists with one pointer each. Repeatedly append the smaller head to the result. Use a dummy node so we never special-case the very first append.

Push the head node of each list into a min-heap. Repeatedly poll the smallest, append it to the result, and push its next.

"Rotate = Transpose + Reverse. Spiral = 4 boundaries that shrink. Word search = DFS + backtrack with # marker."

If matrix[i][j] == 0, row i and column j must become zero; store which rows/cols need clearing using O(1) extra space by repurposing the first row and first…

Walk right → down → left → up along the current rectangle border, then shrink the rectangle; after each direction, check if the border collapsed to avoid…

A 90° clockwise rotation equals transpose then reverse each row (for square matrices); alternatively rotate four cells in place in one loop.

From each cell, DFS along valid neighbors matching the next character; mark visited on the path and undo (backtrack) when returning so other branches can…

"Contiguous + constraint → sliding window. Palindrome → expand from center. Anagram → frequency count."

For each right, move left just past the previous index of s[right] so the window never holds duplicates.

A window is valid if (window length) - (count of most frequent char) <= k — you only need to replace the “minority” characters.

Expand until the window covers all required characters, then shrink from the left as much as possible while still valid—track “how many required chars have…

Prefix each chunk with its length and a delimiter that cannot appear in the length token (e.g. 5#hello), so decoding is unambiguous.

Anagrams share the same character counts—use a canonical key (sorted string or count signature) as the HashMap key.

Each closing bracket must match the most recent unmatched opening bracket—LIFO order.

Every palindrome has a center (one character for odd length, between two chars for even)—try all centers and expand while ends match.

Each palindrome has a center; expand outward and count how many palindromes each center generates (usually 1 per successful expansion step).

Two strings are anagrams iff each character appears the same number of times in both. Track counts with int[26].

One pointer from each end. Skip non-alphanumerics. Compare lowercased characters.

"Tree problem → recursion. Level info → BFS with size loop. BST → inorder gives sorted order. Path-sum-style → DFS that returns the best path ending at the…

The depth of a node is 1 + max(depth of left subtree, depth of right subtree); the base case is an empty subtree (depth 0).

At each node, the best path through that node uses the node plus at most one best “chain” from left and one from right; return to parent only a single…

Process nodes level by level using a queue: dequeue a level’s worth of nodes, enqueue their children, repeat.

A preorder string that records null for missing children uniquely defines the tree shape; deserialize consumes tokens left-to-right matching that preorder.

subRoot is a subtree of root if some node x in root has identical structure and values to subRoot; verify with a helper isSame(a, b).

Preorder’s first element is the root; find that value in inorder to split left size vs right size; recurse on subranges.

In a BST, every node’s value must lie in an open interval (min, max) inherited from ancestors; left child tightens the upper bound, right child tightens the…

Inorder traversal of a BST visits nodes in sorted ascending order; the kth visited node is the kth smallest.

Walk from the root: if both p and q are smaller than current, go left; if both larger, go right; otherwise current is the split → LCA.

Two trees are identical iff their roots have equal values and their left subtrees are identical and their right subtrees are identical.

At each node, swap its left and right children. Recurse on both. Result is the mirror image of the original tree.

"Many prefix queries on a dictionary → Trie. Wildcards → Trie + DFS. Many target words in text/grid → Trie + DFS with pruning."

Each node holds links to 26 (or alphabet-sized) children and an isEnd flag; insert walks/creates edges; search/startsWith follow edges and check termination.

. matches any single letter — at a . node, try all non-null children recursively; otherwise follow the single matching edge.

Put all words in one trie; DFS from each cell, following trie edges; on end, record word and prune node to avoid duplicates.