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.