The Interview Playbook

The interview is a conversation

You now know the main data structures and patterns. A coding interview tests one more thing. Can you use them while another person watches, in about 45 minutes, on a problem you have not seen before? Interviewers do not only ask "did the code pass?" They also ask: Can I follow how this person thinks? Would I enjoy working with them? Do they notice problems before I point them out?

That is good news, because thinking and speaking clearly are skills you can practise. This lesson gives you a fixed routine to follow every time. On interview day you can then spend your energy on the problem, and not on deciding what to do next. The routine has six steps: clarify, examples, plan, code, test, analyse. We use Two Sum as our example all the way through, because you already know it.

The 45 minutes at a glance

Step 1: clarify the problem

Problem statements are short and a little vague on purpose. Asking questions is not a sign of weakness. It is the first thing a real engineer does with a new task. First, say the problem again in your own words. Then a misunderstanding shows up now, and not at minute 30. Next, ask the questions whose answers would change your solution.

Step 2: examples and edge cases, out loud

Take the example from the problem and solve it by hand. Say each step out loud: "nums is 2, 7, 11, 15 and the target is 9. 2 and 7 add up to 9, so the answer is indices 0 and 1." This shows you understood the problem. The way you solved it by hand is often the algorithm itself.

Then make up edge cases. These are small, odd inputs where code often breaks. Here is a checklist you can trust: empty input, one element, two elements, all elements equal, duplicates, negatives and zero, already sorted, sorted in reverse, the largest allowed size, and "no answer exists". Say them out loud and write the expected answers next to them. You will use the same list again in step 5.

Step 3: brute force, then optimise

Always say the brute force first, even if you already see a better answer. Brute force means trying every possibility in the simplest way. It is correct, it shows you can solve the problem, and it gives you a cost to beat. Then ask: where is the wasted work? It is usually one of these. You search for something that a map could look up (lesson 26). Or you work out again something that a running total could remember (lesson 20). Or you scan a sorted range that binary search could cut in half (lesson 28). Or you solve the same small problem many times (lesson 54).

// "Does the array contain a duplicate?" in three steps of improvement, said aloud as you go.function hasDuplicateBrute(nums) {            // 1. brute force: compare every pair, O(n^2) time, O(1) space  for (let i = 0; i < nums.length; i++) {    for (let j = i + 1; j < nums.length; j++) {      if (nums[i] === nums[j]) return true;    }  }  return false;}function hasDuplicateSort(nums) {             // 2. sort, then equal values sit side by side: O(n log n) time  const sorted = [...nums].sort((a, b) => a - b);   // copy first so the caller's array is untouched  for (let i = 1; i < sorted.length; i++) {    if (sorted[i] === sorted[i - 1]) return true;  }  return false;}function hasDuplicateSet(nums) {              // 3. remember what we have seen: O(n) time, O(n) space  const seen = new Set();  for (const x of nums) {    if (seen.has(x)) return true;    seen.add(x);  }  return false;}for (const f of [hasDuplicateBrute, hasDuplicateSort, hasDuplicateSet]) {  console.log(f([1, 2, 3, 1]), f([1, 2, 3]), f([]));}// true false false// true false false// true false false

Say it like climbing a ladder: "Brute force is O(n²) time. Sorting gives O(n log n) time with O(1) extra memory, if I may change the order. A Set (a collection that remembers values and checks "seen it?" in O(1) time) gives O(n) time but uses O(n) memory. Which trade-off would you like?" Offering the choice is a strong move. Then agree on the plan before you type: "Does that approach sound reasonable to you?"

Step 4: clean code under time pressure

You write for two readers: the interviewer, and yourself ten minutes from now, when you must dry-run the code. So:

• Write one function with a clear name and inputs, in the same form the problem gave you.
• Choose names that mean something (needed, left, best), not a, t, m.
• Handle the special cases first with an early return (leave the function at once), then write the main logic.
• Explain in blocks, not word by word: "now the loop that builds the map".
• Use built-in tools you know well (Map, Set, Math.max). Do not write a heap from memory unless asked. JavaScript has no built-in priority queue, so just say "I would use a priority queue here".
• If a helper function slows you down, give it a name, use it, and write its body later.

// The same function twice. Both are correct; only one is pleasant to read, dry-run and fix at minute 35.function f(a, t) {  const m = new Map();  for (let i = 0; i < a.length; i++) {    if (m.has(t - a[i])) return [m.get(t - a[i]), i];    m.set(a[i], i);  }  return [];}function twoSum(nums, target) {  const indexOf = new Map();                   // value -> index where we saw it  for (let i = 0; i < nums.length; i++) {    const needed = target - nums[i];    if (indexOf.has(needed)) return [indexOf.get(needed), i];    indexOf.set(nums[i], i);                   // set AFTER the check so an element never pairs with itself  }  return [];}console.log(f([2, 7, 11, 15], 9));        // [ 0, 1 ]console.log(twoSum([2, 7, 11, 15], 9));   // [ 0, 1 ]

Step 5: test with a dry run

When the code is written, do not say "I think it works." Run it by hand. This is the dry-run habit you built in lesson 1. Point at each line and say the value of each variable. Write the variables in a small table next to the code. Use three kinds of input. First, the example from the problem. Second, one edge case from step 2. Third, if you have time, one case made to break your idea (for Two Sum: the same number used twice).

// A tiny test table you can type in two minutes, and run in your head just as well.function twoSum(nums, target) {  const indexOf = new Map();  for (let i = 0; i < nums.length; i++) {    const needed = target - nums[i];    if (indexOf.has(needed)) return [indexOf.get(needed), i];    indexOf.set(nums[i], i);  }  return [];}const cases = [  ["the given example",     [2, 7, 11, 15], 9,  [0, 1]],  ["duplicates",            [3, 3],         6,  [0, 1]],  ["negatives",             [-1, -2, -3, -4], -6, [1, 3]],  ["no element used twice", [3, 2, 4],      6,  [1, 2]],  ["no answer",             [1, 2],         10, []],  ["empty array",           [],             5,  []],];for (const [name, nums, target, want] of cases) {  const got = twoSum(nums, target);  console.log(JSON.stringify(got) === JSON.stringify(want) ? "pass" : "FAIL", name, got);}// pass the given example [ 0, 1 ]// pass duplicates [ 0, 1 ]// pass negatives [ 1, 3 ]// pass no element used twice [ 1, 2 ]// pass no answer []// pass empty array []

If you find a bug yourself, you earn credit ("good catch, that is an off-by-one", which means a mistake of 1 in a count or index). If the interviewer finds it, it costs you. When you find a bug, change the smallest thing. Run the case that failed. Then run the earlier cases again to check that nothing else broke.

Step 6: state time and space complexity

Give the analysis before you are asked. A good answer has the same few parts every time:

The interviewer may then ask "can you do better?" They may be hinting that a better solution exists, or they may just want to see how you react. Think out loud about the slowest part. Is it the sort? The lookup? The repeated work? You do not need to find a miracle. It is also a good answer to explain the lowest possible cost ("I must at least read every element, so O(n) time is the minimum").

Using hints well

Hints are normal. Almost every interviewer plans to give some. What they watch is how you use them.

1. Get stuck out loud. Say what you have tried and where it fails: "sorting loses the original indices, so I need a way to keep them". That is a clear question, and it earns a clear hint.
2. Ask for a direction, not the answer. "Should I think more about the data structure or about the algorithm?"
3. Say the hint again in your own words and say what it changes: "So you suggest a map from value to index. Then each lookup is O(1)."
4. Do not feel bad about it. A hint at minute 15 costs far less than a silent dead end until minute 40.
5. Do not ignore it. If the interviewer mentions a data structure or a limit, use it straight away.

JavaScript-specific tips

JavaScript has a few behaviours that can quietly break an answer that is otherwise correct. We ran every sample below to check the printed values. Knowing these behaviours shows that you have experience.

sort() compares text by default

If you give sort() no comparator (a small function that says which of two values comes first), it turns the values into strings. Then 10 sorts before 9. For numbers, always pass (a, b) => a - b (lesson 18). It also sorts in place, which means it changes the original array. Copy first with [...arr] if you need to keep the original.

const nums = [10, 9, 1, 100];console.log([...nums].sort());                // [ 1, 10, 100, 9 ]      default order compares TEXT: "10" < "9"console.log([...nums].sort((a, b) => a - b)); // [ 1, 9, 10, 100 ]      a comparator fixes itconsole.log(nums);                            // [ 10, 9, 1, 100 ]      the spread copied it, so the original is intactnums.sort((a, b) => a - b);                   // sort() with no copy changes the array in placeconsole.log(nums);                            // [ 1, 9, 10, 100 ]console.log(["b", "a", "c"].sort().join("")); // abc                    fine for single letters: text order is what we want

-0, NaN and decimals

Three kinds of values break the usual idea of "equal". First, -0 (negative zero) is a real value. It equals 0 under ===, but Object.is and console.log treat it as different. It appears from 0 * -5 and similar sums, and it can make a check of the expected output fail. Second, NaN (“not a number”) is never equal to anything, even itself. Use Number.isNaN to test for it. Third, computers store decimals as binary fractions, so 0.1 + 0.2 is not exactly 0.3.

console.log(0 === -0);                  // true     === says they are equalconsole.log(Object.is(0, -0));          // false    Object.is can tell them apartconsole.log(0 * -5, Math.round(-0.4));  // -0 -0    -0 appears whenever a zero is multiplied by a negativeconsole.log(String(-0), JSON.stringify(-0)); // 0 0 it prints as a plain 0 in text, but console.log shows -0console.log((-0) + 0, new Set([0, -0]).size); // 0 1   adding 0 normalises it; Set and Map treat them as one keyconsole.log(NaN === NaN);               // false    NaN is not equal to anything, itself includedconsole.log([NaN].includes(NaN));       // true     includes, Set and Map use "same value" logic...console.log([NaN].indexOf(NaN));        // -1       ...but indexOf uses ===, so it never finds NaNconsole.log(Number.isNaN(Number("abc")), Number.isNaN("abc"), isNaN("abc")); // true false trueconsole.log(0.1 + 0.2);                 // 0.30000000000000004console.log(0.1 + 0.2 === 0.3);         // falseconsole.log(Math.abs(0.1 + 0.2 - 0.3) < 1e-9); // true   compare floats with a tolerance, or work in whole cents

Map and Set against plain objects

A plain object is fine for counting letters. But its keys are always strings, keys that look like whole numbers get reordered, and it already has inherited names like constructor. A Map keeps the type of each key and the order in which you added them. Neither one compares arrays by their contents. For pairs, build a text key such as "row,col" (lesson 10).

const obj = {};obj[1] = "number key";obj["1"] = "string key";console.log(Object.keys(obj).length);   // 1       an object turns every key into a string, so 1 and "1" collideconst map = new Map();map.set(1, "number key");map.set("1", "string key");console.log(map.size);                  // 2       a Map keeps the typeconst order = {};order.b = 1; order[2] = 1; order[1] = 1;console.log(Object.keys(order));        // [ '1', '2', 'b' ]   integer-like keys jump to the front, sorted: not insertion orderconsole.log("constructor" in {});       // true    an empty object already "has" inherited names such as constructor and toStringconst byReference = new Map();byReference.set([1, 2], "x");console.log(byReference.get([1, 2]));   // undefined   arrays are compared by identity, not by contentsconst visited = new Set();visited.add(2 + "," + 3);               // build a text key for a pair such as a grid cell (row 2, column 3)console.log(visited.has("2,3"));        // true

Integers: 2^53 and 32 bits

JavaScript numbers are 64-bit decimal-style numbers (called doubles). They do not wrap around like a 32-bit intdoes in Java or C++. But whole numbers are exact only up to 2^53 - 1. This leads to two traps. First, a product or sum above that limit loses digits, and nothing warns you. For "give the answer modulo 1e9 + 7" questions (the remainder after dividing by 1e9 + 7), use BigInt (a number type for very big whole numbers) or split the multiplication. Second, the bitwise operators (|, &, ^, <<, >>) first turn the number into 32 bits. So they are the wrong tool for big values (lesson 58).

console.log(Number.MAX_SAFE_INTEGER);   // 9007199254740991    this is 2^53 - 1console.log(2 ** 53 + 1 === 2 ** 53);   // true     beyond it, whole numbers silently lose precisionconsole.log(12345678901234567890);      // 12345678901234567000console.log(12345678901234567890n);     // 12345678901234567890n    a BigInt (the n suffix) stays exactconsole.log((2 ** 31) | 0);             // -2147483648   bitwise operators work on 32-bit integersconsole.log(5000000000 | 0);            // 705032704console.log(1 << 31, 1 << 32);          // -2147483648 1// "Return the answer modulo 1e9 + 7" with big factors: the multiplication itself can exceed 2^53.const a = 999999999, b = 999999998, mod = 1000000007;console.log((a * b) % mod);             // 70   wrong: a * b is about 1e18, already roundedconsole.log(Number(BigInt(a) * BigInt(b) % BigInt(mod))); // 72   right: BigInt multiplies exactly

Array holes

new Array(3) makes three empty slots (holes), not three undefined values. Methods such as map and forEach skip these holes. Build arrays with fill or Array.from. Holes also appear when you write delete arr[i] or assign to an index past the end of the array.

const holes = [1, , 3];                 // a hole: the slot does not exist at all (not the same as undefined)console.log(holes.length, 1 in holes);  // 3 falseconsole.log(holes.map((x) => x * 2));   // [ 2, <1 empty item>, 6 ]   map, forEach and friends skip holesconsole.log(new Array(3).map((_, i) => i)); // [ <3 empty items> ]    so this "fill with 0..2" does nothingconsole.log(new Array(3).fill(0));      // [ 0, 0, 0 ]console.log(Array.from({ length: 3 }, (_, i) => i)); // [ 0, 1, 2 ]   the safe way to build an array from an index

Recursion depth is limited

Each function call uses space on the call stack (the list of calls that are still waiting to finish). JavaScript limits this to about ten thousand calls for simple functions. In our test the function below reached about 10,900 calls in Node 22. Browsers and bigger functions give other numbers. A recursion that goes n = 100,000 calls deep, such as a depth-first search down a long chain, gives a RangeError. In an interview, ask for the maximum depth. If it can reach 10^5, say that you will switch to your own stack (an array that you push to and pop from).

function countDown(n) { return n === 0 ? 0 : 1 + countDown(n - 1); }console.log(countDown(1000));           // 1000try {  countDown(100000);} catch (e) {  console.log(e instanceof RangeError, e.message); // true Maximum call stack size exceeded}// The same walk with your own array as the stack never hits that limit.function countDownLoop(n) {  const stack = [n];  let steps = 0;  while (stack.length) {    const v = stack.pop();    if (v > 0) { steps++; stack.push(v - 1); }  }  return steps;}console.log(countDownLoop(100000));     // 100000

shift() can be slow; use a head index

queue.shift() removes the first element and moves all the others down by one. So it can cost O(n) for each call. (JavaScript engines speed this up for small arrays, but you cannot count on it.) In our test run for this lesson, emptying 100,000 elements with shift took over ten seconds. With an index it took about a millisecond. For BFS (breadth-first search: visit everything one step away, then two steps away, and so on, using a queue; lessons 39 and 50), move a head index forward instead. The same advice applies to unshift, and to splice in the middle of a big array.

// A queue as an array: advance a head index instead of calling shift().const queue = [1, 2, 3];let head = 0;const order = [];while (head < queue.length) {  const x = queue[head++];              // O(1) dequeue  order.push(x);  if (x < 3) queue.push(x + 10);        // new work joins the back, exactly as in BFS}console.log(order);                     // [ 1, 2, 3, 11, 12 ]

Destructuring swaps

[a, b] = [b, a] swaps two values without a temporary variable. It also works on array slots. There is one trap. A line that starts with [ is joined to the line before it if that line has no semicolon. So if you write without semicolons, the swap can give an error or do something else without warning. End the line before it with ;.

let x = 1, y = 2;[x, y] = [y, x];                        // swap with no temporary variableconsole.log(x, y);                      // 2 1const arr = [5, 6, 7];[arr[0], arr[2]] = [arr[2], arr[0]];    // swap two array slots: the heart of reverse, partition and permutationsconsole.log(arr);                       // [ 7, 6, 5 ]const [first, ...rest] = [1, 2, 3];console.log(first, rest);               // 1 [ 2, 3 ]

2-D arrays: fill and copying

The most common bug with grids: Array(3).fill(Array(3).fill(0)) puts one inner array into all three rows. So changing one row changes all of them. Build each row separately. Copying has the same problem. [...grid] is a shallow copy. This means it copies only the outer array, and the rows are still shared. Copy each row, or use structuredClone, which copies at any depth (lesson 25).

const bad = Array(3).fill(Array(3).fill(0));    // fill puts the SAME inner array in every rowbad[0][0] = 1;console.log(bad);                       // [ [ 1, 0, 0 ], [ 1, 0, 0 ], [ 1, 0, 0 ] ]const good = Array.from({ length: 3 }, () => Array(3).fill(0));   // a fresh inner array per rowgood[0][0] = 1;console.log(good);                      // [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ]const grid = [[1, 2], [3, 4]];const shallow = [...grid];              // copies the outer array only; the rows are sharedshallow[0][0] = 99;console.log(grid[0][0]);                // 99const rowsCopied = grid.map((row) => [...row]);   // one level deeper: a real copy of a 2-D arrayrowsCopied[0][0] = 5;console.log(grid[0][0]);                // 99   unchangedconst deep = structuredClone(grid);     // copies any depth (numbers, arrays, objects, Map, Set)deep[0][0] = 7;console.log(grid[0][0], deep[0][0]);    // 99 7

Smaller gotchas, all checked

Common mistakes

Mock interview walk-throughs

These four are different from the practice questions in earlier lessons. Each one is a script. It has the problem, the examples, the approaches, and a green box at the end with what you would say out loud at each step. Read the problem, close the solutions, and first try to say your own version out loud. Then compare.

function twoSum(nums, target) {  for (let i = 0; i < nums.length; i++) {    for (let j = i + 1; j < nums.length; j++) {   // j starts after i: no element is used twice      if (nums[i] + nums[j] === target) return [i, j];    }  }  return [];}console.log(twoSum([2, 7, 11, 15], 9)); // [ 0, 1 ]console.log(twoSum([3, 2, 4], 6));      // [ 1, 2 ]console.log(twoSum([3, 3], 6));         // [ 0, 1 ]console.log(twoSum([1, 2], 10));        // []

function twoSum(nums, target) {  const indexOf = new Map();                       // value -> index where we saw it  for (let i = 0; i < nums.length; i++) {    const needed = target - nums[i];    if (indexOf.has(needed)) return [indexOf.get(needed), i];    indexOf.set(nums[i], i);                       // store after checking, so an element cannot pair with itself  }  return [];}console.log(twoSum([2, 7, 11, 15], 9)); // [ 0, 1 ]console.log(twoSum([3, 2, 4], 6));      // [ 1, 2 ]console.log(twoSum([3, 3], 6));         // [ 0, 1 ]console.log(twoSum([1, 2], 10));        // []

function isValid(s) {  let brackets = s.replace(/[^()\[\]{}]/g, "");  // drop every character that is not a bracket  let previous;  do {    previous = brackets;    brackets = brackets.replace("()", "").replace("[]", "").replace("{}", "");  } while (brackets !== previous);  return brackets === "";}console.log(isValid("a(b)[c]{d}")); // trueconsole.log(isValid("(]"));         // falseconsole.log(isValid("(()"));        // falseconsole.log(isValid("{[()]}"));     // true

function firstInvalid(s) {  const pairs = { ")": "(", "]": "[", "}": "{" };  const stack = [];                                  // indices of openers not yet closed  for (let i = 0; i < s.length; i++) {    const ch = s[i];    if (ch === "(" || ch === "[" || ch === "{") {      stack.push(i);    } else if (ch in pairs) {      if (stack.length === 0 || s[stack[stack.length - 1]] !== pairs[ch]) return i;   // nothing to close, or wrong type      stack.pop();    }                                                // any other character is ignored  }  return stack.length === 0 ? -1 : stack[0];         // the earliest opener that was never closed}console.log(firstInvalid("a(b)[c]{d}")); // -1console.log(firstInvalid("(]"));         // 1console.log(firstInvalid("(()"));        // 0console.log(firstInvalid("())"));        // 2console.log(firstInvalid(""));           // -1console.log(firstInvalid("}"));          // 0

function merge(intervals) {  const list = intervals.map(([a, b]) => [a, b]);        // copy, so the caller's data is not changed  let changed = true;  while (changed) {    changed = false;    search: for (let i = 0; i < list.length; i++) {      for (let j = i + 1; j < list.length; j++) {        const [a, b] = list[i], [c, d] = list[j];        if (a <= d && c <= b) {                           // they overlap (or touch)          list[i] = [Math.min(a, c), Math.max(b, d)];          list.splice(j, 1);          changed = true;          break search;                                   // start the scan again        }      }    }  }  return list.sort((p, q) => p[0] - q[0]);}console.log(merge([[1, 3], [2, 6], [8, 10], [15, 18]])); // [ [ 1, 6 ], [ 8, 10 ], [ 15, 18 ] ]console.log(merge([[1, 4], [4, 5]]));                    // [ [ 1, 5 ] ]console.log(merge([[1, 4], [2, 3]]));                    // [ [ 1, 4 ] ]console.log(merge([]));                                  // []

function merge(intervals) {  const sorted = intervals.map(([a, b]) => [a, b]).sort((p, q) => p[0] - q[0]);   // by start; a copy  const result = [];  for (const [start, end] of sorted) {    const last = result[result.length - 1];    if (last && start <= last[1]) {      last[1] = Math.max(last[1], end);               // overlap: extend, never shrink    } else {      result.push([start, end]);                      // gap: begin a new merged interval    }  }  return result;}console.log(merge([[1, 3], [2, 6], [8, 10], [15, 18]])); // [ [ 1, 6 ], [ 8, 10 ], [ 15, 18 ] ]console.log(merge([[1, 4], [4, 5]]));                    // [ [ 1, 5 ] ]console.log(merge([[1, 4], [2, 3]]));                    // [ [ 1, 4 ] ]console.log(merge([]));                                  // []

function canFinish(numCourses, prerequisites) {  const next = Array.from({ length: numCourses }, () => []);  for (const [course, before] of prerequisites) next[before].push(course);   // arrow: before -> course  const state = new Array(numCourses).fill(0);       // 0 = unvisited, 1 = on the current path, 2 = finished  function hasCycle(v) {    if (state[v] === 1) return true;                 // we came back to a course on our own path    if (state[v] === 2) return false;    state[v] = 1;    for (const w of next[v]) if (hasCycle(w)) return true;    state[v] = 2;    return false;  }  for (let v = 0; v < numCourses; v++) if (hasCycle(v)) return false;  return true;}console.log(canFinish(2, [[1, 0]]));                          // trueconsole.log(canFinish(2, [[1, 0], [0, 1]]));                  // falseconsole.log(canFinish(4, [[1, 0], [2, 0], [3, 1], [3, 2]]));  // trueconsole.log(canFinish(1, []));                                // true

function canFinish(numCourses, prerequisites) {  const next = Array.from({ length: numCourses }, () => []);  const waiting = new Array(numCourses).fill(0);     // prerequisites each course still needs  for (const [course, before] of prerequisites) {    next[before].push(course);    waiting[course]++;  }  const queue = [];  for (let v = 0; v < numCourses; v++) if (waiting[v] === 0) queue.push(v);  let head = 0;  while (head < queue.length) {    const v = queue[head++];                         // take this course    for (const w of next[v]) {      waiting[w]--;      if (waiting[w] === 0) queue.push(w);    }  }  return queue.length === numCourses;                // anything stuck inside a cycle is never queued}console.log(canFinish(2, [[1, 0]]));                          // trueconsole.log(canFinish(2, [[1, 0], [0, 1]]));                  // falseconsole.log(canFinish(4, [[1, 0], [2, 0], [3, 1], [3, 2]]));  // trueconsole.log(canFinish(1, []));                                // true

Make it stick

What's next

The last lesson, Lesson 60, turns everything into a plan. It has a cheat sheet that links the words of a problem to the right method and lesson. It has an eight-week practice schedule. It has a spaced-repetition routine (you review things again after longer and longer gaps). It also has mock interviews where you must spot the pattern from the words alone.