Re-solve every problem you card on day 1, day 3, day 7, day 21 and day 60, then retire it. A review means an empty file and writing the solution again from nothing, not scrolling your old submission and nodding at it. The front of the card is the problem name and nothing else. The back is three lines: the pattern, the one invariant that makes the solution correct, and the complexity. A pass is running code inside the time cap, with the invariant said out loud before you typed.
The ladder: 1, 3, 7, 21, 60
Five sittings, each with a shorter clock than the last. The clock matters as much as the date, because a solution you can only re-derive in twenty minutes is not stored, it is being rebuilt from scratch.
| Sitting | Days after last pass | Cap | What it tests |
|---|---|---|---|
| First solve | Day 0 | None | Nothing. This is acquisition. Write the card that evening, while you still remember which line beat you. |
| Review 1 | +1 day | 15 min | Whether you understood it or watched someone else understand it. A day is enough to lose a shrink condition. |
| Review 2 | +3 days | 12 min | The steep part of the forgetting curve. If the invariant is going, it goes here, not at week three. |
| Review 3 | +7 days | 10 min | Whether the invariant is a claim you can state or just muscle memory of a code shape. |
| Review 4 | +21 days | 8 min | Transfer. You have solved neighbours by now, so this shows whether you recall this problem or the family. |
| Review 5 | +60 days | 8 min | A maintenance ping. Pass and it retires, which is what stops the deck eating your calendar. |
Gaps count from your last passing review, never from the first solve. Hold at day 7 and the next sitting is seven days later, not twenty-one. Intervals roughly triple because each sits just before you would lose the material, and the benefit comes from retrieving something that has started to fade. Reviewing on day 2 because you have a free evening feels productive and buys nothing.
A review is a blank file, not a re-read
Re-reading your own correct solution is the most pleasant thing in interview prep and one of the least useful: it trains recognition, and interviews ask for recall into an empty editor.
Clear the editor before the timer starts
LeetCode generally restores your last submission when you reopen a problem, so select all and delete before you read a word. Better, work in a local file with no template and no saved test harness. If your old code is on screen, you are testing your eyes.
Say the invariant before you type
One sentence on what is true of your state at every step, inside thirty seconds. If nothing comes, the review is already a hold, but sit it anyway. The failed retrieval is where the learning happens.
Do not open the back of your own card
The back is for grading against afterwards, not consulting during. Same for the editorial and the discussion tab. One glance and the sitting has measured nothing.
Stop at the cap, then diff
When the timer goes, stop typing mid-line if you have to. Open the old solution and compare. The diff is the review. Note the one line you got wrong and why, then leave the rest.
The card: a name on the front, three lines on the back
The front is the problem name. Not the difficulty, not the topic tag, not the list it came from. A front reading "Sliding Window: Longest Repeating Character Replacement" has handed you the answer, which is exactly the help no interviewer gives you. The back is three lines:
- Pattern. Family plus the shape inside it. "Sliding window, right always advances, left advances at most once per step" beats a bare "sliding window".
- The one invariant. A claim about state, not a description of steps. It should rewrite to start "at every step it is true that". If you wrote "then we move the left pointer", that is a step.
- Complexity. Time and space, each with its reason in about four words. "O(n), one pass, 26-slot count array", not a bare "O(n)".
No code on the back, ever. Code is the one thing that turns the deck back into a re-reading habit, because you will glance at it, recognise it and feel fluent, and that feeling is what the ladder exists to disprove. A real card:
Front: Longest Repeating Character Replacement
Back: Sliding window, right always advances, left advances at most once per step. At every step the window is valid when its length minus the count of its most frequent character is at most k, because that difference is exactly the number of replacements it needs. O(n) time, one pass with a running max, O(1) space for a 26-slot count array.
Writing that back is the real work of day 0. If you failed the problem cold and need the reasoning compressed into three lines, Code Copilot returns an optimal solution with intuition, a dry run and the Big-O. Use it on day 0 and never on a review day.
Grading: pass, hold, reset
Grade what you did, not whether the judge went green.
- Pass. Invariant stated before typing, running code inside the cap, at most one typo fix. Advance a rung.
- Hold. Over the cap, or correct by trial and error with the invariant never articulated, or you needed one look at the back. Repeat the same gap from today: a day-7 review finished in eleven minutes returns on day 14, not day 28.
- Reset. You opened the old solution, the editorial or the discussion tab before the cap, or never got running code. Back to day 1. Two resets running means park it and clear two easier problems in the family first.
Three submissions of off-by-one guesswork ending in green is a hold, or the schedule stops measuring anything and becomes a chore list.
One problem, four reviews, and what moved each time
The card above, up the ladder. Day 0 was a 38-minute first solve that stalled on when to shrink and ended in the editorial.
| Sitting | What happened | Grade | What changed on the card |
|---|---|---|---|
| Day 1 cap 15 |
12 min. Invariant stated, but in the editorial's words, and max(count.values()) recomputed every iteration, quietly O(26n). |
Pass | Nothing added. A pencilled margin question: does that max need recomputing? |
| Day 4 cap 12 |
8 min, in her own phrasing for the first time. Margin question answered: the running max never needs to decrease, since a later window with a smaller max is shorter than the best already recorded. | Pass | Line 3 sharpened from "O(26n)" to "O(n), one pass, running max never decreases", and that reason moved up into the invariant. |
| Day 11 cap 10 |
5 min. Wrote a while for the shrink, then saw an if suffices, because the window grows by exactly one per iteration. |
Pass | Nothing added. A hedge deleted from line 1. The card is shorter than the day it was written. |
| Day 32 cap 8 |
4 min, first submission green. Later that day, longest substring with at most k distinct characters read as the same skeleton with a different validity test dropped in. | Pass | Line 1 rewritten onto the family: "expand right, shrink left while a predicate is violated, record the best", with this problem's predicate demoted to a sub-clause. |
Day 60 took four minutes and produced nothing new, so the card retired. That shape repeats. Pass one you recall the words, pass two the reasons behind them, pass three you start deleting, pass four the card stops being about the problem and becomes a card about the family, which is the only version that helps on something you have never seen. A card still growing at pass three has a bad invariant line, bad the same way every time: it describes steps instead of stating what is true.
The arithmetic that kills this at week three
Each carded problem generates five reviews, so two months in, your daily load settles at roughly five times your daily intake. At ten minutes a sitting, three new cards a day is 150 minutes of review before you solve anything new. Week three is where most people quietly stop, and that is arithmetic, not weak discipline.
Three fixes. Card at most one problem in three, since something you solved cold with the invariant already in your head was never wrong. Set intake from your budget, not your ambition: 60 minutes a day supports about one new card, 100 minutes supports two. Retire hard at day 60, because an unbounded deck is an abandoned deck.
Honest limits. This is retention, not acquisition, so if you have never met dynamic programming a ladder will not teach it to you. It does nothing for narration, about half of what an interviewer grades, so pair it with mocks where you talk the whole way through. For system design it is close to useless, because there is no single correct artefact to re-derive.
On tooling, since a vendor publishes this page: OfferPilot AI has no review scheduler and will not run your deck, so a four-column spreadsheet is the right tool for the schedule itself. It fits at day 0 and at the diff, with Gemini selected, the recommended model for LeetCode-style problems. It is Windows 10 and 11 only, no macOS, Linux, mobile or browser version. Running it during a review destroys the measurement, which is the point of a review. The free tier is five minutes a day with no card required, and paid plans are on the pricing page.