Why sequences matter for performance in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of eager vs lazy collection processing

Consider the following Kotlin code that processes a list of numbers. What will be the output?

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)

val eagerResult = numbers
    .map { println("Mapping $it"); it * 2 }
    .filter { println("Filtering $it"); it > 5 }

val lazyResult = numbers.asSequence()
    .map { println("Mapping $it"); it * 2 }
    .filter { println("Filtering $it"); it > 5 }
    .toList()

println("Eager result size: ${eagerResult.size}")
println("Lazy result size: ${lazyResult.size}")

A

Mapping 1
Filtering 2
Mapping 2
Filtering 4
Mapping 3
Filtering 6
Mapping 4
Filtering 8
Mapping 5
Filtering 10
Eager result size: 3
Mapping 1
Filtering 2
Mapping 2
Filtering 4
Mapping 3
Filtering 6
Mapping 4
Filtering 8
Mapping 5
Filtering 10
Lazy result size: 3

B

Mapping 1
Mapping 2
Mapping 3
Mapping 4
Mapping 5
Filtering 2
Filtering 4
Filtering 6
Filtering 8
Filtering 10
Eager result size: 3
Mapping 1
Mapping 2
Mapping 3
Mapping 4
Mapping 5
Filtering 2
Filtering 4
Filtering 6
Filtering 8
Filtering 10
Lazy result size: 3

C

Mapping 1
Mapping 2
Mapping 3
Mapping 4
Mapping 5
Filtering 2
Filtering 4
Filtering 6
Filtering 8
Filtering 10
Eager result size: 3
Mapping 1
Filtering 2
Mapping 2
Filtering 4
Mapping 3
Filtering 6
Mapping 4
Filtering 8
Mapping 5
Filtering 10
Lazy result size: 3

D

Mapping 1
Filtering 2
Mapping 2
Filtering 4
Mapping 3
Filtering 6
Mapping 4
Filtering 8
Mapping 5
Filtering 10
Eager result size: 3
Mapping 1
Mapping 2
Mapping 3
Mapping 4
Mapping 5
Filtering 2
Filtering 4
Filtering 6
Filtering 8
Filtering 10
Lazy result size: 3

💡 Hint

Think about when the map and filter functions run in eager vs lazy collections.

In eager processing, map runs on all items first, then filter runs on all mapped items. In lazy processing with sequences, map and filter run together per item, so you see interleaved prints.

🧠 Conceptual

intermediate

Why use sequences for large data?

Why are Kotlin sequences better for processing large collections compared to regular lists?

A Sequences process elements lazily, avoiding creating intermediate collections and saving memory.

B Sequences automatically parallelize operations to speed up processing.

C Sequences store all elements in memory to speed up repeated access.

D Sequences convert collections to arrays internally for faster access.

💡 Hint

Think about how sequences handle each element compared to lists.

Sequences process elements one by one and only when needed, so they don't create extra collections during chained operations. This saves memory and can improve performance on large data.

🔧 Debug

advanced

Identify the performance issue

Look at this Kotlin code snippet. It processes a large list but runs slowly. What is the main cause?

Kotlin

val largeList = (1..1_000_000).toList()

val result = largeList
    .map { it * 2 }
    .filter { it % 3 == 0 }
    .take(5)

println(result)

A The code creates intermediate lists for map and filter, causing high memory use and slow processing.

B The take(5) is applied too early, so it processes only 5 elements.

C The map operation is missing a return statement causing a runtime error.

D The filter condition is incorrect and filters out all elements.

💡 Hint

Think about how map and filter work on lists versus sequences.

Using map and filter on lists creates new lists at each step, which is expensive for large data. Using sequences would avoid this by processing elements lazily.

📝 Syntax

advanced

Correct sequence usage syntax

Which Kotlin code snippet correctly converts a list to a sequence, filters even numbers, maps them to strings, and collects the result as a list?

A val result = list.asSequence().map { it.toString() }.filter { it % 2 == 0 }.toList()

B val result = list.asSequence().filter { it % 2 == 0 }.map { it.toString() }.toList()

C val result = list.filter { it % 2 == 0 }.asSequence().map { it.toString() }.toList()

D val result = list.toList().asSequence().filter { it % 2 == 0 }.map { it.toString() }

💡 Hint

Remember the order of operations and that filter must be applied before map for correct filtering.

Option B correctly converts the list to a sequence first, then filters even numbers, maps them to strings, and finally collects to a list. Other options either apply filter after map or miss collecting to a list.

🚀 Application

expert

Optimize chained operations on large data

You have a large list of integers. You want to find the first 10 numbers that are multiples of 7 after doubling each number. Which Kotlin code snippet is the most efficient?

A val result = largeList.asSequence().filter { it % 7 == 0 }.map { it * 2 }.take(10).toList()

B val result = largeList.map { it * 2 }.filter { it % 7 == 0 }.take(10)

C val result = largeList.filter { it % 7 == 0 }.map { it * 2 }.take(10).toList()

D val result = largeList.asSequence().map { it * 2 }.filter { it % 7 == 0 }.take(10).toList()

💡 Hint

Consider lazy evaluation and the order of map and filter for efficiency.

Option D uses sequences to process lazily, doubling first then filtering multiples of 7, and stops after finding 10 results. This avoids processing the entire list. Option D creates intermediate lists and does not collect to a list. Option D filters before doubling, which changes the logic. Option D filters before doubling, which is incorrect for the requirement.

Practice

1. What is the main advantage of using Sequence in Kotlin compared to a regular List?

easy

A. It processes elements lazily, improving performance with large data.

B. It stores elements in a database automatically.

C. It converts all elements to strings immediately.

D. It requires less code to create than a list.

Solution

1. Step 1: Understand how sequences process data

   Sequences process elements one by one only when needed, not all at once.

2. Step 2: Compare with lists

   Lists process all elements eagerly, which can be slower and use more memory for large data.

3. Final Answer:

   It processes elements lazily, improving performance with large data. -> Option A

4. Quick Check:

   Lazy processing = better performance [OK]

Hint: Sequences process lazily, lists process eagerly [OK]

Common Mistakes:

• Thinking sequences store data in a database
• Confusing lazy processing with immediate conversion
• Assuming sequences need less code to create

2. Which of the following is the correct way to create a sequence from a list in Kotlin?

easy

A. val seq = list.toSequence()

B. val seq = list.asSequence()

C. val seq = Sequence(list)

D. val seq = list.sequence()

Solution

1. Step 1: Recall Kotlin sequence creation syntax

   The standard way to create a sequence from a list is using asSequence().

2. Step 2: Check each option

   val seq = list.asSequence() uses list.asSequence(), which is correct. Others are invalid or do not exist.

3. Final Answer:

   val seq = list.asSequence() -> Option B

4. Quick Check:

   Use asSequence() to convert list to sequence [OK]

Hint: Use asSequence() to convert list to sequence [OK]

Common Mistakes:

• Using toSequence() which does not exist
• Trying to call sequence() on list
• Trying to instantiate Sequence directly

3. What will be the output of this Kotlin code?

val list = listOf(1, 2, 3, 4, 5)
val result = list.asSequence()
    .map { println("Mapping $it"); it * 2 }
    .filter { println("Filtering $it"); it > 5 }
    .toList()
println(result)

medium

A. Mapping and filtering printed step-by-step, then [6, 8, 10]

B. No output except [6, 8, 10]

C. [6, 8, 10] with all mapping and filtering printed before the list

D. Compilation error due to println inside lambda

Solution

1. Step 1: Understand lazy evaluation of sequences

   Sequences process elements one by one, so map and filter print statements happen step-by-step per element.

2. Step 2: Trace the output

   For each element, "Mapping" prints, then "Filtering" prints, then next element. Finally, the filtered list [6, 8, 10] prints.

3. Final Answer:

   Mapping and filtering printed step-by-step, then [6, 8, 10] -> Option A

4. Quick Check:

   Lazy = step-by-step prints [OK]

Hint: Sequences print lazily per element, not all at once [OK]

Common Mistakes:

• Assuming all map prints happen before filter prints
• Expecting no prints due to lazy evaluation
• Thinking println causes compile error

4. Identify the problem in this Kotlin code that tries to improve performance using sequences:

val numbers = (1..5).toList()
val doubled = numbers.map { it * 2 }
val filtered = doubled.asSequence().filter { it > 5 }.toList()
println(filtered)

medium

A. toList() is missing after map, causing error.

B. Filter is applied before map, causing wrong results.

C. Sequence is created after map, so map is eager and wastes memory.

D. Sequence cannot be created from a list.

Solution

1. Step 1: Analyze the order of operations

   Mapping happens first on the list eagerly, then sequence is created only for filtering.

2. Step 2: Understand performance impact

   Because map is eager, it processes all elements immediately, losing sequence benefits.

3. Final Answer:

   Sequence is created after map, so map is eager and wastes memory. -> Option C

4. Quick Check:

   Sequence after map loses lazy benefits [OK]

Hint: Create sequence before map to keep lazy processing [OK]

Common Mistakes:

• Thinking filter order is wrong
• Expecting error due to missing toList() after map
• Believing sequence can't be made from list

5. You have a large list of numbers and want to find the sum of squares of even numbers greater than 10. Which Kotlin code snippet uses sequences best for performance?

hard

A. val sum = numbers.filter { it > 10 }
.filter { it % 2 == 0 }
.map { it * it }
.sum()

B. val sum = numbers.asSequence()
.map { it * it }
.filter { it > 10 && it % 2 == 0 }
.sum()

C. val sum = numbers.map { it * it }
.filter { it > 10 && it % 2 == 0 }
.sum()

D. val sum = numbers.asSequence()
.filter { it > 10 }
.filter { it % 2 == 0 }
.map { it * it }
.sum()

Solution

1. Step 1: Identify the correct order for filtering and mapping

   Filter first for numbers > 10 and even, then map to square to avoid unnecessary calculations.

2. Step 2: Use sequence to process lazily

   Using asSequence() before filters and map ensures lazy evaluation and better performance on large lists.

3. Final Answer:

   val sum = numbers.asSequence() .filter { it > 10 } .filter { it % 2 == 0 } .map { it * it } .sum() -> Option D

4. Quick Check:

   Sequence + filter before map = best performance [OK]

Hint: Filter before map, use sequence for lazy processing [OK]

Common Mistakes:

• Mapping before filtering wastes work
• Not using sequence loses lazy benefits
• Combining filters incorrectly after map