NeetCode 150: The Definitive Coding Interview Study List
If you have searched for "what LeetCode problems should I solve for interviews," you have almost certainly come across the NeetCode 150. With over 50,000 monthly searches, it has become the de facto study roadmap for software engineers preparing for coding interviews at top tech companies.
The NeetCode 150 is a curated list of 150 LeetCode problems organized by pattern and difficulty. It was created by NeetCode, an ex-Google engineer who built one of the most popular coding interview YouTube channels. The list is an expansion of the original Blind 75 — adding 75 more problems to cover gaps and provide deeper practice in each pattern category.
In this guide, you will find every problem in the NeetCode 150 organized by category, the optimal order to study them, how it compares to the Blind 75 and Grind 75, and practical tips to use the list effectively. Whether you are starting from scratch or looking to fill in gaps, this is everything you need to know about the NeetCode 150.
What Is NeetCode 150?
NeetCode 150 is a hand-picked collection of 150 LeetCode problems that together cover all 17 major coding interview patterns. The list was designed by NeetCode (real name: a former Google software engineer) who noticed that most interview problems fall into a small number of recurring patterns.
The philosophy behind the NeetCode 150 is straightforward: instead of grinding 500+ random LeetCode problems, you solve 150 carefully selected ones that teach you every pattern you will encounter in a real interview. Each problem was chosen because it is either a classic example of a pattern or a commonly asked question at top companies.
The list is organized into 17 categories, starting with simpler patterns like Arrays and Hashing and progressing to harder ones like Dynamic Programming and Graphs. Within each category, problems are roughly ordered from easy to hard, giving you a natural learning progression.
NeetCode also provides free video explanations for every single problem on the list, making it one of the most well-supported study resources available. The combination of a curated problem set plus detailed walkthroughs is what sets the NeetCode 150 apart from other lists.
NeetCode 150 All Problems by Category
Here is the complete NeetCode 150 list broken down by all 17 categories. The problem counts reflect the current version of the list as maintained on neetcode.io.
- Arrays & Hashing (9 problems): Contains Duplicates, Valid Anagram, Two Sum, Group Anagrams, Top K Frequent Elements, Encode and Decode Strings, Product of Array Except Self, Valid Sudoku, Longest Consecutive Sequence
- Two Pointers (5 problems): Valid Palindrome, Two Sum II, 3Sum, Container With Most Water, Trapping Rain Water
- Sliding Window (6 problems): Best Time to Buy and Sell Stock, Longest Substring Without Repeating Characters, Longest Repeating Character Replacement, Permutation in String, Minimum Window Substring, Sliding Window Maximum
- Stack (7 problems): Valid Parentheses, Min Stack, Evaluate Reverse Polish Notation, Generate Parentheses, Daily Temperatures, Car Fleet, Largest Rectangle in Histogram
- Binary Search (7 problems): Binary Search, Search a 2D Matrix, Koko Eating Bananas, Find Minimum in Rotated Sorted Array, Search in Rotated Sorted Array, Time Based Key-Value Store, Median of Two Sorted Arrays
- Linked List (11 problems): Reverse Linked List, Merge Two Sorted Lists, Reorder List, Remove Nth Node From End, Copy List with Random Pointer, Add Two Numbers, Linked List Cycle, Find the Duplicate Number, LRU Cache, Merge K Sorted Lists, Reverse Nodes in K-Group
- Trees (15 problems): Invert Binary Tree, Maximum Depth of Binary Tree, Diameter of Binary Tree, Balanced Binary Tree, Same Tree, Subtree of Another Tree, Lowest Common Ancestor of BST, Binary Tree Level Order Traversal, Binary Tree Right Side View, Count Good Nodes, Validate BST, Kth Smallest Element in BST, Construct Binary Tree from Preorder and Inorder, Binary Tree Maximum Path Sum, Serialize and Deserialize Binary Tree
- Tries (3 problems): Implement Trie, Design Add and Search Words Data Structure, Word Search II
- Heap / Priority Queue (7 problems): Kth Largest Element in a Stream, Last Stone Weight, K Closest Points to Origin, Kth Largest Element in an Array, Task Scheduler, Design Twitter, Find Median from Data Stream
- Backtracking (9 problems): Subsets, Combination Sum, Permutations, Subsets II, Combination Sum II, Word Search, Palindrome Partitioning, Letter Combinations of a Phone Number, N-Queens
- Graphs (13 problems): Number of Islands, Max Area of Island, Clone Graph, Walls and Gates, Pacific Atlantic Water Flow, Course Schedule, Course Schedule II, Redundant Connection, Number of Connected Components, Graph Valid Tree, Word Ladder, Alien Dictionary, Cheapest Flights Within K Stops (Note: some problems are on LeetCode Premium)
- 1-D Dynamic Programming (12 problems): Climbing Stairs, Min Cost Climbing Stairs, House Robber, House Robber II, Longest Palindromic Substring, Palindromic Substrings, Decode Ways, Coin Change, Maximum Product Subarray, Word Break, Longest Increasing Subsequence, Partition Equal Subset Sum
- 2-D Dynamic Programming (11 problems): Unique Paths, Longest Common Subsequence, Best Time to Buy and Sell Stock with Cooldown, Coin Change II, Target Sum, Interleaving String, Longest Increasing Path in a Matrix, Distinct Subsequences, Edit Distance, Burst Balloons, Regular Expression Matching
- Greedy (8 problems): Maximum Subarray, Jump Game, Jump Game II, Gas Station, Hand of Straights, Merge Triplets to Form Target, Partition Labels, Valid Parenthesis String
- Intervals (6 problems): Insert Interval, Merge Intervals, Non-overlapping Intervals, Meeting Rooms, Meeting Rooms II, Minimum Interval to Include Each Query
- Math & Geometry (8 problems): Rotate Image, Spiral Matrix, Set Matrix Zeroes, Happy Number, Plus One, Pow(x,n), Multiply Strings, Detect Squares
- Bit Manipulation (7 problems): Single Number, Number of 1 Bits, Counting Bits, Reverse Bits, Missing Number, Sum of Two Integers, Reverse Integer
Why NeetCode 150?
NeetCode 150 covers all 17 major coding patterns with 150 carefully selected problems — it's the expansion of Blind 75 and has become the de facto interview study roadmap with 50K+ monthly searches.
NeetCode 150 Study Order: The Best Way to Work Through the List
One of the most common mistakes people make with the NeetCode 150 is solving problems in the order they appear on the website. While the categories are logically arranged, the optimal study order depends on building foundational patterns before tackling harder ones.
The recommended NeetCode 150 study order follows a progression from easier patterns that build intuition to harder patterns that require combining multiple techniques. Here is the order that works best for most candidates.
- 1Phase 1 — Foundation (weeks 1-2): Arrays & Hashing, Two Pointers, Sliding Window, Stack, Binary Search. These five categories contain 34 problems and teach you the most fundamental patterns. Arrays and Hashing problems build your comfort with hash maps and frequency counting. Two Pointers and Sliding Window teach you to manipulate indices efficiently. Stack and Binary Search round out the core toolkit.
- 2Phase 2 — Data Structures (weeks 3-4): Linked List, Trees. These 26 problems are critical because trees appear in roughly 35% of coding interviews. Start with Linked List to get comfortable with pointer manipulation, then move to Trees where you will learn recursive DFS, iterative BFS, and BST properties.
- 3Phase 3 — Advanced Patterns (weeks 5-7): Tries, Heap/Priority Queue, Graphs, Backtracking. These 32 problems introduce more complex data structures and search algorithms. Graphs are heavily tested at FAANG companies, so spend extra time on DFS/BFS traversals, topological sort, and union-find.
- 4Phase 4 — Optimization (weeks 7-9): 1-D Dynamic Programming, 2-D Dynamic Programming, Greedy. These 31 problems are the hardest for most candidates. Start with 1-D DP problems like Climbing Stairs and House Robber to build your DP intuition before moving to 2-D DP. Greedy problems often feel like DP but have simpler solutions.
- 5Phase 5 — Fill Gaps (weeks 9-10): Intervals, Math & Geometry, Bit Manipulation. These 21 problems cover niche patterns that appear less frequently but still show up in interviews. Intervals and Math are especially common at certain companies.
NeetCode 150 vs Blind 75 vs Grind 75
The NeetCode 150 did not appear in a vacuum. It is part of a family of curated LeetCode lists that all aim to help you prepare efficiently. Understanding how they differ helps you choose the right one for your timeline and goals.
The Blind 75 is the original curated list, posted anonymously on the Blind forum by a Facebook engineer. It contains 75 problems covering 14 categories and is designed to be the minimum viable set of problems for interview prep. If you have less than 4 weeks to prepare, the Blind 75 is your best bet.
The NeetCode 150 is a direct expansion of the Blind 75. It includes all 75 original problems plus 75 additional ones that fill in gaps — particularly in Trees, Graphs, and DP where the Blind 75 was thin. If you have 6-10 weeks, the NeetCode 150 gives you significantly better coverage.
Grind 75 is a newer tool created by a former Google engineer. It is not a fixed list but an adaptive generator that creates a custom study plan based on your available hours per week. It pulls from a pool of about 170 problems and prioritizes by importance and difficulty.
- Blind 75: 75 problems, 14 categories. Best for 2-4 week timelines. Minimum viable coverage. No video explanations included.
- NeetCode 150: 150 problems, 17 categories. Best for 6-10 week timelines. Most comprehensive fixed list. Free video explanations for every problem.
- Grind 75: ~170 problem pool, adaptive scheduling. Best for custom timelines. Generates a personalized plan based on hours per week. Web-based tool.
- If you are unsure which to pick: start with NeetCode 150. You can always skip problems you already know, and the category-based structure makes it easy to focus on your weak areas.
Study Order Tip
Don't solve NeetCode 150 in list order — start with Arrays & Hashing and Two Pointers (easiest patterns), then work through Trees and Graphs (most tested), and save DP and Backtracking for last (hardest).
How to Use NeetCode 150 Effectively
Having the NeetCode 150 list is one thing. Using it effectively is another. Most candidates who fail interviews have solved plenty of problems — they just cannot recall the patterns when it counts. Here are the strategies that separate successful candidates from those who grind without results.
First, do not solve problems in list order. Follow the phased study order described above. Each phase builds on the previous one, so you will have the right mental models in place before tackling harder patterns.
Second, track your progress by category, not by total count. Solving 50 problems across 17 categories is far more valuable than solving 50 Array problems. Your goal is pattern breadth first, depth second.
Third, use spaced repetition to review solved problems. Research shows that you forget 80% of what you learn within 2 weeks without review. After solving a problem, revisit it 1 day later, then 3 days later, then 1 week later. This is where most candidates fall short — they solve and forget.
Fourth, time yourself. Real interviews give you 20-30 minutes per problem. If you cannot solve a medium problem in 25 minutes, look at the solution, understand the pattern, and mark it for review. Spending 90 minutes on a single problem teaches you less than studying the pattern and solving three similar ones.
Fifth, skip problems you have already mastered. If you solved Two Sum six months ago and can still explain the approach from memory, move on. The NeetCode 150 is a guide, not a checklist you must complete linearly.
NeetCode 150 + YeetCode: The Complete Interview Prep Stack
The NeetCode 150 excels at giving you a structured problem list and video explanations. But it does not solve the retention problem — the gap between solving a problem and being able to recall the pattern weeks later in an interview.
This is where YeetCode fills the gap. YeetCode provides flashcards organized by the same coding patterns you encounter in the NeetCode 150: Arrays and Hashing, Two Pointers, Sliding Window, Trees, Graphs, Dynamic Programming, and more. Instead of re-solving entire problems to review, you can drill the core pattern logic in minutes.
The most effective workflow combines both tools. Use the NeetCode 150 as your primary problem-solving list — work through each category in the recommended study order. Then use YeetCode flashcards between solving sessions to reinforce the patterns you have learned. This combination of active problem-solving plus spaced repetition review is backed by learning science and is how top candidates prepare.
Whether you are targeting FAANG, startups, or mid-size tech companies, the NeetCode 150 roadmap paired with pattern-based flashcard review gives you the best chance of walking into your interview with every major pattern fresh in your mind.
The Retention Problem
Completing all 150 problems means nothing if you can't recall the patterns 2 weeks later — pair NeetCode 150 with spaced repetition review or you'll forget 80% of what you solved.