Wrap-Up

📘 Learn Wrap-Up from zero

Start from zero. A "Wrap-Up" is the last mile of interview prep. After weeks of learning patterns, you do two things: a Quick Recap (compress everything into a one-page index) and a Checklist (a repeatable routine you run in every interview). Neither teaches new content; both make the content you already have reliably retrievable under stress.

Analogy: a pilot's pre-flight checklist. A senior pilot with 10,000 hours still reads a printed checklist before every takeoff — "flaps set, fuel checked, instruments green." Not because they forgot how to fly, but because under pressure even experts skip steps. Your interview checklist does the same: it guarantees you never forget to clarify the input, state the time and space complexity, or test an edge case, no matter how nervous you are.

Worked example. Say you've studied 8 patterns. Your Quick Recap is a single table: signal → pattern → complexity. "Find a pair summing to target in a sorted array" → two pointers → O(n) time, O(1) space. "Longest substring without repeating characters" → sliding window → O(n) time. Your Checklist, applied to any problem, follows the canonical CTCI 7 steps: (1) restate the problem, (2) walk a concrete example, (3) clarify input size, duplicates, and empty/negative cases, (4) give a brute force with its Big-O, (5) optimize — name the technique and its Big-O, (6) code it, then (7) dry-run a small example and walk edge cases. In the interview you don't invent this routine under pressure — you execute it.

Key insight: the goal of wrap-up is not to know more, but to make what you already know automatic and visible — converting fragile knowledge into a calm, repeatable performance the interviewer can actually grade.

✨ Added by the guide to build intuition — not from the source course.

🎯 Guided practice

1. Easy — Build the one-line recap entry for a known pattern.

   Task: a problem says "given a sorted array, find two numbers that add up to target." Produce the Quick Recap entry.

   Step 1 — find the signal: the words "sorted" and "find a pair." Step 2 — map signal to pattern: sorted + pair → two pointers (one at each end). Step 3 — state the mechanics in one line: move left++ if the sum is too small, right-- if too large. Step 4 — attach complexity: O(n) time, O(1) space. Your recap line: "sorted array + find pair → two pointers; O(n)/O(1)". The shape of every good recap entry is signal → technique → complexity, never prose.

2. Medium — Run the Checklist live on an unfamiliar problem.

   Task: "Given an array of integers and an integer k, return the length of the longest contiguous subarray whose sum equals k." Walk the checklist out loud as you would for an interviewer.

   Step 1 — Restate: "I need the longest contiguous run summing to exactly k." Step 2 — Clarify: "Can values be negative? Can k be 0? Is the array empty?" This is the load-bearing question: with negatives allowed, the plain sliding-window approach breaks, because shrinking the window no longer monotonically decreases the sum. Step 3 — Brute force + Big-O: "Sum every subarray — O(n^2) time, O(1) space." Step 4 — Optimize + name the technique: because negatives are allowed, use prefix sum + hash map: store the first index at which each running prefix sum appears (seed the map with prefix-sum 0 at index -1); at each index, if (currentSum - k) was seen before, the gap from that earliest index to here is a valid subarray. Step 5 — State the new Big-O: O(n) time, O(n) space. Step 6 — Dry-run on [1,-1,5,-2,3], k=3: prefix sums are 1, 0, 5, 3, 6; the longest match is [1,-1,5,-2] → length 4. Step 7 — Edge cases: all negatives, no valid subarray (return 0), and a single element equal to k.

   The lesson: the checklist forced the right clarifying question ("negatives?"), and that one question redirected you from the wrong pattern (sliding window) to the correct one (prefix sum + hash map). That is the entire value of wrap-up discipline — the routine catches the mistake before the code does.

✨ Added by the guide — work these before the full problem set.