Blind 75: What the List Is and How to Finish It in Six Weeks

The Blind 75 is a seventy-five-problem list that has become the default answer to "what should I actually solve before an interview". It is named after Blind, the anonymous workplace forum where it was first posted, and its appeal is entirely about scope: it is small enough to finish, and wide enough that finishing it means you have met every technique a standard coding screen is likely to use.

It is a third-party list, not ours. What follows is an honest read of what it covers, what it does not, and a six-week schedule for getting through it — including the part most guides skip, which is what to do with a problem you cannot solve.

What the list actually is#

Seventy-five problems, grouped into ten topics: arrays, binary, dynamic programming, graphs, intervals, linked lists, matrices, strings, trees and heaps. Nothing about the selection is algorithmic; a person chose the problems, and the value is precisely that a person chose them.

The grouping is worth understanding, because it is not evenly weighted:

Trees and dynamic programming together are a third of the list, which is a fair reflection of where most people lose interviews.

You can see the full set, with a Python solution and complexity analysis on every problem, on the Blind 75 list page.

Why seventy-five is enough — and what it leaves out#

The case for a short list is that returns fall off fast. The first problem in a pattern teaches you the pattern. The second teaches you the variant. The fifth teaches you almost nothing you did not already have, and the fortieth teaches you nothing at all while feeling productive, which is the dangerous part.

Seventy-five problems, chosen for coverage rather than volume, gets you at least one honest encounter with every major technique. That is the right target before an interview, because interviews test whether you can name the technique from the constraints — not whether you have seen this exact problem.

The honest caveats, which you can verify by reading the list itself:

There is no monotonic stack problem. Not one. No Daily Temperatures, no Largest Rectangle in Histogram, no Trapping Rain Water. Next-greater-element questions are common enough that this is a real gap — see the monotonic stack pattern and add Daily Temperatures and Trapping Rain Water.

There is no binary search on the answer. The list has array binary search, in rotated form, but nothing where you bisect a range of possible answers and test feasibility. That shape — "minimum capacity such that…", "minimum speed such that…" — is now extremely common. Add Koko Eating Bananas.

There are no subsets, permutations or combinations. Backtracking appears only as grid search in Word Search. If an interviewer asks you to enumerate arrangements you will be improvising. Add Subsets and Permutations.

It contains no system design, no behavioural preparation and no language-specific work. It is an algorithms list. A full loop is not.

Four extra problems and an awareness of the gaps turns the list from good into genuinely sufficient.

How to work through the Blind 75 in six weeks#

Twelve or thirteen problems a week, grouped so that each week builds on the last. The order below is deliberately not the list's own order — it front-loads the patterns that appear inside later problems.

Week 1 — Arrays and hashing#

The foundation. Almost every later problem contains a hash map or a two-pointer scan somewhere inside it, so this week is about making both automatic rather than about the problems themselves.

By the end you should be able to say, without thinking, why a complement lookup works in one pass (a pair is always found from its second member, so only the past needs remembering) and why sorting buys you a converging scan.

Anchors: Two Sum · Group Anagrams · Product of Array Except Self · 3Sum · Maximum Subarray

Week 2 — Strings, windows and binary search#

The sliding window is the highest-leverage pattern on the list, and Minimum Window Substring is the hardest thing you will meet this early. Do the easy windows first, in order, and do not skip the template — every variable-size window is the same six lines with a different legality check.

Binary search belongs here because the rotated-array problems are really about writing a predicate that is monotone, which is the same mental move as a window's legality condition.

Anchors: Longest Substring Without Repeating Characters · Longest Repeating Character Replacement · Minimum Window Substring · Find Minimum in Rotated Sorted Array · Search in Rotated Sorted Array

Week 3 — Linked lists, intervals and matrices#

A light week by design, sitting between two hard ones. Linked list problems are pointer discipline, not algorithms: allocate a dummy head whenever the head can change, and save next before you overwrite it. Interval problems are one insight repeated — sort by start to merge, sort by end to schedule greedily.

Anchors: Reverse Linked List · Merge k Sorted Lists · Merge Intervals · Non-overlapping Intervals · Rotate Image

Week 4 — Trees#

The biggest group and the one that repays the most attention. Almost every tree problem is a traversal with a small amount of work attached, so the decision is always when the node is processed relative to its children: postorder when the answer depends on the subtrees, inorder when the tree is a BST and the question is about sorted order.

Serialize and Deserialize and Maximum Path Sum are the two that separate people. Both are postorder with careful bookkeeping.

Anchors: Maximum Depth of Binary Tree · Validate Binary Search Tree · Binary Tree Level Order Traversal · Binary Tree Maximum Path Sum · Serialize and Deserialize Binary Tree

Week 5 — Tries, heaps and graphs#

Graphs feel hard until you notice that most of them are one of three things: flood fill over a grid, a component count, or a cycle check. Write the neighbour loop as a list of offsets once and reuse it. The two heap problems are the standard pair — top-k with a capped heap, and a running median with two heaps facing each other.

Anchors: Implement Trie (Prefix Tree) · Top K Frequent Elements · Number of Islands · Course Schedule · Clone Graph

Week 6 — Dynamic programming and bit manipulation#

The heaviest week on purpose. Sixteen problems, and eleven of them are dynamic programming, because this is where the marginal problem still teaches you something.

Do them in this order: Climbing Stairs, House Robber, Coin Change, Longest Increasing Subsequence, Word Break, Longest Common Subsequence, Unique Paths. That sequence walks from a one-dimensional table with a two-term transition up to a two-dimensional grid, and each step changes exactly one thing. Write every one as memoised recursion first — the recursive form reads like the problem statement — and convert to a table only after it works.

Anchors: Climbing Stairs · House Robber · Coin Change · Longest Increasing Subsequence · Longest Common Subsequence

How to work one problem#

The schedule is the easy part. This is the part that decides whether six weeks produces anything.

Set a timer for twenty-five minutes. Real effort, no editorial, no hints. If you solve it, write down which pattern it was and why the constraints implied it — one line, in your own words.

If the timer runs out, read the solution once, then close it. Then implement from an empty file. Reading a solution produces recognition, which feels exactly like understanding and disappears within a day. Typing it from nothing is the only thing that produces recall.

Re-solve it three days later. Not the same day. If you cannot reproduce it three days later, you did not learn it, and that is useful information rather than a verdict — it tells you which pattern to spend the next session on.

Say the complexity out loud, every time. Time and space, with a reason. Interviewers ask, and candidates who have practised saying it answer in five seconds instead of thirty.

Two hours a day is not required. Ninety minutes on most days, held for six weeks, beats a heroic weekend followed by two idle ones — spacing is what moves a pattern from "I have seen this" to "I know this".

What to do after#

If you finish and still have time, the NeetCode 150 is the natural next step: it is the same core widened to three or four problems per pattern, which is the repetition that makes recognition automatic. If you would rather go by technique than by list, work through the pattern hubs and take three problems from each one you feel slow on.

And if the interview is next week rather than in six, do Week 1, Week 2 and the first half of Week 6. Hashing, windows, binary search and basic dynamic programming cover more of a typical screen than any other four things you could pick.

One last thing worth being honest about: solving problems alone in a quiet room is a different skill from solving them while someone watches and the clock runs. If you want support during the interview itself, Stealth Interview is a desktop app for macOS and Windows that reads the problem from a screenshot, works through it step by step with time and space complexity, and stays invisible to screen sharing.