Lazy evaluation vs eager evaluation in Kotlin - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of eager vs lazy list processing

Consider the following Kotlin code that processes a list eagerly and lazily. What is the output when running this code?

Kotlin

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val eager = numbers.map { println("Eager: $it"); it * 2 }
    val lazy = numbers.asSequence().map { println("Lazy: $it"); it * 2 }
    println("Eager result: $eager")
    println("Lazy result: ${lazy.toList()}")
}

A

Eager result: [2, 4, 6, 8]
Lazy result: [2, 4, 6, 8]
Eager: 1
Eager: 2
Eager: 3
Eager: 4
Lazy: 1
Lazy: 2
Lazy: 3
Lazy: 4

B

Eager: 1
Eager: 2
Eager: 3
Eager: 4
Eager result: [2, 4, 6, 8]
Lazy: 1
Lazy: 2
Lazy: 3
Lazy: 4
Lazy result: [2, 4, 6, 8]

C

Lazy: 1
Lazy: 2
Lazy: 3
Lazy: 4
Lazy result: [2, 4, 6, 8]
Eager: 1
Eager: 2
Eager: 3
Eager: 4
Eager result: [2, 4, 6, 8]

D

Eager: 1
Eager: 2
Eager: 3
Eager: 4
Lazy result: [2, 4, 6, 8]
Eager result: [2, 4, 6, 8]
Lazy: 1
Lazy: 2
Lazy: 3
Lazy: 4

💡 Hint

Remember that eager operations run immediately, while lazy operations run when the result is requested.

The eager map runs immediately, printing for each element before the result is printed. The lazy sequence map only runs when toList() is called, so its print statements appear just before the lazy result.

❓ Predict Output

intermediate

Effect of filtering on lazy vs eager collections

What is the output of this Kotlin code that filters a list eagerly and lazily?

Kotlin

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val eager = numbers.filter { println("Eager filter: $it"); it % 2 == 0 }
    val lazy = numbers.asSequence().filter { println("Lazy filter: $it"); it % 2 == 0 }
    println("Eager filtered: $eager")
    println("Lazy filtered: ${lazy.toList()}")
}

A

Eager filter: 1
Eager filter: 2
Eager filter: 3
Eager filter: 4
Eager filtered: [2, 4]
Lazy filter: 1
Lazy filter: 2
Lazy filter: 3
Lazy filter: 4
Lazy filtered: [2, 4]

B

Lazy filter: 1
Lazy filter: 2
Lazy filter: 3
Lazy filter: 4
Lazy filtered: [2, 4]
Eager filter: 1
Eager filter: 2
Eager filter: 3
Eager filter: 4
Eager filtered: [2, 4]

C

Eager filtered: [2, 4]
Lazy filtered: [2, 4]
Eager filter: 1
Eager filter: 2
Eager filter: 3
Eager filter: 4
Lazy filter: 1
Lazy filter: 2
Lazy filter: 3
Lazy filter: 4

D

Eager filter: 1
Eager filter: 2
Eager filter: 3
Eager filter: 4
Lazy filtered: [2, 4]
Eager filtered: [2, 4]
Lazy filter: 1
Lazy filter: 2
Lazy filter: 3
Lazy filter: 4

💡 Hint

Filtering eagerly runs the predicate immediately, lazy filtering runs it when the result is requested.

The eager filter prints for all elements before printing the filtered list. The lazy filter prints only when toList() is called, so prints appear after eager output but before lazy filtered list.

🔧 Debug

advanced

Why does this lazy sequence not print anything?

This Kotlin code uses a lazy sequence with map and filter, but nothing is printed. Why?

Kotlin

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val lazy = numbers.asSequence()
        .map { println("Mapping: $it"); it * 2 }
        .filter { println("Filtering: $it"); it > 4 }
    // No terminal operation here
}

A Because the list is empty, so map and filter have no elements to process.

B Because the println statements are inside lambdas and lambdas never run in Kotlin.

C Because the sequence operations are lazy and no terminal operation is called, so map and filter are never executed.

D Because the filter condition is false for all elements, so nothing is printed.

💡 Hint

Think about when lazy sequences actually run their operations.

Lazy sequences only run their operations when a terminal operation like toList() or forEach() is called. Without it, map and filter lambdas are not executed.

❓ Predict Output

advanced

Output of mixed eager and lazy operations

What is the output of this Kotlin code mixing eager and lazy operations?

Kotlin

fun main() {
    val numbers = listOf(1, 2, 3)
    val eager = numbers.map { println("Eager map: $it"); it + 1 }
    val lazy = numbers.asSequence().map { println("Lazy map: $it"); it + 1 }
    println("Eager sum: ${eager.sum()}")
    println("Lazy sum: ${lazy.sum()}")
}

A

Lazy map: 1
Lazy map: 2
Lazy map: 3
Lazy sum: 9
Eager map: 1
Eager map: 2
Eager map: 3
Eager sum: 9

B

Eager sum: 9
Lazy sum: 9
Eager map: 1
Eager map: 2
Eager map: 3
Lazy map: 1
Lazy map: 2
Lazy map: 3

C

Eager map: 1
Eager map: 2
Eager map: 3
Lazy sum: 9
Eager sum: 9
Lazy map: 1
Lazy map: 2
Lazy map: 3

D

Eager map: 1
Eager map: 2
Eager map: 3
Eager sum: 9
Lazy map: 1
Lazy map: 2
Lazy map: 3
Lazy sum: 9

💡 Hint

Eager map runs immediately, lazy map runs when sum() is called.

The eager map prints immediately during map call. The lazy map prints only when sum() triggers evaluation.

🧠 Conceptual

expert

Why prefer lazy evaluation in large data processing?

Which of the following is the best reason to prefer lazy evaluation over eager evaluation when processing large data sets in Kotlin?

A Lazy evaluation reduces memory usage by processing elements only when needed, avoiding creating large intermediate collections.

B Lazy evaluation always runs faster because it uses multiple threads automatically.

C Lazy evaluation guarantees that all elements are processed in parallel for better performance.

D Lazy evaluation stores all intermediate results in memory to speed up repeated access.

💡 Hint

Think about how lazy evaluation handles data compared to eager evaluation.

Lazy evaluation processes elements on demand, which saves memory by not creating large intermediate collections. It does not automatically use multiple threads or parallelism.