Two operations: dedupe then sort. The whole question hinges on one gotcha.

The solution

function sortedUnique(arr) {
  return [...new Set(arr)].sort((a, b) => a - b);
}
sortedUnique([3, 1, 2, 3, 1]); // [1, 2, 3]

• new Set(arr) removes duplicates in O(n) — Set keeps only distinct values.
• [...set] spreads it back to an array.
• .sort((a, b) => a - b) sorts numerically, ascending.

The gotcha interviewers are actually testing

Array.prototype.sort() with no comparator sorts elements as strings:

[10, 9, 1, 100].sort();            // [1, 10, 100, 9]  ❌ lexicographic!
[10, 9, 1, 100].sort((a, b) => a - b); // [1, 9, 10, 100] ✅

Forgetting the comparator on numeric input is the #1 mistake. Always pass (a, b) => a - b.

Without Set (if asked)

function sortedUnique(arr) {
  const seen = {};
  const out = [];
  for (const x of arr) {
    if (!seen[x]) { seen[x] = true; out.push(x); }
  }
  return out.sort((a, b) => a - b);
}

Or sort first, then filter elements equal to their predecessor.

Other talking points

• .sort() mutates the array in place and returns it — spreading into a new array first avoids mutating the caller's input.
• Mixed types / NaN — a - b produces NaN for non-numbers; clarify the input contract.
• Strings — for string input, .sort() with no comparator (or localeCompare for locale-correct order) is actually correct.
• Complexity — O(n) dedupe + O(n log n) sort = O(n log n).

The framing

"[...new Set(arr)].sort((a, b) => a - b) — Set for O(n) dedupe, sort for O(n log n). The thing I'd call out explicitly is the comparator: bare .sort() is lexicographic, so [10, 9].sort() gives [10, 9]. And since sort mutates, I spread into a fresh array so I don't clobber the caller's input."