TL;DR: You don't need 500 LeetCode problems. You need 75 of the right ones, in the right order. Grokking 75 is a curated list organized by coding pattern, built from the questions top tech companies actually asked in the past year. This post gives you the full list, a 6-week schedule to work through it, and an honest comparison with Blind 75 and NeetCode 150. It also regroups LeetCode's own study plan, LeetCode 75, by the pattern that solves each problem, because the two lists are easy to confuse and they share only 17 problems.
LeetCode has over 3,000 problems. At one problem per day, clearing the site would take you eight years. Nobody does that, and nobody needs to, because interview questions are not 3,000 unique challenges. They are a few dozen underlying patterns wearing different costumes.
That means the entire game of interview prep is choosing which small set of problems to study so that the patterns transfer to problems you've never seen. In 2018, an engineer posted a list of 75 problems on Blind that became legendary for exactly this reason. It was a good list. But it's aging, it was never ordered for learning, and it has real gaps.
Grokking 75 is our answer: 75 problems, organized by pattern, sequenced so each topic builds on the last, and refreshed against what FAANG companies actually asked in the past year. I'll give you the whole list below, then show you how to use it.
What makes a 75-problem list actually work
Having reviewed candidates on both sides of the table for years, I can tell you the difference between a list that produces offers and a list that produces burnout comes down to three properties:
1. Pattern coverage, not problem count. Every common interview pattern should appear with enough variations that you learn the pattern's range, not one frozen example. A list with six sliding window problems and zero monotonic stack problems fails the coverage test no matter how famous its problems are.
2. Learning order. Arrays before linked lists. Tree DFS before graph DFS. Plain recursion before backtracking, and backtracking before dynamic programming. When a list is unordered, every problem is a cold start. When it's sequenced, each problem reuses mental machinery from the previous section, which is what makes 75 problems feel like 40.
3. Recency. Interview fashion moves. Monotonic stack questions (like Daily Temperatures) barely existed in interviews in 2018 and are now routine. Tries and matrix-traversal problems show up far more often than older lists reflect. A list frozen in 2018 leaves you unprepared for today's loops.
Blind 75 scores well on the first property, poorly on the other two. That's the gap Grokking 75 was built to close.
The Grokking 75 list
Work through the sections in order. Difficulty is marked E (easy), M (medium), H (hard).
Array / String
- Kids With the Greatest Number of Candies (E)
- Roman to Integer (E)
- Best Time to Buy and Sell Stock (E)
- Zigzag Conversion (M)
- Jump Game (M)
- Jump Game II (M)
- H-Index (M)
Two Pointers
- Pair with Target Sum (E)
- Dutch National Flag Problem (M)
- Comparing Strings Containing Backspaces (M)
- Minimum Window Sort (M)
Sliding Window
- Maximum Average Subarray I (E)
- Maximum Number of Vowels in a Substring of Given Length (M)
- Max Consecutive Ones III (M)
- Longest Subarray of 1's After Deleting One Element (M)
- Minimum Size Subarray Sum (M)
- Longest Substring Without Repeating Characters (M)
Matrix
- Valid Sudoku (M)
- Spiral Matrix (M)
- Rotate Image (M)
- Set Matrix Zeroes (M)
Hash Map / Set
- Contains Duplicate II (E)
- Word Pattern (E)
- Determine if Two Strings Are Close (M)
- Group Anagrams (M)
- Longest Consecutive Sequence (M)
Linked List
- Add Two Numbers (M)
- Reverse Linked List II (M)
- Odd Even Linked List (M)
- Reverse Nodes in k-Group (H)
Stack & Monotonic Stack
- Valid Parentheses (E)
- Evaluate Reverse Polish Notation (M)
- Simplify Path (M)
- Daily Temperatures (M)
Tree Depth First Search (DFS)
- Tree Diameter (E)
- Maximum Depth of Binary Tree (E)
- Path Sum III (M)
- Count Good Nodes in Binary Tree (M)
- Lowest Common Ancestor of a BST (M)
- Validate Binary Search Tree (M)
Tree Breadth First Search (BFS)
- All Nodes Distance K in Binary Tree (M)
- Even Odd Tree (M)
- Right View of a Binary Tree (M)
- Find Largest Value in Each Tree Row (M)
Binary Tree & BST
- Cousins in Binary Tree (E)
- Pseudo-Palindromic Paths in a Binary Tree (M)
- Amount of Time for Binary Tree to Be Infected (M)
- Maximum Difference Between Node and Ancestor (M)
- Kth Smallest Element in a BST (M)
- Path with Maximum Sum (H)
Graph
- Find the Town Judge (E)
- Course Schedule (M)
- Clone Graph (M)
Graph BFS / DFS
- Walls and Gates (M)
- Rotting Oranges (M)
- Shortest Path in a Grid with Obstacles Elimination (H)
- Word Ladder (H)
Heap / Priority Queue
- Sort Characters By Frequency (M)
- K-th Smallest Prime Fraction (M)
- Smallest Range Covering Elements from K Lists (H)
- Median of Two Sorted Arrays (H)
Backtracking
- Permutations II (M)
- Letter Combinations of a Phone Number (M)
- Balanced Parentheses (H)
- Palindromic Partitioning (H)
Dynamic Programming
- N-th Tribonacci Number (E)
- Partition Array for Maximum Sum (M)
- Number of Dice Rolls With Target Sum (M)
Intervals
- Merge Intervals (M)
- Insert Interval (M)
Divide & Conquer
- Majority Element (E)
- Longest Substring with At Least K Repeating Characters (M)
Trie
- Implement Trie (Prefix Tree) (M)
- Design Add and Search Words Data Structure (M)
- Search Suggestions System (M)
That's 75 problems across 18 topics: roughly 15% easy to build momentum, 70% medium because that's where real interviews live, and 15% hard to stretch you at the end of each topic.
Want each of these taught, not just listed? Grokking 75: Top Coding Interview Questions walks through every problem on this list with pattern introductions, step-by-step solutions, and code in Python, Java, JavaScript, C++, C#, and Go.
How to work the list: the 6-week plan
Doing these problems is not the goal. Learning the pattern behind each section is the goal, and that changes how you should schedule them.
| Week | Sections | Problems |
|---|---|---|
| 1 | Array/String, Two Pointers | 1-11 |
| 2 | Sliding Window, Matrix, Hash Map/Set | 12-26 |
| 3 | Linked List, Stack, Tree DFS | 27-40 |
| 4 | Tree BFS, Binary Tree & BST | 41-50 |
| 5 | Graph, Graph BFS/DFS, Heap | 51-61 |
| 6 | Backtracking, DP, Intervals, Divide & Conquer, Trie | 62-75 |
That's 11 to 15 problems a week, roughly 2 per day with one rest day, or 1 per day on the 12-week relaxed track. Three rules make the plan actually work:
Finish a section before moving on. The sections are pattern blocks. Solving them consecutively is what installs the pattern template in your memory. Skipping around destroys exactly the effect the ordering was designed to create.
Write down each pattern's tell. After finishing a section, write one sentence: "I should suspect this pattern when the problem says ___." If you can't write that sentence, redo two problems from the section. This recognition step is the missing skill that makes LeetCode feel impossible, and we covered it in depth in Why Is LeetCode So Hard?
Recycle your failures. Keep a list of every problem you couldn't solve in 30 minutes. Re-solve each one from scratch a week later. Your failure list, not the main list, is where most of your improvement lives.
If your interview is sooner than six weeks, compress rather than skip: do weeks 1-2 material in week 1, prioritize Sliding Window, Two Pointers, Tree DFS/BFS, Graph, and Intervals, and drop the hards entirely. A hard problem you half-understand is worth less than a medium you own.
Grokking 75 vs Blind 75 vs NeetCode 150
| Blind 75 | NeetCode 150 | LeetCode 75 | Grokking 75 | |
|---|---|---|---|---|
| Problems | 75 | 150 | 75 | 75 |
| Organized by pattern | Partially | Yes | By data structure (22 categories) | Yes |
| Sequenced for learning | No | Partially | By category | Yes |
| Reflects recent interviews | No (2018 era) | Mostly | Not stated | Yes (past year) |
| Monotonic stack, matrix, trie coverage | Thin | Good | Good | Good |
| Solutions included | Community links | Video walkthroughs | LeetCode editorials and community posts | Full lessons, 6 languages |
| Time to complete | 5-8 weeks | 10-15 weeks | 4-6 weeks | 5-6 weeks |
Honest guidance: all three lists are far better than random grinding, and if you've already started NeetCode 150 and have 3+ months, finishing it is a fine plan. Choose Grokking 75 when your timeline is measured in weeks, when you want the patterns taught rather than assembled from videos and forum posts, or when you've done an older list before and want problems that match what companies are asking now.
LeetCode 75 grouped by pattern
LeetCode 75 is a different list from Grokking 75. It is LeetCode's own free study plan, published at leetcode.com/studyplan/leetcode-75. It files its 75 problems under 22 categories, such as "Array / String", "Queue", and "Heap / Priority Queue". Those categories name the data structure in the problem. A pattern names the technique that solves the problem, and the two are often different.
Six of the 22 categories mix more than one technique. The "Array / String" category needs five different approaches: two pointers, prefix sum, greedy choices, a single pass, and one math problem. The "Heap / Priority Queue" category needs three patterns, which are Top K Elements, Ordered Set, and Two Heaps. Number of Provinces sits under "Graphs - DFS", although Union Find solves it more directly.
This difference changes how the list should be studied. A candidate who works by category learns each problem as a separate case. A candidate who works by pattern adds each problem to a technique that also solves unseen questions.
The table regroups all 75 problems by the pattern that solves them, with the largest groups first. The numbers are LeetCode problem numbers, and the letter is LeetCode's difficulty rating. The third column shows where LeetCode files the same problems.
| Pattern | LeetCode 75 problems | Where LeetCode files them | The tell |
|---|---|---|---|
| Tree DFS (8) | 104 Maximum Depth of Binary Tree (E), 872 Leaf-Similar Trees (E), 1448 Count Good Nodes in Binary Tree (M), 437 Path Sum III (M), 1372 Longest ZigZag Path in a Binary Tree (M), 236 Lowest Common Ancestor of a Binary Tree (M), 700 Search in a Binary Search Tree (E), 450 Delete Node in a BST (M) | Binary Tree - DFS, Binary Search Tree | a tree, and a question about a path, a depth, an ancestor, or whether two trees match |
| Two Pointers (8) | 1768 Merge Strings Alternately (E), 345 Reverse Vowels of a String (E), 151 Reverse Words in a String (M), 443 String Compression (M), 283 Move Zeroes (E), 392 Is Subsequence (E), 11 Container With Most Water (M), 1679 Max Number of K-Sum Pairs (M) | Array / String, Two Pointers | two indexes that move through one or two sequences, often from both ends, with O(1) extra space |
| Fibonacci-style DP (6) | 1137 N-th Tribonacci Number (E), 746 Min Cost Climbing Stairs (E), 198 House Robber (M), 790 Domino and Tromino Tiling (M), 62 Unique Paths (M), 714 Best Time to Buy and Sell Stock with Transaction Fee (M) | DP - 1D, DP - Multidimensional | the answer for position n depends on the answers for n-1 and n-2 |
| Sliding Window (5) | 643 Maximum Average Subarray I (E), 1456 Maximum Number of Vowels in a Substring of Given Length (M), 1004 Max Consecutive Ones III (M), 1493 Longest Subarray of 1's After Deleting One Element (M), 933 Number of Recent Calls (E) | Sliding Window, Queue | a contiguous run of an array or string, and "longest", "shortest", or "at most k" |
| Hash Maps (4) | 2215 Find the Difference of Two Arrays (E), 1207 Unique Number of Occurrences (E), 1657 Determine if Two Strings Are Close (M), 2352 Equal Row and Column Pairs (M) | Hash Map / Set | counting, grouping, or checking membership; "have I seen this before" |
| Modified Binary Search (4) | 374 Guess Number Higher or Lower (E), 2300 Successful Pairs of Spells and Potions (M), 162 Find Peak Element (M), 875 Koko Eating Bananas (M) | Binary Search | sorted or rotated input and an O(log n) requirement |
| Bitwise XOR (3) | 338 Counting Bits (E), 136 Single Number (E), 1318 Minimum Flips to Make a OR b Equal to c (M) | Bit Manipulation | bits, parity, or "without using the + operator" |
| Graphs (3) | 841 Keys and Rooms (M), 1466 Reorder Routes to Make All Paths Lead to the City Zero (M), 399 Evaluate Division (M) | Graphs - DFS | nodes and edges, and a copy, a reachability, or a traversal |
| Prefix Sum (3) | 238 Product of Array Except Self (M), 1732 Find the Highest Altitude (E), 724 Find Pivot Index (E) | Array / String, Prefix Sum | range totals or products, asked many times |
| Stacks (3) | 2390 Removing Stars From a String (M), 735 Asteroid Collision (M), 394 Decode String (M) | Stack | matching brackets, or the most recent unresolved item |
| Backtracking (2) | 17 Letter Combinations of a Phone Number (M), 216 Combination Sum III (M) | Backtracking | all combinations or all paths, with dead ends to abandon |
| Fast & Slow Pointers (2) | 2095 Delete the Middle Node of a Linked List (M), 2130 Maximum Twin Sum of a Linked List (M) | Linked List | a linked list and a cycle, a middle, or a loop start |
| Greedy (2) | 605 Can Place Flowers (E), 334 Increasing Triplet Subsequence (M) | Array / String | a local best choice at each step gives the global best |
| In-place Reversal (2) | 328 Odd Even Linked List (M), 206 Reverse Linked List (E) | Linked List | a linked list that must be reversed or rearranged with O(1) extra space |
| Longest Common Subsequence family (2) | 1143 Longest Common Subsequence (M), 72 Edit Distance (M) | DP - Multidimensional | two sequences compared, or one sequence and a "longest increasing" ask |
| Matrix Traversal (2) | 1926 Nearest Exit from Entrance in Maze (M), 994 Rotting Oranges (M) | Graphs - BFS | a grid, and a question about regions, spreading, or reaching an edge |
| Merge Intervals (2) | 435 Non-overlapping Intervals (M), 452 Minimum Number of Arrows to Burst Balloons (M) | Intervals | start and end pairs, and a question about overlap, gaps, or how many at once |
| Monotonic Stack (2) | 739 Daily Temperatures (M), 901 Online Stock Span (M) | Monotonic Stack | the next greater or smaller element, or how far back a value reaches |
| Top K Elements (2) | 215 Kth Largest Element in an Array (M), 2542 Maximum Subsequence Score (M) | Heap / Priority Queue | "k largest", "k most frequent", "k closest" |
| Tree Level Order Traversal (2) | 199 Binary Tree Right Side View (M), 1161 Maximum Level Sum of a Binary Tree (M) | Binary Tree - BFS | a tree, and an answer per level |
| Trie (2) | 208 Implement Trie (Prefix Tree) (M), 1268 Search Suggestions System (M) | Trie | many words, and prefix or wildcard search over them |
| Math, no named pattern (1) | 1071 Greatest Common Divisor of Strings (E) | Array / String | a divisor, a remainder, or a formula that replaces the search |
| One-pass Scan, no named pattern (1) | 1431 Kids With the Greatest Number of Candies (E) | Array / String | one pass that tracks a running maximum, minimum, or count |
| Ordered Set (1) | 2336 Smallest Number in Infinite Set (M) | Heap / Priority Queue | a pool of values that changes, with repeated requests for the smallest or largest |
| Simulation (1) | 649 Dota2 Senate (M) | Queue | rules applied turn by turn until one final state remains |
| Two Heaps (1) | 2462 Total Cost to Hire K Workers (M) | Heap / Priority Queue | two pools compared at every step, such as the two halves of a stream or the two ends of an array |
| Union Find (1) | 547 Number of Provinces (M) | Graphs - DFS | edges arriving as pairs, and a question about connected groups or cycles |
Three results stand out in the regrouped list. The five largest patterns cover 31 of the 75 problems: Tree DFS (8), Two Pointers (8), Fibonacci-style DP (6), Sliding Window (5), and Hash Maps (4). Modified Binary Search also has 4. These patterns deserve most of the study time. Seventeen problems appear on both LeetCode 75 and Grokking 75, mostly in the sliding window, tree, and trie sections. Finally, several patterns that interviews ask regularly do not appear in LeetCode 75 at all: Topological Sort, K-way Merge, Cyclic Sort, 0/1 Knapsack, and Palindromic Subsequence.
If LeetCode 75 is your main list, work through it pattern by pattern using the table. Then add two problems for each missing pattern before an interview at a large company. The same regrouping for the older community list is in Blind 75 Grouped by Pattern. The tell for every pattern is in the DSA patterns cheat sheet.
The takeaway
The candidates I hired at Meta and Microsoft were never the ones who had seen the most problems. They were the ones who could take a problem they'd never seen and calmly map it to one they had. That skill is built by studying a small, well-ordered, pattern-complete set of problems deeply, and 75 is genuinely enough.
Start today: Grokking 75: Top Coding Interview Questions covers this exact list with pattern lessons and multi-language solutions. Prefer the full patterns curriculum? Grokking the Coding Interview teaches all 42 patterns (32 common + 10 advanced) with hundreds of problems, rated 4.6/5 by 62,000+ learners.
FAQs
Is 75 LeetCode problems really enough for FAANG interviews? Yes, if the 75 systematically cover the common patterns and you study them for recognition rather than memorization. Coverage beats count: 75 problems spanning 18 topics prepare you for more unseen problems than 300 random ones.
What's the difference between Grokking 75 and Blind 75? Blind 75 is a community list from 2018: great problems, no teaching order, and thin coverage of patterns that became common since (monotonic stack, matrix traversal, tries). Grokking 75 is organized by pattern, sequenced for learning, and refreshed against questions asked in the past year.
Is Grokking 75 the same as LeetCode 75? No. LeetCode 75 is LeetCode's own free study plan, grouped into 22 data-structure categories. Grokking 75 is a separate list ordered by coding pattern and taught with full lessons. The two lists share 17 problems. LeetCode 75 is regrouped by pattern above.
Is LeetCode 75 enough for FAANG interviews? It is a reasonable base, but it leaves out several patterns that large companies ask, including Topological Sort, K-way Merge, Cyclic Sort, and 0/1 Knapsack. Add two problems for each missing pattern, then practice timed mixed sets so that you choose the pattern without the category label to guide you.
Should I do Grokking 75 or the full Grokking the Coding Interview course? Timeline decides. With 4 to 6 weeks, Grokking 75 is the focused path. With 2 to 3 months, the full course teaches all 42 patterns (32 common + 10 advanced) with more variations per pattern, which transfers better to harder loops like Google's.
How many hours a day does the 6-week plan take? About 1.5 to 2 hours a day: roughly two problems, plus the write-the-tell and failure-review habits. On 1 hour a day, plan for 10 to 12 weeks.
Do I need LeetCode Premium for this list? No. Nearly every problem is free on LeetCode, and the Grokking 75 course includes full problem statements and an in-browser coding environment, so you can prepare without Premium.
