Fold and reduce operations in Kotlin - Step-by-Step Execution

Concept Flow - Fold and reduce operations

Start with collection

↓

Initialize accumulator

↓

Take next element

↓

Apply operation(accumulator, element)

↓

Update accumulator

↓

More elements?

Yes→Take next element

No↓

Return accumulator

Fold and reduce go through each item in a collection, combining them step-by-step into one result using an operation.

Execution Sample

Kotlin

val numbers = listOf(1, 2, 3)
val sumFold = numbers.fold(0) { acc, n -> acc + n }
val sumReduce = numbers.reduce { acc, n -> acc + n }

This code sums numbers using fold (starting at 0) and reduce (starting at first element).

Execution Table

Step	Operation	Accumulator Before	Current Element	Accumulator After	Notes
1	fold start	0	1	0 + 1 = 1	fold starts with initial 0
2	fold next	1	2	1 + 2 = 3	fold adds next element
3	fold next	3	3	3 + 3 = 6	fold adds next element
4	fold end	6	-	6	fold returns final accumulator
5	reduce start	1 (first element)	2	1 + 2 = 3	reduce starts with first element
6	reduce next	3	3	3 + 3 = 6	reduce adds next element
7	reduce end	6	-	6	reduce returns final accumulator

💡 All elements processed, accumulator holds final sum

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
fold accumulator	0	1	3	6	6
reduce accumulator	1	3	6	-	6

Key Moments - 3 Insights

Why does fold need an initial value but reduce does not?

Fold requires an initial accumulator (see step 1) because it starts from that value. Reduce uses the first element as the initial accumulator automatically (see step 5).

What happens if the collection is empty?

Fold returns the initial value immediately. Reduce throws an error because it has no first element to start with.

Why is the accumulator updated each step?

Each step combines the accumulator with the current element to build the final result progressively (see steps 2,3 for fold and 6 for reduce).

Visual Quiz - 3 Questions

Look at the execution table, what is the accumulator after step 2 in fold?

A 3

B 1

C 6

D 0

💡 Hint

Check the 'Accumulator After' column for fold at step 2

At which step does reduce start processing elements?

A Step 1

B Step 4

C Step 5

D Step 7

💡 Hint

Look for 'reduce start' in the Operation column

If the list was empty, what would fold return?

A Throws error

B Returns initial value

C Returns null

D Returns zero always

💡 Hint

Recall fold starts with initial value and returns it if no elements

Concept Snapshot

fold(initial, operation): starts with initial value and applies operation to each element and accumulator
reduce(operation): uses first element as initial accumulator and applies operation to rest
fold works on empty collections safely, reduce requires non-empty
Both combine collection elements step-by-step into one result

Full Transcript

Fold and reduce are ways to combine all items in a list into one value. Fold starts with a given initial value and updates it by applying an operation with each element. Reduce starts with the first element as the initial value and combines the rest. Fold can handle empty lists safely by returning the initial value. Reduce needs at least one element or it will fail. Step by step, the accumulator updates by combining with each element until all are processed, then the final result is returned.

Practice

1. What is the main difference between fold and reduce in Kotlin?

easy

A. fold starts with an initial value; reduce starts with the first list item.

B. fold only works on numbers; reduce works on any type.

C. fold modifies the original list; reduce creates a new list.

D. fold is faster than reduce in all cases.

Solution

1. Step 1: Understand fold behavior

   fold requires an initial value and then applies the operation starting from that value.

2. Step 2: Understand reduce behavior

   reduce uses the first element of the list as the initial value and then applies the operation to the rest.

3. Final Answer:

   fold starts with an initial value; reduce starts with the first list item. -> Option A

4. Quick Check:

   fold initial value vs reduce first item = C [OK]

Hint: Remember: fold needs your start, reduce uses first item [OK]

Common Mistakes:

• Thinking fold modifies the original list
• Assuming reduce needs an initial value
• Believing fold only works on numbers

2. Which of the following is the correct syntax to use fold on a list listOf(1, 2, 3) to sum all elements starting from 10?

easy

A. listOf(1, 2, 3).fold(10, (acc, item) -> acc + item)

B. listOf(1, 2, 3).fold { acc, item -> acc + item }

C. listOf(1, 2, 3).fold(10) { acc, item -> acc + item }

D. listOf(1, 2, 3).fold(10, acc + item)

Solution

1. Step 1: Check fold function signature

   fold takes an initial value and a lambda with two parameters: accumulator and current item.

2. Step 2: Match syntax with options

   listOf(1, 2, 3).fold(10) { acc, item -> acc + item } correctly uses fold(10) { acc, item -> acc + item }. Others miss initial value or have wrong lambda syntax.

3. Final Answer:

   listOf(1, 2, 3).fold(10) { acc, item -> acc + item } -> Option C

4. Quick Check:

   fold(initial) with lambda = D [OK]

Hint: fold needs initial value and lambda with two params [OK]

Common Mistakes:

• Omitting the initial value in fold
• Using incorrect lambda syntax
• Passing expression instead of lambda

3. What is the output of this Kotlin code?

val numbers = listOf(2, 3, 4)
val result = numbers.reduce { acc, item -> acc * item }
println(result)

medium

A. Error

B. 9

C. 14

D. 24

Solution

1. Step 1: Understand reduce operation

   reduce starts with first element (2) as accumulator, then multiplies by next items.

2. Step 2: Calculate step-by-step

   2 * 3 = 6, then 6 * 4 = 24.

3. Final Answer:

   24 -> Option D

4. Quick Check:

   2 * 3 * 4 = 24 [OK]

Hint: Multiply stepwise starting from first item [OK]

Common Mistakes:

• Adding instead of multiplying
• Starting from zero instead of first item
• Expecting a list output

4. Identify the error in this Kotlin code using reduce:

val emptyList = listOf<Int>()
val result = emptyList.reduce { acc, item -> acc + item }
println(result)

medium

A. Throws exception because list is empty

B. No error, output is 0

C. Syntax error in lambda

D. Returns null

Solution

1. Step 1: Check reduce behavior on empty list

   reduce requires at least one element; empty list causes runtime exception.

2. Step 2: Understand exception cause

   Since list is empty, no first element exists to start reduction, so it throws NoSuchElementException.

3. Final Answer:

   Throws exception because list is empty -> Option A

4. Quick Check:

   reduce on empty list = Exception [OK]

Hint: reduce fails on empty lists, fold needs initial value [OK]

Common Mistakes:

• Assuming reduce returns 0 on empty list
• Thinking lambda syntax is wrong
• Expecting null instead of exception

5. Given a list of strings listOf("a", "b", "c"), which Kotlin expression using fold produces the string "abc-"?

hard

A. listOf("a", "b", "c").fold("-") { acc, s -> acc + s }

B. listOf("a", "b", "c").fold("") { acc, s -> acc + s + "-" }

C. listOf("a", "b", "c").reduce { acc, s -> acc + s + "-" }

D. listOf("a", "b", "c").fold("") { acc, s -> s + acc + "-" }

Solution

1. Step 1: Understand fold with initial empty string

   Starting with empty string, each item is appended with a dash after it.

2. Step 2: Check each step of fold

   "" + "a" + "-" = "a-"; then "a-" + "b" + "-" = "a-b-"; then "a-b-" + "c" + "-" = "abc-".

3. Final Answer:

   listOf("a", "b", "c").fold("") { acc, s -> acc + s + "-" } -> Option B

4. Quick Check:

   fold with empty start and append = A [OK]

Hint: fold with empty start and add dash after each item [OK]

Common Mistakes:

• Using reduce which starts with first item, missing initial empty string
• Appending dash before instead of after
• Wrong initial value causing different output