Spaced Repetition for LeetCode

You’ve solved 200 problems. How many could you re-solve from scratch right now? Be honest.

Without a system, most of what you practice fades within days. The only question is whether you notice before or during your interview.

Spaced repetition is the system that fixes this. Here’s exactly how to use it for LeetCode.

---

Why spaced repetition works for LeetCode

Spaced repetition is a study method where you review material at increasing intervals. Instead of solving a problem once and moving on, you re-solve it on a schedule: tomorrow, then in 3 days, then a week, then a month. Each successful review strengthens the memory and pushes the next review further out. Each failure pulls it back in.

Most people’s workflow fights against this: solve a problem, check the box, never touch it again, wonder why they can’t recognize patterns in interviews. Spaced repetition breaks that cycle by fighting the forgetting curve — the exponential decay of memories over time:

Without review, you lose most of what you learned within days. With reviews timed to catch the decay, each repetition makes the memory more durable and the intervals longer.

Instead of solving 500 problems shallowly, you solve 75–150 — think Blind 75 or NeetCode 150 — and actually retain them all.

---

How to use spaced repetition for LeetCode prep

1. Study by pattern, not by difficulty

Stop sorting by Easy → Medium → Hard. That order feels structured, but from a learning perspective it’s random — you’re jumping between sliding window, graph traversal, and dynamic programming with no connective tissue.

Instead:

1. Pick one pattern (e.g., sliding window, two pointers, BFS/DFS)
2. Solve 3–5 problems that use it, back to back
3. Move to the next pattern once you’ve seeded the first

The problems reinforce each other because you’re seeing the same underlying structure from different angles.

2. Rate yourself after every solve

After you solve a problem (or fail to), give yourself an honest rating. This is the signal the scheduling algorithm uses to decide when you see the problem next.

The temptation is to rate everything “Good.” Resist it. If you peeked at a hint, that’s “Again.” If it was trivial, that’s “Easy.” Honest ratings mean the algorithm spends your time where it actually matters.

3. Review on schedule

Here’s what a typical review schedule looks like for a single problem:

Review #	When	What’s happening
1	Day 1	Re-solve from scratch. Memory is fresh.
2	Day 3–4	Starting to fade — this review is critical.
3	Day 7–10	Getting easier. Interval grows.
4	Day 20–30	Barely have to think. Almost locked in.
5+	Day 60+	Permanent. Quick confirmation review.

The intervals aren’t fixed — they adapt based on your ratings. Rate “Again” and you’ll see the problem tomorrow. Rate “Easy” three times and it might not come back for months.

As you add more problems, your daily review queue becomes a mix of patterns at different stages. This interleaving is where the deepest learning happens — you stop just executing a pattern you’ve been drilling and start identifying which pattern to apply. That’s the skill interviews actually test.

4. Re-solve, don’t re-read

This is where most people sabotage the whole system. When a problem comes up for review, they open their old solution and read through it. “Yeah, that makes sense.” Close the tab. Forget it by Friday.

Reading and problem-solving use completely different cognitive pathways. Reading your old code gives you a feeling of understanding without actually testing whether you can reproduce it.

The rule: blank editor, no notes, no peeking. If you can’t solve it within 10–15 minutes, that’s useful data — the interval was too long. Rate it “Again” and you’ll see it sooner.

When you rate “Again”: study the solution, but don’t just skim it. Trace through the logic and understand why each step works. Then close it and re-attempt from scratch before ending your session. This same-day retry is how you convert a blank stare into a working memory.

Mistakes that kill the system

Adding too many new problems. Your review queue grows with every problem you add. If you’re adding 5 new problems a day, your reviews will overwhelm you within two weeks. Start with 1–2 new problems per day and let reviews take priority.

Skipping reviews when you’re busy. One skipped day compounds. The problems you should have reviewed start decaying, and suddenly you’ve got a backlog where you’ve forgotten the approach. If you’re short on time, do reviews and skip new problems — not the other way around.

Rating dishonestly. If you peeked at a hint or your old solution, that’s “Again,” not “Good.” Inflating your rating pushes the interval too far, and you forget it before the next review. Garbage in, garbage out.

Reviewing by reading. Already covered this, but it’s worth repeating because it’s the most common mistake. Recognition feels like recall. It isn’t. Solve from a blank editor every time.

---

What a typical day looks like

After a week or two, your daily practice has a rhythm:

Reviews first (20–40 minutes), then 1–2 new problems. The reviews are fast because you’ve seen these before. Most of your effort goes into new problems and the ones you rated “Again.”

---

Best spaced repetition tools for LeetCode

The best review system is whichever one you’ll actually use consistently. Here are your options:

The reason most review systems die is friction. Every step between “I want to review” and “I’m solving a problem” is a step where you might quit.

---

What to expect

Week 1–2: It feels slow. You’re reviewing “easy” problems instead of grinding new ones. This is normal and correct.

Week 3–4: Your review queue starts mixing patterns. You solve a sliding window problem, then a graph problem, then a DP problem. You notice you’re identifying patterns faster in new problems.

Month 2+: Problems you used to struggle with take five minutes. Your daily reviews are mostly quick confirmations with a few tough ones mixed in. New problems feel easier because you have a deep library of patterns to draw from.

The math: 75–150 problems reviewed to the point of automatic recognition will outperform 500 problems solved once and forgotten.