Fold and reduce operations in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the fold function do in Kotlin?

The fold function starts with an initial value and combines it with elements of a collection one by one using a given operation, producing a single result.

beginner

How is reduce different from fold in Kotlin?

reduce does not take an initial value; it uses the first element of the collection as the starting point and combines the rest. fold requires an explicit initial value.

intermediate

What happens if you call reduce on an empty list in Kotlin?

Calling reduce on an empty list throws a NoSuchElementException because there is no first element to start the operation.

beginner

Explain the role of the lambda function in fold and reduce.

The lambda function defines how to combine the current accumulated value with the next element. It takes two parameters: the accumulator and the current element, and returns the new accumulator.

beginner

Give a simple example of using fold to sum a list of numbers starting from 10.

Example:
val numbers = listOf(1, 2, 3)
val sum = numbers.fold(10) { acc, num -> acc + num }
This results in sum = 16 because 10 + 1 + 2 + 3 = 16.

What initial value does reduce use when combining elements?

A Null

B Zero

C The first element of the collection

D An explicit initial value provided by the user

reduce uses the first element of the collection as the starting point.

Which function requires an explicit initial value: fold or reduce?

A fold

B reduce

C Both

D Neither

fold requires an initial value; reduce does not.

What exception is thrown if reduce is called on an empty list?

A NullPointerException

B IndexOutOfBoundsException

C IllegalArgumentException

D NoSuchElementException

Calling reduce on an empty list throws NoSuchElementException.

In the lambda for fold, what do the two parameters represent?

A The index and the element

B The accumulator and the current element

C The collection and the element

D The previous element and the next element

The lambda takes the accumulator (current result) and the current element to produce a new accumulator.

What will be the result of listOf(2, 3, 4).fold(1) { acc, n -> acc * n }?

A 24

B 10

C 9

D 1

The calculation is 1 * 2 * 3 * 4 = 24.

Describe how fold and reduce work in Kotlin and when you might use each.

Think about starting points and empty lists.

Write a Kotlin example using reduce to find the maximum number in a list.

Use maxOf or comparison inside lambda.

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