flatten is a classic recursion warm-up. Show you can do it three ways and know the tradeoffs.

1. Recursive with reduce (the expected answer)

function flatten(arr) {
  return arr.reduce(
    (acc, item) =>
      Array.isArray(item)
        ? acc.concat(flatten(item))   // recurse into nested arrays
        : acc.concat(item),
    []
  );
}
flatten([1, [2, [3, [4]], 5]]); // [1, 2, 3, 4, 5]

2. With a depth parameter (like the real flat())

function flatten(arr, depth = Infinity) {
  return depth < 1
    ? arr.slice()
    : arr.reduce(
        (acc, item) =>
          Array.isArray(item)
            ? acc.concat(flatten(item, depth - 1))
            : acc.concat(item),
        []
      );
}
flatten([1, [2, [3]]], 1); // [1, 2, [3]]

3. Iterative with a stack (no recursion-depth limit)

For very deeply nested arrays, recursion can blow the call stack. An explicit stack avoids that:

function flatten(arr) {
  const stack = [...arr];
  const result = [];
  while (stack.length) {
    const next = stack.pop();
    if (Array.isArray(next)) stack.push(...next); // push children back
    else result.push(next);
  }
  return result.reverse(); // pop reverses order, so reverse back
}

4. The built-in

[1, [2, [3]]].flat(Infinity); // [1, 2, 3]

Array.prototype.flat(depth) exists — mention it, but interviewers want the manual implementation.

Talking points

• concat vs push — concat returns a new array (cleaner but allocates more); push(...item) mutates in place (faster).
• Recursion depth — the recursive version is elegant but can stack-overflow on pathological input; the iterative stack version is bulletproof.
• Array.isArray — the correct check, not typeof (arrays are objects).

The framing

"I'd start with the recursive reduce — it's the cleanest expression of the idea. Then I'd mention two things a senior cares about: a depth parameter to match the real flat(), and an iterative stack version that won't overflow on deeply nested input. flat(Infinity) is the built-in, but the point of the exercise is the recursion."