The Blind 75 LeetCode Problems: Every Interview Pattern, No Gaps

In 2018, a Meta engineer named Yangshun Tay posted a list on Teamblind: 75 problems, every major pattern, no filler. It got copy-pasted, bookmarked, and passed around Discord servers until half the industry treated it like a sacred text. The Blind 75 LeetCode problems list is genuinely good. It also has gaps.

No tries. No backtracking. No greedy. No intervals. A thin stack section. One company's interview patterns from six years ago.

The list below patches those gaps while staying at 75. Every problem earns its spot by teaching something the others don't. If you can solve all 75 and explain why you solved them the way you did, you are ready for any standard FAANG loop.

The Problems Don't Matter. The Patterns Do.

You can solve 400 problems and still fail if you grind them as isolated puzzles. The reason these 75 work is that each problem is the canonical representative of a recognizable structure. When you see a new problem, you should be mapping it to a pattern, not frantically Ctrl-F'ing your memory for a similar problem title. If that sounds obvious, most people are still not doing it.

Work through each section. Once a pattern clicks, the other problems in that section start feeling like variations on a theme, because they are. This is either deeply satisfying or mildly unsettling, depending on how many hours you've already spent treating them as unrelated.

Arrays and Hashing

The warmup section doubles as the foundation. If you can't hold state in a hash map while scanning, everything downstream breaks. Two Sum is basically the Hello World of this discipline. Embarrassingly simple in hindsight. Yet here we all are.

#	Problem	Diff	What it teaches
1	Two Sum (1)	E	Complement lookup: O(n) by trading space for a second pass
2	Contains Duplicate (217)	E	Hash set membership; the O(1) existence check
3	Group Anagrams (49)	M	Sorted string as canonical key; all anagrams map to the same key
4	Product of Array Except Self (238)	M	Two-pass left/right product; division-free trick earns its own insight
5	Longest Consecutive Sequence (128)	M	Only start counting from unstarted elements; avoid redundant O(n²) chains

Two Pointers

Two pointers eliminate the second loop. The insight is always the same: moving a pointer toward the center is equivalent to rejecting all states you skip over. This sounds like something a professor says right before it clicks, then feels obvious forever after.

#	Problem	Diff	What it teaches
6	Valid Palindrome (125)	E	Skip-logic while advancing; the two-pointer skeleton
7	3Sum (15)	M	Sort, fix one element, two-pointer the rest; dedup by skipping equal values
8	Container With Most Water (11)	M	Greedy argument: only the shorter side can possibly improve
9	Trapping Rain Water (42)	M	When leftMax < rightMax, the left bar is the bottleneck regardless of what's right

Sliding Window

Every sliding window problem asks one of two things: the longest window satisfying a condition, or the shortest window that does. The template is the same; the shrink condition changes. Which is roughly the most useful and simultaneously most unhelpful thing you can say. The full mechanics are in the sliding window guide if you want the derivation before you start.

#	Problem	Diff	What it teaches
10	Best Time to Buy and Sell Stock (121)	E	Sliding minimum; the simplest dynamic window
11	Longest Substring Without Repeating Characters (3)	M	Shrink on first repeated character
12	Longest Repeating Character Replacement (424)	M	The max_count approximation: you don't need the exact current max
13	Minimum Window Substring (76)	H	Expand until valid, contract until invalid; a `need` counter avoids inner loops
14	Sliding Window Maximum (239)	H	Monotonic deque: pop front when expired, pop back when smaller than new element

Stack

Stacks solve problems where you need to remember unresolved things and resolve them later. That sounds vague until you notice half your interview problems fit that description. The stack is the data structure that keeps showing up uninvited, and it's usually right.

#	Problem	Diff	What it teaches
15	Valid Parentheses (20)	E	Unresolved openers live on the stack; closed by matching closers
16	Min Stack (155)	M	Parallel min-tracking stack; synced push/pop maintains the invariant
17	Daily Temperatures (739)	M	Waiting room: elements wait on the stack for a warmer day to pop them
18	Largest Rectangle in Histogram (84)	H	Contribution counting: each bar is the minimum of some rectangle; stack finds the width

Binary Search

Binary search is not a search algorithm. It is a way to halve a decision space whenever a monotonic predicate exists. LC 704 is the template. Everything else is a different predicate. This distinction feels like splitting hairs until you're staring at Koko Eating Bananas wondering why the array has nothing to do with anything.

#	Problem	Diff	What it teaches
19	Binary Search (704)	E	Closed-interval [lo, hi] invariant; `lo + (hi - lo) // 2` avoids overflow
20	Search in Rotated Sorted Array (33)	M	Identify which half is sorted; recurse on the sorted half
21	Find Minimum in Rotated Sorted Array (153)	M	Binary search for the inflection point, not a target value
22	Koko Eating Bananas (875)	M	Search the answer space with a feasibility predicate; array is irrelevant
23	Median of Two Sorted Arrays (4)	H	Binary search on a partition of two arrays; O(log(min(m,n)))

Linked List

Linked list problems are solved by one of three techniques: the sentinel node (eliminates edge cases), the two-pointer gap (nth from end, cycles), or the find-middle-and-reassemble pattern. Linked lists are the data structure interviewers love and real engineers almost never actually use in production. Enjoy the irony.

#	Problem	Diff	What it teaches
24	Reverse Linked List (206)	E	prev/curr/next iteration; memorize both iterative and recursive
25	Merge Two Sorted Lists (21)	E	Sentinel node: a dummy head removes the "empty list" special case
26	Linked List Cycle (141)	E	Fast-slow pointer: cycle means they meet
27	Remove Nth Node From End (19)	M	Gap of N+1: advance fast pointer first, then move both
28	Reorder List (143)	M	Find middle, reverse second half, interleave; three primitives fused
29	Merge K Sorted Lists (23)	H	Min-heap of size k; O(n log k) vs O(nk) naive

Trees

Tree problems split into two families: problems where you return a value upward (compute subtree properties) and problems where you pass a value downward (validate constraints). Knowing which direction the information flows decides your approach before you write a line. This is the kind of thing that sounds obvious after you've seen it enough and completely invisible before.

#	Problem	Diff	What it teaches
30	Invert Binary Tree (226)	E	Recursive swap; the simplest DFS
31	Maximum Depth of Binary Tree (104)	E	Return height upward; base case
32	Diameter of Binary Tree (543)	E	Global max updated internally, local height returned; these diverge for the first time here
33	Binary Tree Level Order Traversal (102)	M	BFS snapshot trick: loop `for _ in range(len(queue))` to process one level
34	Validate BST (98)	M	Propagate range [min, max] downward; parent comparison alone fails
35	Lowest Common Ancestor of Binary Tree (236)	M	Post-order: if both children return non-null, this node is the LCA
36	Construct Tree from Preorder and Inorder (105)	M	Preorder[0] is root; find it in inorder to split left/right subtrees
37	Binary Tree Right Side View (199)	M	BFS: last node per level. DFS: only record when depth == result length
38	Kth Smallest Element in BST (230)	M	Inorder traversal is sorted; decrement counter, return on zero
39	Binary Tree Maximum Path Sum (124)	H	Each node returns max gain upward; global answer considers both children

Tries

A trie is the right tool when you need prefix queries over a fixed dictionary. The first time it works, it feels like magic. The second time, you wonder why you ever used anything else. Two problems cover everything you need.

#	Problem	Diff	What it teaches
40	Implement Trie (208)	M	TrieNode with children and is_end; prefix search differs from word search
41	Word Search II (212)	H	DFS pruning via trie; set `is_end = False` after finding to avoid re-reporting

Heap / Priority Queue

A heap answers one question efficiently: what is the best element so far? It is the data structure equivalent of "sorted, but only the part you actually need." Every heap problem reduces to tracking a running set of k best elements or merging sorted streams.

#	Problem	Diff	What it teaches
42	Kth Largest Element in Array (215)	M	Min-heap of size k; the kth-largest becomes the heap minimum
43	K Closest Points to Origin (973)	M	Max-heap of size k, or quickselect for O(n) average
44	Task Scheduler (621)	M	Formula: `(max_count - 1) * (n + 1) + count_of_max`; teaches modeling over simulation
45	Find Median from Data Stream (295)	H	Two heaps (max-heap for lower half, min-heap for upper); balance after each insert

Backtracking

The original Blind 75 has no backtracking. This is one of its real gaps, and also a little ironic for a list people keep coming back to and revising. Subsets, combinations, and permutations each have a distinct tree shape and cost. Learn all three. They show up constantly.

#	Problem	Diff	What it teaches
46	Subsets (78)	M	Include/exclude at each index; O(n·2^n)
47	Combination Sum (39)	M	Reuse allowed via same-index recursion; start index prevents duplicates
48	Permutations (46)	M	used[] array; every branch has n choices; O(n·n!)
49	Word Search (79)	M	DFS with in-place marking; restore the cell on backtrack
50	Palindrome Partitioning (131)	M	Backtracking combined with palindrome check; prune early on non-palindromes

Graphs

Graph problems test two things: traversal mechanics and the ability to model a problem as a graph. The second part is harder. Islands and courses look nothing alike, but they use the same DFS skeleton. Most of what makes graph problems feel hard is the modeling step, not the traversal.

#	Problem	Diff	What it teaches
51	Number of Islands (200)	M	Outer loop is mandatory for disconnected graphs
52	Pacific Atlantic Water Flow (417)	M	Reverse BFS from both coasts; intersection is the answer
53	Clone Graph (133)	M	Hash map node → clone prevents infinite recursion on cycles
54	Course Schedule (207)	M	Topological BFS: cycle = processed count != n
55	Course Schedule II (210)	M	Topological order as output, not just feasibility
56	Redundant Connection (684)	M	Union-Find: add edge, detect same component before union
57	Network Delay Time (743)	M	Dijkstra template on a directed weighted graph
58	Cheapest Flights Within K Stops (787)	M	Bellman-Ford with K+1 passes; snapshot copy prevents same-pass cascades

Intervals

Every interval problem reduces to the same two operations: checking whether two intervals overlap and deciding how to merge them. The overlap predicate is a.start <= b.end AND b.start <= a.end. Using max() in the merge step is not optional and is exactly the step most people skip, resulting in silent containment bugs that are very fun to debug at midnight.

#	Problem	Diff	What it teaches
59	Merge Intervals (56)	M	Sort by start; `max(current.end, prev.end)` is not optional on containment
60	Insert Interval (57)	M	Three-phase scan without resorting: before, overlap, after
61	Non-overlapping Intervals (435)	M	Activity selection: sort by end time, greedily keep earliest-ending

1D Dynamic Programming

DP is recursion with a cache. The state design is the whole problem. Every problem below has a simple recurrence once you identify what the state is. The hard part is not the code. The dynamic programming framework covers how to find the state before you touch a problem.

#	Problem	Diff	What it teaches
62	Climbing Stairs (70)	E	Fibonacci recurrence as DP intro; state = steps remaining
63	House Robber (198)	M	`dp[i] = max(dp[i-1], dp[i-2] + nums[i])`; rolling two variables
64	House Robber II (213)	M	Circular breaks DP; run twice excluding first/last element
65	Coin Change (322)	M	Unbounded knapsack; initialize to infinity, iterate low-to-high
66	Longest Increasing Subsequence (300)	M	O(n²) DP or O(n log n) patience sorting; both worth knowing
67	Word Break (139)	M	DP with inner loop over word lengths; teaches string DP
68	Decode Ways (91)	M	Two lookback values; the edge case where digit is '0' is the whole problem
69	Partition Equal Subset Sum (416)	M	0/1 knapsack; iterate capacity high-to-low or you reuse elements in the same pass

2D Dynamic Programming

When state depends on two sequences or a grid, the recurrence becomes a table. Space can often be compressed to one row. This feels great. Then you try to reconstruct the path and realize you threw away the information you needed. Such is life.

#	Problem	Diff	What it teaches
70	Unique Paths (62)	M	Grid DP; `dp[i][j] = dp[i-1][j] + dp[i][j-1]`
71	Longest Common Subsequence (1143)	M	The canonical 2D string DP; match on equal chars, skip on mismatch
72	Edit Distance (72)	H	Three operations; `min(insert, delete, replace) + 1`
73	Burst Balloons (312)	H	Interval DP inversion: think about the last balloon popped, not the first

Bit Manipulation

The original Blind 75 has five bit manipulation problems. Most of them teach the same trick. Two cover everything you need. Bit manipulation is the interview equivalent of a party trick: impressive once, slightly tedious the fifth time, but you still have to know it.

#	Problem	Diff	What it teaches
74	Number of 1 Bits (191)	E	`n & (n-1)` clears the lowest set bit; count iterations
75	Missing Number (268)	E	XOR all indices and values; self-cancellation leaves the missing one

How to Work Through This List

Do not solve them in order. Work by section. Finish every problem in a section before moving on.

For each problem: 30-minute timer, no hints, no peeking at the tag. When you finish, write down the pattern signal that should have told you the approach before you started. That log is what actually builds interview skill. Your solved count is for telling people at dinner parties. The pattern log is for getting offers.

The hardest problems in most sections (84, 76, 239, 4, 124, 295, 72, 312) are skippable unless you are targeting Google L5+ or a staff-level role. Most interviewers want a medium solved cleanly with clear communication. That is 48 of the 75 problems above. The case for focusing on mediums is worth reading before you start.

If you want to drill specifically for voice-based technical interviews, SpaceComplexity lets you work through these problems out loud with an AI interviewer that scores your explanation, not just your code. Most candidates who can solve LC 743 silently still cannot explain Dijkstra's relaxation loop under pressure. That gap shows up in the debrief.