TL;DR: The Blind 75 is a list of 75 LeetCode problems, grouped by data structure. Grouped by the technique that solves each one instead, the same 75 problems use 27 patterns, and the five biggest cover 31 of them. The table below maps every problem to its pattern and to the tell, the words in the statement that give the pattern away. Six problems are locked behind LeetCode Premium, and each has a free equivalent. Learn the patterns first, then use the list as the test.
A problem list tells you what to solve. It does not tell you what you are practicing when you solve it. This page adds that second column, for all 75.
What the Blind 75 is
The Blind 75 is a list of 75 LeetCode problems. Yangshun Tay, then an engineer at Facebook, posted it on Blind, the anonymous forum for tech employees. He chose the problems he had used for his own job search. He grouped them by data structure: Array, Binary, Dynamic Programming, Graph, Interval, Linked List, Matrix, String, Tree, and Heap.
The list lasted for two reasons. It is short enough to finish. And most other LeetCode problems combine techniques from these 75, so finishing it prepares you for far more than 75 problems.
Why group it by pattern instead of by topic
A topic is a data structure. A pattern is a reusable solution shape with a tell, the words in the problem statement that point to it. The interview question arrives without a topic label, so the pattern is the thing you have to recognize.
The list's own groups hide this. Longest Consecutive Sequence sits under Graph, and it is solved with a hash set. Word Search sits under Matrix, and it is backtracking. Jump Game sits under Dynamic Programming, and the clean solution is greedy. Missing Number sits under Binary, and the technique is cyclic sort.
Grouped by pattern, the list shows what each problem trains. It also shows which patterns the list trains a lot, and which it trains once.
The full map
Every problem, grouped by the pattern that solves it. The patterns with the most problems come first. A problem marked (Premium) is locked behind LeetCode Premium; free equivalents are in the section after the table.
| Pattern | Problems | The tell |
|---|---|---|
| Tree DFS (10) | Maximum Depth of Binary Tree, Same Tree, Invert Binary Tree, Binary Tree Maximum Path Sum, Serialize and Deserialize Binary Tree, Subtree of Another Tree, Construct Binary Tree from Preorder and Inorder Traversal, Validate Binary Search Tree, Kth Smallest Element in a BST, Lowest Common Ancestor of a BST | a tree, and a question about a path, a depth, an ancestor, or whether two trees match |
| Fibonacci-style DP (6) | Maximum Product Subarray, Climbing Stairs, House Robber, House Robber II, Decode Ways, Unique Paths | the answer for position n depends on the answers for n-1 and n-2 |
| Hash Maps (5) | Two Sum, Contains Duplicate, Longest Consecutive Sequence, Valid Anagram, Group Anagrams | counting, grouping, or checking membership; "have I seen this before" |
| Matrix Traversal (5) | Pacific Atlantic Water Flow, Number of Islands, Set Matrix Zeroes, Spiral Matrix, Rotate Image | a grid, and a question about regions, spreading, or reaching an edge |
| Merge Intervals (5) | Insert Interval, Merge Intervals, Non-overlapping Intervals, Meeting Rooms (Premium), Meeting Rooms II (Premium) | start and end pairs, and a question about overlap, gaps, or how many at once |
| Bitwise XOR (4) | Sum of Two Integers, Number of 1 Bits, Counting Bits, Reverse Bits | bits, parity, or "without using the + operator" |
| Sliding Window (4) | Best Time to Buy and Sell Stock, Longest Substring Without Repeating Characters, Longest Repeating Character Replacement, Minimum Window Substring | a contiguous run of an array or string, and "longest", "shortest", or "at most k" |
| Two Pointers (4) | 3Sum, Container With Most Water, Remove Nth Node From End of List, Valid Palindrome | sorted input, or a pair that must satisfy a condition, with O(1) extra space |
| Trie (3) | Implement Trie (Prefix Tree), Add and Search Word, Word Search II | many words, and prefix or wildcard search over them |
| Unbounded Knapsack (3) | Coin Change, Word Break, Combination Sum IV | items or choices that can be reused, and a target to reach or count |
| Greedy (2) | Maximum Subarray, Jump Game | a local best choice at each step gives the global best |
| In-place Reversal (2) | Reverse a Linked List, Reorder List | a linked list that must be reversed or rearranged with O(1) extra space |
| K-way Merge (2) | Merge Two Sorted Lists, Merge K Sorted Lists | several sorted inputs that must become one sorted output |
| Longest Common Subsequence family (2) | Longest Increasing Subsequence, Longest Common Subsequence | two sequences compared, or one sequence and a "longest increasing" ask |
| Modified Binary Search (2) | Find Minimum in Rotated Sorted Array, Search in Rotated Sorted Array | sorted or rotated input and an O(log n) requirement |
| Palindromic Subsequence (2) | Longest Palindromic Substring, Palindromic Substrings | the word "palindrome", counted or maximized |
| Topological Sort (2) | Course Schedule, Alien Dictionary (Premium) | tasks with prerequisites, or an order that must respect dependencies |
| Union Find (2) | Graph Valid Tree (Premium), Number of Connected Components in an Undirected Graph (Premium) | edges arriving as pairs, and a question about connected groups or cycles |
| Backtracking (1) | Word Search | all combinations or all paths, with dead ends to abandon |
| Cyclic Sort (1) | Missing Number | numbers in a known range 1 to n, and a missing or duplicate one |
| Fast & Slow Pointers (1) | Detect Cycle in a Linked List | a linked list and a cycle, a middle, or a loop start |
| Graphs (1) | Clone Graph | nodes and edges, and a copy, a reachability, or a traversal |
| No pattern needed (1) | Encode and Decode Strings (Premium) | a design question with one standard trick (length-prefix encoding) |
| Prefix Sum (1) | Product of Array Except Self | range totals or products, asked many times |
| Stacks (1) | Valid Parentheses | matching brackets, or the most recent unresolved item |
| Top K Elements (1) | Top K Frequent Elements | "k largest", "k most frequent", "k closest" |
| Tree Level Order Traversal (1) | Binary Tree Level Order Traversal | a tree, and an answer per level |
| Two Heaps (1) | Find Median from Data Stream | a running median, or the middle of a stream |
Every pattern above has its tell and its template in the pattern guide. The ones with a deep dive on this site are linked in the table.
Where to start
The five biggest patterns cover 31 of the 75 problems: Tree DFS (10), Fibonacci-style DP (6), Hash Maps (5), Matrix Traversal (5), Merge Intervals (5). Learn those five first, in that order, and more than a third of the list becomes practice instead of discovery.
The single-problem patterns at the bottom of the table are the ones the list barely trains. If your target company asks them, the list alone will not prepare you, and the pattern guide fills the gap.
The six locked problems, and free equivalents
Six problems on the list need LeetCode Premium. You can pay for one month, or solve a free problem that trains the same pattern.
| Locked problem | Pattern | Free equivalent |
|---|---|---|
| Meeting Rooms | Merge Intervals | Non-overlapping Intervals: the same overlap check, sorted by start |
| Meeting Rooms II | Merge Intervals with a min-heap | Car Pooling: the same count-at-once question, on a number line |
| Alien Dictionary | Topological Sort | Course Schedule II: the same ordering with dependencies, without the string parsing |
| Graph Valid Tree | Union Find | Redundant Connection: the same cycle detection with union find |
| Number of Connected Components in an Undirected Graph | Union Find | Number of Provinces: the same component count |
| Encode and Decode Strings | No pattern needed | Implement it yourself with length-prefix encoding and your own test cases |
Whether Premium is worth buying for the list is a separate question, answered in LeetCode Premium vs Free.
How to use the list
Learn the pattern before its problems. Read the tell and the template for one pattern, then solve that pattern's problems from the table as a block. Solving them as a block installs the template. Solving them in the list's original order, one topic at a time, hides it.
Then use the list as the test. Once the patterns are installed, take unseen problems in mixed order and practice naming the pattern from the tell before you write code. That diagnosis step is the skill the interview measures.
Pace it by the calendar. One properly solved problem a day finishes the list in about 12 weeks. Three a day finishes it in four. The full pace table is in The LeetCode Daily Schedule.
Pick the right list first. The Blind 75 is the shortest of the three common lists. If you have more time, or a harder target, compare it with the other two lists first: Blind 75 vs NeetCode 150 vs Grokking 75.
Want the patterns taught before the problems? Grokking the Coding Interview covers all 42 patterns, each with its tell and template. Then it gives you 300+ problems, sequenced so each one stretches the last. On a deadline, Grokking 75 is the 75-problem version of the same method.
The takeaway
The Blind 75 is 75 problems and 27 patterns. Five patterns cover 31 problems, six problems are locked, and every one of them has a pattern you can name from the statement. Learn the patterns as blocks, then work the list in mixed order as the exam. The list is the test, not the syllabus.
The original patterns course: Grokking the Coding Interview, all 42 patterns, 300+ problems in six languages, one-time $79 with lifetime access.
FAQs
What is the Blind 75? A list of 75 LeetCode problems chosen by Yangshun Tay and posted on the Blind forum. It is grouped by data structure, it is short enough to finish, and most other LeetCode problems combine techniques from it.
Is the Blind 75 enough for FAANG interviews? It covers the common patterns once each, which is enough for many loops if every problem is solved to a real quality bar. It trains several patterns only once, so pair it with a pattern reference and add mock interviews in the last two weeks.
Blind 75 or NeetCode 150? The Blind 75 is the shorter list and the NeetCode 150 adds a second problem per pattern plus a study order. With four to six weeks, do the 75. With more time, the 150. The full comparison is in Blind 75 vs NeetCode 150 vs Grokking 75.
How long does the Blind 75 take? About 12 weeks at one properly solved problem a day, six weeks at two a day, and four weeks at three a day. A properly solved problem takes about an hour: attempt, post-mortem, re-code, and a one-line note.
Which Blind 75 problems are Premium? Six: Meeting Rooms, Meeting Rooms II, Alien Dictionary, Graph Valid Tree, Number of Connected Components in an Undirected Graph, and Encode and Decode Strings. Each has a free problem that trains the same pattern, listed above.
Is there a Blind 75 PDF? The list itself is free on the original forum post and on many mirrors. This page prints cleanly as the pattern-grouped version, with the tell for each pattern, which the plain list does not carry.
Related guides
- Blind 75 vs NeetCode 150 vs Grokking 75: Which List Should You Actually Do?
- The NeetCode Roadmap on One Page, With the Pattern Behind Each of the 18 Topics
- The DSA Patterns Cheat Sheet: All 41 on One Page
- LeetCode Premium vs Free: Every Feature Compared, and the Four That Matter for Interviews
- The Only 75 LeetCode Problems You Need (Grokking 75)