A Practice Routine That Compounds

Two habits do most of the work. Space your repetitions, so a problem you struggled with comes back tomorrow, next week and next month, and a problem you solved easily comes back much later. And spend your review time only on what you got wrong, because rereading a solution you already understood teaches you nothing.

from collections import Counter

attempts = ["two sum", "two sum", "kadane", "valid parentheses", "two sum", "kadane"]


def review_queue(log):
    seen = Counter(log)
    return [topic for topic, count in seen.items() if count > 1]


print(review_queue(attempts))

The output is the list two sum and kadane, the two topics that appeared more than once in the log and so deserve more review time.

The mechanism is the spacing effect. Memory research is consistent on this: a skill you nearly have is retained much better by a short session today and a short session in a few days than by one long session today. The review queue is the practical version of that, since it identifies exactly which topics are still fragile.

The trade-off to name is that this approach feels slower than grinding one topic for a weekend, because the work is spread thin and the repetition is not adjacent. The result is the opposite of what it feels like. A second point is to keep the problems fresh rather than repeating the same ones verbatim, since recognising a specific problem is a different skill from recognising the pattern, and the interview will give you a new problem wearing the pattern.

Keep a simple log with one row per attempt: the topic, the pattern it belongs to, whether you solved it, how long it took and whether you needed a hint. The value is in the aggregate view rather than in any single row, because the aggregate is where the imbalance shows up.

Once you have the log, the questions to ask are obvious. Which topics do you always fail? Which patterns have you never seen at all? On which topics are you slow rather than wrong, which is a different problem with a different remedy? And how long has it been since you last touched each pattern, which is the input to the spacing schedule.

The mechanism is that preparation goes wrong in a predictable way. People practise what they already like, which is usually the array and hash map problems they can already do, and they avoid the trees and graph problems that they find harder, which is exactly where the interviews are won or lost.

The trade-off to name is the overhead of maintaining the log, which is small if you keep it to a few fields and update it immediately after each attempt. The alternative is to trust your memory of what you have covered, and that is unreliable, since familiarity feels like coverage. A third point is that the log should include your failures, because a practice log that only records the problems you solved is a record of what you already knew.