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.
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 a 2026 loop.
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 | Grokking 75 | |
|---|---|---|---|
| Problems | 75 | 150 | 75 |
| Organized by pattern | Partially | Yes | Yes |
| Sequenced for learning | No | Partially | Yes |
| Reflects recent interviews | No (2018 era) | Mostly | Yes (past year) |
| Monotonic stack, matrix, trie coverage | Thin | Good | Good |
| Solutions included | Community links | Video walkthroughs | Full lessons, 6 languages |
| Time to complete | 5-8 weeks | 10-15 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.
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 27 patterns 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.
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 27 patterns 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.