Blind 75 vs NeetCode 150 vs LeetCode 75: Which List Should You Do?

What is the Blind 75, and where did the other lists come from?

The Blind 75 began as one engineer's shortlist. Yangshun, a former Meta staff engineer and the author of the Tech Interview Handbook, writes that he picked the 75 LeetCode questions he considered most important for his own job hunt, shared them on the anonymous forum Blind after extracting them from an article he had written for freeCodeCamp, and that someone reposted the list on LeetCode's forum, where the community gave it its name. Years later he cut it down to a 50-question, five-week schedule and built Grind 75, a configurable successor, on the same site.

NeetCode's lists build directly on it. The NeetCode practice page describes the NeetCode 150 as the Blind 75 plus 75 more problems, meant for people who already know basic data structures and algorithms, and the NeetCode 250 as the NeetCode 150 plus 100 more, which it presents as its most beginner-friendly list. LeetCode publishes its own study plans: LeetCode 75, which its summary recommends for one to three months of preparation, and Top Interview 150, recommended for three months or more.

The sizes and difficulty splits below were read from each publisher's page on November 14, 2026. Lists get revised, so open the linked pages before you plan around a number.

• Tech Interview Handbook: Best practice questions, by the author of Blind 75
• NeetCode: NeetCode 150
• LeetCode study plan: LeetCode 75

Topic distribution: Blind 75 vs NeetCode 150 vs NeetCode 250

NeetCode files all three of its lists under the same 18 categories, which makes them directly comparable. In its copy of the Blind 75, trees (11 problems) and one-dimensional dynamic programming (10) are the largest groups and together make up 28 percent of the list, while stacks, heaps and advanced graphs get a single problem each.

The 75 problems that the NeetCode 150 adds are not spread evenly. The biggest additions are two-dimensional dynamic programming (2 to 11), backtracking (2 to 10), graphs (6 to 13), heaps (1 to 7) and greedy (2 to 8), plus five more each in binary search, linked lists, stacks, advanced graphs and math. That is the practical difference: the Blind 75 shows you each major pattern a few times, and the NeetCode 150 gives the patterns that need repetition, such as backtracking and grid DP, enough problems to become routine. The NeetCode 250 then more than doubles the Easy count, from 28 to 60, which is why it suits a first pass.

• NeetCode: Blind 75
• NeetCode: NeetCode 150
• NeetCode: NeetCode 250

LeetCode 75 and Blind 75 vs Grind 75: three different ideas of 75

LeetCode 75 is not a subset of the Blind 75. It is LeetCode's own plan, split into 22 small topic groups, and on November 14, 2026 it held 22 Easy and 53 Medium problems and no Hard ones. It has groups that the NeetCode categories do not single out, such as prefix sum, queue and monotonic stack, and it opens with nine array and string problems. That makes it the gentlest of the 75-problem lists and a sensible first list for someone who has finished a data structures course but has not practiced interview problems yet.

Grind 75 keeps the number but changes the method. By default it schedules 75 questions over 8 weeks at 8 hours a week and estimates 64 hours of work; sliders go up to 26 weeks and 40 hours a week, and filters select difficulty and topics. Its FAQ says the questions were drawn from the Blind 75 and other pattern collections, and the tool's “View All Questions” mode showed 169 of them on November 14, 2026; they are ordered so that easy questions come first and LeetCode Premium questions come as late as possible. Each question carries a recommended time, 15 to 45 minutes in the default list, and each week deliberately mixes topics instead of finishing one topic before starting the next. The default selection leans on arrays (11), graphs (10), binary trees (9), strings (8) and stacks (7), with only 5 dynamic programming questions.

• LeetCode study plan: LeetCode 75
• LeetCode study plan: Top Interview 150
• Grind 75 (Tech Interview Handbook)
• Grind 75: Frequently asked questions

Blind 75 or NeetCode 150: which list for your time budget and level

Two questions decide it: how many weeks you have, and whether you can already write a hash map lookup, a binary search and a tree traversal without looking anything up. If you cannot, a longer and easier list is faster in practice, because every Blind 75 problem will otherwise turn into a tutorial. If you can, the shorter list leaves time for the part that matters more than coverage: re-solving.

None of the list pages cites outcome data, so no list can honestly be called the one that gets offers. Treat the table as a starting point and switch lists if the first ten problems are far too easy or far too hard.

• A 7-day technical interview crash plan
• A 30-day software engineer interview study plan

How long each list takes at 5, 10 and 15 problems a week

List size only means something next to a weekly pace. The script below divides each list by three paces and rounds up; its real output is in the comment. At 10 new problems a week, a 75-problem list takes 8 weeks and a 150-problem list takes 15; the NeetCode 250 takes 25 weeks, about half a year.

To turn problems into hours, use the one published estimate: Grind 75 budgets 64 hours for 75 questions, which it calls a conservative figure that includes roughly as much time for checking the answer as for solving. That is about 51 minutes per question, so 10 new problems a week is an 8 to 9 hour week before any re-solving, and finishing the NeetCode 150 in ten weeks means 15 problems and roughly 13 hours a week. Treat those hours as a floor for the longer lists: the estimate comes from Grind 75's default selection, where 24 of 75 questions are Easy, while two thirds of the NeetCode 150 is Medium. By the same estimate, a 75-problem list in three to five weeks is 13 to 21 hours a week. If you have 5 hours a week, plan on 5 or 6 new problems, and the Blind 75 becomes a three-month project rather than a three-week one.

import math

LISTS = {
    "LeetCode 75": 75, "Blind 75": 75, "Grind 75": 75,
    "NeetCode 150": 150, "Top Interview 150": 150, "NeetCode 250": 250,
}

print(f"{'new problems per week':<22}{5:>4}{10:>4}{15:>4}")
for name, size in LISTS.items():
    weeks = [math.ceil(size / pace) for pace in (5, 10, 15)]
    print(f"{name:<22}{weeks[0]:>4}{weeks[1]:>4}{weeks[2]:>4}")

# Output (weeks needed):
# new problems per week    5  10  15
# LeetCode 75             15   8   5
# Blind 75                15   8   5
# Grind 75                15   8   5
# NeetCode 150            30  15  10
# Top Interview 150       30  15  10
# NeetCode 250            50  25  17

• Grind 75 (Tech Interview Handbook)

How to work a list so it sticks

A finished list is not the goal; being able to solve an unseen problem of the same pattern is. The Grind 75 FAQ makes the same point when it explains why the tool hides company tags: the aim is to get better at common patterns, not to collect questions you hope to be asked. The routine below treats each problem as a source of one reusable idea and schedules a second and third attempt.

Disclosure: this library is published by RecallDeck, a spaced-repetition flashcard app. Cards are a reasonable place to keep the three-line note from the routine and have it resurface on a schedule, but they do not replace writing the code again; nothing here requires any particular tool.

• Time-box every attempt. Grind 75 assigns each question 15 to 45 minutes; when the time is up, read a solution, close it, and write the code yourself.
• After each problem, write three lines: the trigger in the statement that points to the pattern, the invariant the solution maintains, and the time and space complexity.
• Re-solve from a blank editor a few days later and again a few weeks later. Mark a problem done only when a re-solve works without hints.
• Mix topics within a week. The Grind 75 FAQ recommends its default order for exactly this reason: you revisit each topic in later weeks instead of finishing it once.
• Say the approach aloud before typing, as you will have to in an interview.
• Calibrate after 20 to 30 questions. The Grind 75 FAQ says that if you still need longer than the recommended times at that point, you should go back to fundamentals and easier questions.

• The best LeetCode alternatives, and when to use each one
• How to use spaced repetition for technical interviews
• Sliding window algorithm patterns in Python
• Dynamic programming interview questions: a method

Common mistakes with curated lists

Most wasted effort comes from treating the list as a checklist. The same handful of mistakes appears whichever list you choose, and each has a cheap fix.

• Counting solved problems instead of re-solved ones. A problem you could not repeat a week later was read, not learned.
• Doing one category to the end before touching the next, then meeting mixed problems for the first time in the interview.
• Starting the NeetCode 150 three weeks before an interview and finishing 60 problems with no time to review any of them.
• Reading the solution after five minutes. Use the full time box first; the struggle is where the pattern is learned.
• Skipping Easy problems as beneath you. Grind 75 puts them first because they teach the core patterns that harder problems combine.
• Stacking lists. The NeetCode 150 contains the Blind 75 and Grind 75 draws on it, so a second list adds fewer new problems than its size suggests.

• Is LeetCode Premium worth it?
• Two pointer technique: patterns and Python problems
• Binary search problems: boundaries and answer search

Quick answers

Frequently asked questions