Frequency counting is the canonical hash-map warm-up: one pass, accumulate counts.

With reduce into an object

function countFrequency(arr) {
  return arr.reduce((acc, item) => {
    acc[item] = (acc[item] || 0) + 1;  // first time → 0, then +1
    return acc;
  }, {});
}
countFrequency(["a", "b", "a", "c", "c", "d"]);
// { a: 2, b: 1, c: 2, d: 1 }

With a Map (the better default)

function countFrequency(arr) {
  const freq = new Map();
  for (const item of arr) {
    freq.set(item, (freq.get(item) || 0) + 1);
  }
  return freq;
}

Object vs Map — the talking point

A Map is usually the better choice and worth mentioning why:

• Any key type — objects, numbers, booleans as real keys. An object coerces all keys to strings (1 and "1" collide).
• No prototype collisions — a plain object inherits keys like constructor, toString. Counting an array containing "constructor" against {} gives surprising results. Use Object.create(null) if you stick with an object.
• Preserves insertion order reliably and has a clean .size / iteration API.

For string keys in interview-scale code, an object is fine — but say you'd reach for Map for robustness.

Complexity

• Time: O(n) — single pass.
• Space: O(k) — k distinct elements.

Follow-ups to be ready for

• Most frequent element — track a running max while counting, or sort entries.
• First non-repeating element — count, then find the first with count 1.
• Group by a derived key — same pattern, key is fn(item).

The framing

"One pass, accumulate into a hash map — reduce into an object, or a Map. acc[x] = (acc[x] || 0) + 1. O(n) time, O(k) space. I'd note that Map is the safer default: it allows non-string keys and avoids prototype-key collisions you get with a plain object — though for string keys at interview scale an object is fine. From here, most-frequent or first-non-repeating are small variations on the same count map."