Fold and reduce operations in Kotlin - Mini Project: Build & Apply

Fold and reduce operations

📖 Scenario: You are working with a list of daily sales amounts in a small shop. You want to find the total sales and the highest single sale using Kotlin's fold and reduce operations.

🎯 Goal: Build a Kotlin program that uses fold to calculate the total sales and reduce to find the highest sale from a list of daily sales.

📋 What You'll Learn

Create a list of daily sales amounts with exact values

Create an initial value variable for fold operation

Use fold to calculate total sales

Use reduce to find the highest sale

Print the total sales and highest sale exactly as specified

💡 Why This Matters

🌍 Real World

Calculating total sales and highest sale is common in retail and business to understand performance.

💼 Career

Knowing fold and reduce helps in data processing tasks, common in software development and data analysis roles.

1

Create the sales data list

Create a list called dailySales with these exact values: 150, 200, 50, 400, 100

Kotlin

# Create the list dailySales with the exact values
# Your code here

Hint

Use listOf to create the list with the exact numbers.

2

Create initial value for fold

Create an integer variable called initialTotal and set it to 0 to use as the starting value for the fold operation.

Kotlin

val dailySales = listOf(150, 200, 50, 400, 100)
# Create initialTotal and set it to 0
# Your code here

Hint

Just create a variable with the exact name and value.

3

Calculate total sales with fold and find highest sale with reduce

Use fold on dailySales with initialTotal to calculate the total sales and store it in totalSales. Then use reduce on dailySales to find the highest sale and store it in highestSale.

Kotlin

val dailySales = listOf(150, 200, 50, 400, 100)
val initialTotal = 0
# Use fold to calculate totalSales
# Use reduce to find highestSale
# Your code here

Hint

Use fold with an accumulator adding each sale, and reduce with a comparison to find the max.

4

Print the results

Print the total sales using println("Total sales: $totalSales") and print the highest sale using println("Highest sale: $highestSale").

Kotlin

val dailySales = listOf(150, 200, 50, 400, 100)
val initialTotal = 0
val totalSales = dailySales.fold(initialTotal) { acc, sale -> acc + sale }
val highestSale = dailySales.reduce { acc, sale -> if (sale > acc) sale else acc }
# Print totalSales and highestSale
# Your code here

Hint

Use println exactly as shown to print the results.

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