Sequence vs collection performance in Kotlin - Practice Questions

Challenge - 5 Problems

❓ query_result

intermediate

Performance difference between Sequence and Collection in Kotlin

Consider the following Kotlin code that processes a list of numbers. What is the output of the code snippet below?

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers.asSequence()
    .map { it * 2 }
    .filter { it > 5 }
    .toList()
println(result)

A [1, 2, 3, 4, 5]

B [2, 4, 6, 8, 10]

C [6, 8, 10]

D []

💡 Hint

Remember that asSequence() processes elements lazily and filters after mapping.

The sequence maps each number by multiplying by 2, then filters those greater than 5. So 6, 8, and 10 remain.

🧠 Conceptual

intermediate

Why use Sequence over Collection in Kotlin?

Which of the following best explains why you might choose a Sequence over a Collection in Kotlin?

A Sequence processes elements lazily, which can improve performance for large data sets by avoiding intermediate collections.

B Sequence stores all elements in memory, making it faster for small data sets.

C Sequence automatically sorts elements, unlike Collection.

D Sequence is mutable while Collection is immutable.

💡 Hint

Think about how data is processed step-by-step in sequences.

Sequences process elements lazily, meaning operations are done one by one without creating intermediate collections, which saves memory and can improve performance on large data.

📝 Syntax

advanced

Identify the syntax error in sequence usage

Which option contains a syntax error when trying to create a sequence and filter elements greater than 10?

Kotlin

val seq = listOf(5, 10, 15, 20).asSequence()
val filtered = seq.filter { it > 10 }
println(filtered.toList())

A val filtered = seq.filter { it -> it > 10 }

B val filtered = seq.filter { it > 10 }

C val filtered = seq.filter { x -> x > 10 }

D val filtered = seq.filter(it > 10)

💡 Hint

Check the syntax of lambda expressions in Kotlin.

Option D is missing the lambda braces and parameter declaration, causing a syntax error.

❓ optimization

advanced

Optimizing chained operations with Sequence

You want to optimize the following Kotlin code for performance on a large list. Which option best improves performance?

val result = numbers
    .map { it * 2 }
    .filter { it > 10 }
    .take(5)
    .toList()

A Replace <code>map</code> with <code>forEach</code> to avoid creating a new list.

B Use <code>numbers.asSequence()</code> before chaining operations to process lazily.

C Call <code>toList()</code> after <code>map</code> and before <code>filter</code>.

D Use <code>numbers.parallelStream()</code> to process in parallel.

💡 Hint

Think about how lazy evaluation can reduce work done.

Using asSequence() makes the operations lazy, so only necessary elements are processed, improving performance especially with take(5).

🔧 Debug

expert

Debugging unexpected output with Sequence and Collection

Given the code below, what is the output and why?

val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers.map { it * 2 }.filter { it > 5 }
println(result)

A [6, 8, 10] because map and filter are applied eagerly on the list.

B [2, 4, 6, 8, 10] because filter is ignored without sequence.

C [] because filter removes all elements less than or equal to 5 before map.

D Compilation error because map and filter cannot be chained on List.

💡 Hint

Consider the order and eager evaluation of collection operations.

map is applied first, doubling each number, then filter removes those not greater than 5, resulting in [6, 8, 10].