Fold and reduce operations in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this fold operation?

Consider the following Kotlin code using fold. What will be printed?

Kotlin

val numbers = listOf(1, 2, 3, 4)
val result = numbers.fold(10) { acc, num -> acc - num }
println(result)

A 14

B 0

C 4

D -10

💡 Hint

Remember that fold starts with the initial value and applies the operation from left to right.

The fold starts with 10. Then 10 - 1 = 9, 9 - 2 = 7, 7 - 3 = 4, 4 - 4 = 0. The output is 0.

❓ Predict Output

intermediate

What is the output of this reduce operation?

Look at this Kotlin code using reduce. What will it print?

Kotlin

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

A 24

B 9

C 20

D 14

💡 Hint

Reduce starts with the first element and multiplies all elements.

Reduce multiplies 2 * 3 = 6, then 6 * 4 = 24. So the output is 24.

❓ Predict Output

advanced

What error does this reduce call cause?

What happens when you run this Kotlin code?

Kotlin

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

A No output, prints 0

B Prints null

C Throws NullPointerException

D Throws UnsupportedOperationException

💡 Hint

Reduce requires at least one element in the list.

Calling reduce on an empty list throws UnsupportedOperationException because there is no initial element to start with.

❓ Predict Output

advanced

What is the output of this foldRight operation?

What will this Kotlin code print?

Kotlin

val letters = listOf("a", "b", "c")
val result = letters.foldRight("") { letter, acc -> acc + letter }
println(result)

A ""

B "abc"

C "cba"

D "cab"

💡 Hint

foldRight starts from the right end of the list.

foldRight applies the operation starting from the right: acc starts as "". Then acc + "c" = "c", then "c" + "b" = "cb", then "cb" + "a" = "cba".

🧠 Conceptual

expert

How many elements are in the resulting list after this fold?

Given this Kotlin code, how many elements does result contain?

Kotlin

val numbers = listOf(1, 2, 3)
val result = numbers.fold(mutableListOf<Int>()) { acc, num ->
    acc.add(num * 2)
    acc
}
println(result.size)

A 3

B 0

C 1

D Throws an exception

💡 Hint

fold can accumulate results in a mutable collection.

The fold starts with an empty mutable list. For each number, it adds the doubled value. After processing 3 numbers, the list has 3 elements.

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