Coding interviews

How coding interviews run and how to work through one: formats and a 45-minute timeline, a solving framework, what to say, how you're scored, TypeScript/JavaScript and Python gotchas, an edge-case checklist and an 8-week prep plan. The patterns themselves are in Problem patterns; costs in Big-O; design rounds in System design interviews.

Formats

Ask the recruiter for the format of every round, the language options, whether code must run, and whether the editor has autocomplete. They'll usually tell you.

A 45-minute round

At minute 20 with no approach, code the brute force. A working O(n²) solution beats an unfinished O(n) one.

Solving framework

clarify ─► examples ─► brute force ─► optimize
  3–5 min    2 min        2 min        5–8 min
   ─► plan ─► code ─► test ─► complexity
      1–2 min  15–20   5 min    1 min

1. Clarify. Input types and sizes (n ≤ ? sets the target cost), value ranges, negatives, zeros, duplicates, empty input, sorted or not, can I modify the input, one answer or all, what to return when there is none, ties.
2. Examples by hand. Work the given example, then make a small tricky one. Solving it by hand often shows the algorithm.
3. Brute force, out loud, with its cost. "Checking every pair is O(n²) time, O(1) space." It proves you understand the problem and gives a fallback.
4. Optimize. Look up the signals in Problem patterns. Ask: what work is repeated? Would sorting help? Would a hash map remove the inner loop? Can I trade space for time? What is the best conceivable runtime (usually the input size)?
5. Plan before code. Say the steps, name the data structures, get a nod. Two minutes here saves ten of rewriting.
6. Code cleanly. Real names, small helpers (inBounds(r, c), neighbors(node)), no premature micro-optimizations. Stub a helper and come back to it if it's routine.
7. Test by tracing. Walk a small example through the code line by line, tracking variables. Then run the edge cases in your head. Fix bugs calmly and say what was wrong.
8. State the final complexity of what you wrote, and mention trade-offs or a better approach you'd try with more time.

Talking while coding

Silence longer than a minute or so reads as stuck. If you need to think quietly, say so: "Give me 30 seconds to think about the invariant."

When you're stuck

• Shrink the example (n = 2, 3) and solve it by hand; write down the steps you took.
• Go back to the brute force and ask where it repeats work.
• Walk the signal table: sorted? contiguous? top k? choices with overlap? graph in disguise?
• Change the representation: sort it, count it, index it by value, build a graph.
• Solve an easier version (no duplicates, only positives, k = 1) and extend.
• Ask for a hint gracefully, with what you've tried: "I have O(n²) with two loops and I'm looking for a way to avoid rescanning. Am I on the right track with a hash map?" Taking a hint well costs little; a long silent stall costs more.

What interviewers score

Most large companies grade four areas separately and combine them into a hire / no-hire recommendation.

Level changes the bar, not the areas: seniors are expected to drive, spot edge cases unprompted and discuss trade-offs; juniors get more hints.

Language choice

Use the language you can write fastest without looking anything up. If two are equal, Python is shorter and ships the data structures interviews use.

Some OA platforms and editors run JavaScript but not TypeScript. The JavaScript tabs on these sheets are the TypeScript with the types removed, so either one carries over.

Gotchas

TypeScript / JavaScript

Python

Safe idioms

The traps above, done right in each language.

// numbers: always pass a comparator
const asc = (xs: number[]): number[] =>
  [...xs].sort((a, b) => a - b);
 
// m × n grid: a fresh row per index, never fill([])
const grid = (m: number, n: number): number[][] =>
  Array.from({ length: m }, () =>
    new Array<number>(n).fill(0));
 
// Python-style floor division and modulo
const floorDiv = (a: number, b: number): number =>
  Math.floor(a / b);
const mod = (a: number, n: number): number =>
  ((a % n) + n) % n;
 
// BFS queue without O(n) shift(): array + head index
function bfs(adj: number[][], start: number): number[] {
  const seen = new Set([start]);
  const q = [start];
  for (let head = 0; head < q.length; head++) {
    for (const v of adj[q[head]]) {
      if (!seen.has(v)) {
        seen.add(v);
        q.push(v);
      }
    }
  }
  return q; // visit order
}
 
// counting: Map keeps number keys as numbers
function counts(xs: number[]): Map<number, number> {
  const c = new Map<number, number>();
  for (const x of xs) c.set(x, (c.get(x) ?? 0) + 1);
  return c;
}
 
// pair keys: arrays compare by reference, so encode
const key = (r: number, c: number): string =>
  `${r},${c}`;

// numbers: always pass a comparator
const asc = (xs) => [...xs].sort((a, b) => a - b);
 
// m × n grid: a fresh row per index, never fill([])
const grid = (m, n) =>
  Array.from({ length: m }, () => new Array(n).fill(0));
 
// Python-style floor division and modulo
const floorDiv = (a, b) => Math.floor(a / b);
const mod = (a, n) => ((a % n) + n) % n;
 
// BFS queue without O(n) shift(): array + head index
function bfs(adj, start) {
  const seen = new Set([start]);
  const q = [start];
  for (let head = 0; head < q.length; head++) {
    for (const v of adj[q[head]]) {
      if (!seen.has(v)) {
        seen.add(v);
        q.push(v);
      }
    }
  }
  return q; // visit order
}
 
// counting: Map keeps number keys as numbers
function counts(xs) {
  const c = new Map();
  for (const x of xs) c.set(x, (c.get(x) ?? 0) + 1);
  return c;
}
 
// pair keys: arrays compare by reference, so encode
const key = (r, c) => `${r},${c}`;

from collections import Counter, deque
 
def asc(xs: list[int]) -> list[int]:
    return sorted(xs)  # xs.sort() would return None
 
def grid(m: int, n: int) -> list[list[int]]:
    return [[0] * n for _ in range(m)]  # not [[0]*n]*m
 
def floor_div(a: int, b: int) -> int:
    return a // b  # already floors toward -infinity
 
def mod(a: int, n: int) -> int:
    return a % n  # already has the sign of n
 
def bfs(adj: list[list[int]], start: int) -> list[int]:
    seen = {start}
    q = deque([start])  # popleft is O(1), pop(0) O(n)
    order: list[int] = []
    while q:
        u = q.popleft()
        order.append(u)
        for v in adj[u]:
            if v not in seen:
                seen.add(v)
                q.append(v)
    return order  # visit order
 
def counts(xs: list[int]) -> Counter[int]:
    return Counter(xs)
 
def key(r: int, c: int) -> tuple[int, int]:
    return (r, c)  # tuples hash directly; lists don't

All O(1) except asc O(n log n), grid O(mn), bfs O(V + E) and counts O(n).

Interview template

Write the signature first, then a tiny harness you can run (or trace) at the end: the given example, then edge cases. In an editor that runs code, this is your test step.

// Two Sum: indexes of the two values adding to target
function twoSum(nums: number[], target: number): number[] {
  const seen = new Map<number, number>(); // value → index
  for (let i = 0; i < nums.length; i++) {
    const j = seen.get(target - nums[i]);
    if (j !== undefined) return [j, i];
    seen.set(nums[i], i);
  }
  return [];
}
 
type Case = [nums: number[], target: number, want: number[]];
const cases: Case[] = [
  [[2, 7, 11, 15], 9, [0, 1]], // given example
  [[3, 3], 6, [0, 1]], // duplicates
  [[-1, -2, -3], -5, [1, 2]], // negatives
  [[1, 2], 7, []], // no answer
  [[], 0, []], // empty
];
for (const [nums, target, want] of cases) {
  const got = twoSum(nums, target);
  const ok = JSON.stringify(got) === JSON.stringify(want);
  console.log(ok ? "ok  " : "FAIL", nums, target, got);
}

// Two Sum: indexes of the two values adding to target
function twoSum(nums, target) {
  const seen = new Map(); // value → index
  for (let i = 0; i < nums.length; i++) {
    const j = seen.get(target - nums[i]);
    if (j !== undefined) return [j, i];
    seen.set(nums[i], i);
  }
  return [];
}
 
const cases = [
  [[2, 7, 11, 15], 9, [0, 1]], // given example
  [[3, 3], 6, [0, 1]], // duplicates
  [[-1, -2, -3], -5, [1, 2]], // negatives
  [[1, 2], 7, []], // no answer
  [[], 0, []], // empty
];
for (const [nums, target, want] of cases) {
  const got = twoSum(nums, target);
  const ok = JSON.stringify(got) === JSON.stringify(want);
  console.log(ok ? "ok  " : "FAIL", nums, target, got);
}

def two_sum(nums: list[int], target: int) -> list[int]:
    seen: dict[int, int] = {}  # value → index
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []
 
cases = [
    ([2, 7, 11, 15], 9, [0, 1]),  # given example
    ([3, 3], 6, [0, 1]),  # duplicates
    ([-1, -2, -3], -5, [1, 2]),  # negatives
    ([1, 2], 7, []),  # no answer
    ([], 0, []),  # empty
]
for nums, target, want in cases:
    got = two_sum(nums, target)
    tag = "ok  " if got == want else "FAIL"
    print(tag, nums, target, got)

twoSum is O(n) time, O(n) space. Check the map before inserting the current value, or [3] with target 6 pairs index 0 with itself.

Edge-case checklist

Prep plan

Problem lists

Pick one list and finish it rather than sampling several. Two months out: Grind 75 or NeetCode 150. New to the material: NeetCode 250 in pattern order, alongside the DS&A sheets.

8-week schedule

About 8–10 hours a week: 1–2 new problems a day plus reviews.

Each day: one review problem first (from the spaced-repetition queue), then new problems. Time-box a new problem to about 25 minutes (easy 15, hard 40) before reading a solution.

Spaced repetition

Keep a problem log and re-solve each problem on a schedule; drop it once it's clean twice in a row.

Re-solve without looking. A review counts only if you write the solution from a blank editor, without notes, and it passes the examples. Recognizing the solution is not the same as producing it.

Mock interviews

• Start in week 4; do the last 2–3 in the final week under real conditions (camera on, shared editor, 45 minutes, talking throughout).
• A peer who interviews for a living is best; paid services with working engineers (such as interviewing.io (opens in a new tab)) are next; trading mocks with a friend works if you both give honest scores against the rubric.
• Record yourself once. Silences, filler and skipped testing are obvious on playback.

Reviewing a problem you failed

1. Write down where you got stuck: didn't see the pattern, saw it but couldn't implement it, or bugs.
2. Read one good solution until you can explain why it works (the invariant), not just what it does.
3. Close it and re-solve from scratch the same day.
4. Name the signal you missed and add it to your own signal table.
5. Solve one sibling problem of the same pattern, then queue the original for day 1 and day 3.

Behavioral

Most loops include one behavioral round, and it can sink an otherwise strong loop. Prepare 6–8 true stories (a conflict, a failure, a hard deadline, leading without authority, ambiguity, your biggest impact) and tell each in STAR form, in about 2 minutes:

More in the Tech Interview Handbook: behavioral interviews (opens in a new tab).

The day before and the day of

Recipes

The first 5 minutes

A script for the start of every coding problem; it covers the clarify and examples steps.

1. Read the prompt out loud, or restate it in your own words.
2. "Let me make sure I understand the input and output":
   types, sizes, return value.
3. Ask the clarifying questions: empty? negatives? duplicates?
   sorted? modify in place? one answer or all? what to return
   when there's none? how big can n get?
4. Work the given example by hand, writing the steps you take.
5. Write one small tricky example of your own and agree on
   its expected output.
6. "The brute force is … at O(…). I'll look for something
   better before coding."

Generating test cases

When asked "how would you test this?", or before declaring done.

[ ] the given example, traced line by line through your code
[ ] smallest inputs: empty, one element, two elements
[ ] boundaries: first and last index, k = 0, k = n, max values
[ ] duplicates and all-equal input
[ ] negatives and zero
[ ] no valid answer / several valid answers
[ ] worst case for time: sorted, reverse sorted, all same
[ ] a random small case checked against the brute force
    (if the code runs)

Out of time at minute 30

When the optimal solution isn't coming together.

1. Say it: "I'm going to write the brute force so we have
   something correct."
2. Code the brute force cleanly (5–8 minutes).
3. Test it on the example.
4. Describe the optimization you'd make and its complexity,
   in words or pseudocode.
5. If there's time left, start converting the slow part
   (e.g., inner loop → hash map).

Problem log

One row per attempt, kept in a spreadsheet with columns date, problem, pattern, result, time, missed signal and next review. Sort by "next review" each morning.

date  problem               pattern      result  time  next
09-27 Min Window Substring  sliding win  hint    38m   09-30
      missed: shortest ⇒ shrink while valid
09-27 Daily Temperatures    mono stack   clean   14m   10-11
09-28 Course Schedule       topo sort    failed  40m   09-29
      missed: "prerequisites" ⇒ graph

Post-mortem template

Right after a real or mock interview.

Company / round / date:
Problem (name or paraphrase):
What I asked when clarifying; what I forgot to ask:
Approach I reached and at what minute:
Where I got stuck, and what unstuck me (hint? smaller example?):
Bugs I wrote, and whether I found them or the interviewer did:
Complexity I stated; was it right?
Communication: silences, missed check-ins:
The pattern / signal to add to my table:
Problems to add to the log:

References

• Tech Interview Handbook: coding interview prep (opens in a new tab): the end-to-end guide this sheet's process follows
• Tech Interview Handbook: coding interview rubrics (opens in a new tab): how the four areas are graded
• Tech Interview Handbook: coding interview techniques (opens in a new tab): approaches for when you're stuck
• Grind 75 (opens in a new tab): a configurable schedule of problems
• NeetCode practice (opens in a new tab) and roadmap (opens in a new tab): NeetCode 150 / 250 by pattern, with videos
• Blind 75 (original post) (opens in a new tab): the list that started it
• MDN: Array.prototype.sort (opens in a new tab): default string comparison, comparators, toSorted
• MDN: Remainder (%) (opens in a new tab): sign follows the dividend
• MDN: Math.trunc (opens in a new tab): truncation vs Math.floor and \| 0
• MDN: Number.MAX_SAFE_INTEGER (opens in a new tab): where integer precision ends
• MDN: Array.prototype.shift (opens in a new tab): reindexes the whole array
• Python FAQ: shared default values (opens in a new tab) and multidimensional lists (opens in a new tab): the two classic aliasing bugs
• Python docs: heapq (opens in a new tab): min-heap only, tuple priorities
• Python docs: sys.setrecursionlimit (opens in a new tab): the recursion limit and its risks
• Python wiki: TimeComplexity (opens in a new tab): the cost of every list, deque, dict and set operation
• Cracking the Coding Interview (Gayle Laakmann McDowell): the classic book on the process and problem types