Lesson 3 of 80

reduce & breaking big problems into small steps

Q: Explain how reduce works, and implement map or filter using only reduce.

A strong answer covers: reduce walks a list once, carrying a running accumulator, calling a step function with (accumulator, item) each time; The initial value matters — omitting it makes the first item the seed and starts iterating from the second item; map and filter can both be expressed as reduce with a specific step (map: push a transformed item; filter: conditionally push the item).

The one array method that can express all the others — and a way of thinking that turns a scary problem into one small step, repeated.

15 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

Question 1 of 2

What two things does reduce need to work?

A starting value and a step function (accumulator + item -> new accumulator)A filter condition and a mapping functionAn index and a length

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on reduce & breaking big problems into small steps

What interviewers actually ask about this, and what a strong answer has to cover.

Explain how reduce works, and implement map or filter using only reduce.

A strong answer covers

reduce walks a list once, carrying a running accumulator, calling a step function with (accumulator, item) each time
The initial value matters — omitting it makes the first item the seed and starts iterating from the second item
map and filter can both be expressed as reduce with a specific step (map: push a transformed item; filter: conditionally push the item)

Likely follow-ups

What happens if the step function forgets to return the accumulator?
When would you mutate the accumulator versus rebuild it with a spread?
Why is reduce sometimes considered harder to read than map/filter chains, and when is it still the right choice?

Practice these with the AI interviewer →

The plain-language idea

reduce walks a list once, carrying a running result. You give it two things: a starting value, and a step that answers "given the result so far and the next item, what's the new result?"

That's it. Every loop that builds up an answer is secretly a reduce.

The logic move: shrink the problem to one step

When a problem feels big — "group these orders by month and total each" — don't solve the whole thing. Solve one step: given the tally so far and one order, where does it go? Then let reduce repeat that step across the list.

const orders = [
  { month: "Jan", amount: 40 },
  { month: "Feb", amount: 10 },
  { month: "Jan", amount: 25 },
];

const totals = orders.reduce((acc, order) => {
  acc[order.month] = (acc[order.month] ?? 0) + order.amount;
  return acc;                       // always return the running result
}, {});                             // start empty
// totals -> Jan 65, Feb 10

You never had to think about the whole list — only "one order, into the tally." That's the trick for logic that feels weak: find the single repeatable step, and let the machinery repeat it.

reduce: one running value, folded through the listStep 1 of 4

reduce walks a list once, carrying a running result — the accumulator.

What people usually miss

Watch out

Forgetting the initial value. With no second argument, the first item becomes the seed and the walk starts at item two — a common off-by-one surprise. Pass the start explicitly.
Not returning the accumulator. The step must return the new running result every time, or the next step receives undefined.
Mutating vs. rebuilding. Mutating the accumulator is fine and fast for tallies; for state you'll often rebuild with a spread instead.

Why this matters in interviews

"Implement map using reduce" is a classic. It checks whether you see that these aren't separate tricks — they're the same idea (a higher-order function walking a list) wearing different clothes.