Coding under time pressure

Overview

Coding under time pressure is the skill of turning an agreed approach into correct, readable code within about 15 to 20 minutes while explaining what you do. Knowing the algorithm is not enough; many candidates fail because they run out of time, get lost in details, or freeze when a bug appears.

The antidotes are structure and rehearsal: a fixed time budget for each phase, code templates you can write from memory (binary search, BFS, sliding window, backtracking, union find), top-down coding with helper functions, and a calm debugging routine that traces a small example instead of guessing.

When to use it

• Timed coding interviews and online assessments.
• Contests and hackathons.
• Any situation where you must implement correctly on the first try.

Problem patterns it solves

Where it is used in real software

Key terms

Time budget

Planned minutes for clarify, design, code, test.

Template

A memorized skeleton for a common pattern.

Top-down coding

Write the main flow with helper calls first, then implement helpers.

Dry run

Trace the code by hand on a small input.

A 45-minute plan

1. 1
   0-5 min: clarify

   Restate, ask about constraints and edge cases, agree on an example.

2. 2
   5-15 min: design

   Brute force, then the optimal idea with complexity. Get interviewer buy-in before coding.

3. 3
   15-35 min: code

   Write the template first, top-down with helpers, narrating briefly. Use clear names.

4. 4
   35-42 min: test

   Dry-run the example and 2 to 3 edge cases; fix bugs by tracing, not guessing.

5. 5
   42-45 min: wrap up

   State final complexity, mention improvements or follow-ups.

Debugging routine when the output is wrong

Your sliding window returns 4 instead of 3 for "abcabcbb"

A systematic trace on the smallest failing case finds bugs faster than rereading code, and it shows the interviewer a professional debugging process.

Implementation

1// Templates worth writing from memory2 3// 1. Binary search on a monotonic predicate: first index where ok(i) is true4function firstTrue(lo, hi, ok) {5  while (lo < hi) {6    const mid = lo + ((hi - lo) >> 1);7    if (ok(mid)) hi = mid;8    else lo = mid + 1;9  }10  return lo;11}12 13// 2. BFS on a grid14function bfsGrid(grid, sr, sc) {15  const rows = grid.length, cols = grid[0].length;16  const dist = Array.from({ length: rows }, () => new Array(cols).fill(-1));17  const queue = [[sr, sc]];18  dist[sr][sc] = 0;19  for (let head = 0; head < queue.length; head++) {20    const [r, c] = queue[head];21    for (const [dr, dc] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {22      const nr = r + dr, nc = c + dc;23      if (nr < 0 || nc < 0 || nr >= rows || nc >= cols) continue;24      if (grid[nr][nc] === 1 || dist[nr][nc] !== -1) continue;25      dist[nr][nc] = dist[r][c] + 1;26      queue.push([nr, nc]);27    }28  }29  return dist;30}31 32// 3. Variable sliding window33function longestValidWindow(arr, isValidAfterAdd, add, remove) {34  let left = 0, best = 0;35  for (let right = 0; right < arr.length; right++) {36    add(arr[right]);37    while (!isValidAfterAdd()) remove(arr[left++]);38    best = Math.max(best, right - left + 1);39  }40  return best;41}42 43// 4. Backtracking44function backtrackTemplate(choices, isComplete, isValid) {45  const result = [], path = [];46  (function dfs(start) {47    if (isComplete(path)) { result.push([...path]); return; }48    for (let i = start; i < choices.length; i++) {49      if (!isValid(path, choices[i])) continue;50      path.push(choices[i]);51      dfs(i + 1);52      path.pop();53    }54  })(0);55  return result;56}

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Coding before the interviewer agrees with the approach.

  Fix: Ask 'does this approach sound good before I code it?'.

• Random edits when a bug appears.

  Fix: Trace the smallest failing input line by line.

• Spending 20 minutes on a stuck optimal idea.

  Fix: Set a checkpoint: if not clear by minute 15, code the brute force and optimize after.

Interview questions

Practice problems