Array Drills from Real Interviews

This is a favourite because it looks simple and has three traps: duplicates, a single element, and an empty array.

const secondLargest = (numbers) => {
  const distinct = [...new Set(numbers)].sort((a, b) => b - a);
  return distinct.length > 1 ? distinct[1] : null;
};

console.log(secondLargest([4, 1, 9, 9, 2]));   // 4
console.log(secondLargest([1, 1, 1]));          // null
console.log(secondLargest([]));               // null

Working through the solution in an interview, the important move is to state the assumptions before you write anything. The word distinct in the question means duplicates do not count, so nine appearing twice is still one value. And the answer does not exist when there are fewer than two distinct values, so returning null is the honest result rather than a made-up number.

Each step of the implementation addresses one of those. The set removes the duplicates while keeping the order, the sort puts them in descending order, and the length check handles the cases where there is no second value. Sorting in descending order means the second element of the array is the answer, which is easy to see and easy to check.

The alternative is a single pass that keeps the two largest values as it goes, which is linear rather than the sort's n times log n, and it avoids allocating a new array. It is also more code and more room for an off-by-one error. If the interviewer mentions performance, mention the single pass version and explain the trade-off, but start with the clear one.

Grouping by a property is the most common array transformation in real application code, because almost every list view needs it.

const groupBy = (items, key) =>
  items.reduce((groups, item) => {
    const value = item[key];
    (groups[value] ||= []).push(item);
    return groups;
  }, {});

const orders = [
  { id: 1, status: "paid" },
  { id: 2, status: "open" },
  { id: 3, status: "paid" },
];

const grouped = groupBy(orders, "status");
console.log(grouped.paid.length);   // 2
console.log(grouped.open.length);   // 1

The implementation is a reduce with an object accumulator. The key detail is the logical assignment in the middle, which reads the existing group, creates an empty array if there is not one yet, and assigns it back, all in one expression. Spreading the new item into an existing array would copy the array on every item, which is the slow version that catches people out.

Two things to raise in an interview. The accumulator is mutated rather than copied, which is fine here and is the fast approach, but it is worth saying out loud that you are mutating the accumulator and that you know it. And the keys come from user data, so a key such as the name constructor would collide with the inherited property on a plain object. Using a Map avoids that entirely, or you create the accumulator with no prototype.

That collision is not theoretical. Any key that matches a property on the object prototype, such as toString or constructor, will behave oddly, and it is a good example of a security-shaped bug caused by using a plain object as a dictionary.