Week 5 Checkpoint: Interview Drill I
- Retrieve Week 5's six topics from memory under light time pressure
- Complete a 3-problem timed mock (tree / graph / DP) with a think-aloud protocol
- Diagnose misses into a written error log with named causes
- Map each Week 5 pattern to its recognition signals
- Set up an ongoing NeetCode practice cadence for the rest of the program
| Spaced-rep: full Week 5 deck, fumbles marked | 15 min |
| Closed-book recall drills (paper + out-loud) | 15 min |
| Timed mock: 3 problems, think-aloud, self-scored | 40 min |
| Practice: redo your worst problem cold | 15 min |
| Project: error log v1 + practice contract, commit | 15 min |
| Cumulative quiz + schedule next drills | 10 min |
Builds on: Day 29 — Trees & BSTs · Day 31 — Graphs, BFS & DFS · Day 33 — Binary search · Day 34 — Dynamic programming
A pianist does not prepare for a recital by reading sheet music one more time — they play the piece with the score CLOSED, hit the wrong notes, and drill exactly those bars. Today is your closed-score day. This week filled your hands with six instruments — trees, heaps, graphs, sorting, binary search, DP — and today you find out which ones you can actually play from memory, because "I recognized it when I saw the solution" and "I produced it from a blank page" are different skills stored in different places.
The science is boring and bulletproof: retrieval practice — struggling to pull something OUT of memory — strengthens it far more than re-reading, and the struggle works best right as you are starting to forget, which for Monday's trees is… today. So today you write traversals with the editor closed, solve three timed problems cold, and — the part most learners skip — write down *why* each miss happened. That error log becomes the most personally valuable document of your interview prep: a list of exactly your weak bars, updated every drill day until Day 179.
Interview coding rounds are retrieval under pressure with an audience — the only way to train that is to simulate it, which is why every drill day from here to Day 179 uses timed, closed-book mocks. The think-aloud protocol you practice today (restate → examples → brute force → pattern → complexity → code → trace) is scored by real interviewers as heavily as the code itself. And the error log habit compounds: by Day 179 it will tell you precisely which five patterns to cram in your final week instead of anxiously re-reading everything.
Guided practice
Closed-book recall drills
15 minEditor closed for each recall, then open to diff. Score each honestly in your error log: clean / minor slips / needed the book.
- On paper: write the BFS shortest-path skeleton (queue seeding, visited-at-enqueue, parent tracking). Diff against your Day 31
graphs.py. - On paper: the first-occurrence binary search boundary template. Diff against Day 33. Did you keep the invariant comment?
- Out loud (60 seconds each, to your rubber duck or AI tutor in listen-only mode): why in-order traversal of a BST is sorted; why the top-k heap is a MIN-heap; why marking visited at pop time explodes the queue.
- From memory: the four-step DP method, then the house-robber recurrence with its bases.
- Run your spaced-rep deck for all Week 5 cards. Any card you fumble → mark for re-drill and note the day number.
The timed mock — 3 problems, 40 minutes
40 minSet a real timer: about 13 minutes per problem, think-aloud protocol throughout, no peeking at your toolkit files. Say steps 1–4 OUT LOUD before writing code.
- Tree (13 min): Given a binary tree, return the sum of values of nodes at the DEEPEST level. (Pattern check: "by level" — which traversal?)
- Graph (13 min): You are given a list of (employee, manager) pairs forming a hierarchy, plus one employee's name. Return how many levels below the CEO that employee sits. (Model it first: nodes? edges? which traversal answers "levels"?)
- DP (13 min): A message was encoded by mapping A→1, ..., Z→26 and concatenating. Given a digit string like "226", count the decodings ("BZ", "VF", "BBF" → 3). Careful with the digit 0. (Four steps in comments FIRST.)
- When the timer ends, STOP. Grade with the rubric: pattern named before coding (2 pts), working code (3), correct complexity stated (1), edge cases handled (2), clear narration (2) — per problem, out of 10.
- For each problem scored < 7, write the error-log entry now, while the pain is fresh.
On your own
Redo one, cold
15 minTake your WORST mock problem, close everything, and re-solve it from a blank file — including narration. The goal is a clean 9–10/10 run within 12 minutes.
If you scored 9+ on all three (verify honestly against the rubric), instead attempt this stretch problem cold: given a sorted array and a target, return the COUNT of target's occurrences in O(log n) — then check it against your Day 33 toolkit.
No hints today. The struggle is the exercise.
Error log v1 + your NeetCode practice contract
Create interview/error_log.md in your practice repo — the living document that follows you to Day 179. Sections: (1) today's mock scores with per-problem entries (miss type, cause, fix ritual); (2) the Week 5 pattern-recognition map written from memory in your own words; (3) your practice contract: open the NeetCode roadmap, locate the topics you have covered (arrays/hashing, two pointers, stack, trees, heaps, graphs, binary search, 1-D DP), and commit in writing to a cadence (recommended: 2 problems per week, one familiar pattern, one weak-area, logged here). Commit; you will update this file on Days 84, 112, and 179.
Common mistakes & misconceptions
- Re-reading lesson notes instead of retrieving. Familiarity is not recall — the closed-editor diff exposes the difference in minutes.
- Skipping the think-aloud steps to "save time." Naming the pattern before coding is the highest-scoring 30 seconds of a real interview.
- Logging "got it wrong" without a cause. "Marked visited at pop, queue exploded" is fixable; "messed up graphs" is not.
- Grading yourself on whether the idea was right while the code did not run. Interviews (and Day 42's TestClient) grade running code.
- Treating a bad mock score as verdict rather than diagnosis. Today's misses, drilled, are next month's clean solves — that is the entire mechanism.
- Setting an unrealistic practice contract (10 problems/week) that dies by Day 40. Two per week, kept, beats ten planned.
Q1. A problem says "return the minimum number of steps to transform A into B" and you notice sub-transformations repeat. First move?
Q2. The problem guarantees the array is sorted and asks for O(log n). n = 10⁶. Which tool and why?
Q3. Why does the program schedule retrieval drills days after the lesson instead of the same evening?
Go deeper — curated resources
- Make It Stick — the testing effect — The research behind why today felt harder than re-reading and worked better. Optional: read a summary of Roediger & Karpicke's 2006 retrieval-practice studies.
- All recall drills attempted closed-book with honest scores logged
- Timed mock completed within limits and rubric-scored
- Worst problem re-solved cold at 9+/10
- Error log committed with causes named and practice contract signed
- Cumulative quiz ≥ 2/3
← Back: Today drilled Days 29–34 as one toolkit and reused Day 28's drill format. The think-aloud protocol extends the rubber-duck habit from Day 19.
Forward →: The error log returns on Days 84, 112, and 179 (Interview Gym). Week 6 pivots from algorithms to systems — SQL tomorrow — but your practice contract keeps two DSA problems per week alive until interview season.
Unlocks: D179 Interview Gym