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].

Practice

1. What is the main advantage of using a Sequence over a Collection in Kotlin when working with large datasets?

easy

A. Sequences process data lazily, saving memory and improving performance.

B. Sequences store all data in memory for faster access.

C. Sequences automatically sort data for you.

D. Sequences are easier to write than collections.

Solution

1. Step 1: Understand how sequences process data

   Sequences process elements one by one only when needed, which is called lazy processing.

2. Step 2: Compare with collections

   Collections hold all elements in memory and process them eagerly, which can use more memory for large data.

3. Final Answer:

   Sequences process data lazily, saving memory and improving performance. -> Option A

4. Quick Check:

   Lazy processing = better for large data [OK]

Hint: Remember: sequences delay work, collections do it all at once [OK]

Common Mistakes:

• Thinking sequences store all data in memory
• Confusing lazy processing with sorting
• Assuming sequences are always simpler to write

2. Which of the following Kotlin code snippets correctly creates a sequence from a list?

easy

A. val seq = listOf(1, 2, 3).toSequence()

B. val seq = sequenceOf(listOf(1, 2, 3))

C. val seq = listOf(1, 2, 3).asSequence()

D. val seq = Sequence(listOf(1, 2, 3))

Solution

1. Step 1: Identify correct method to convert list to sequence

   The method asSequence() converts a collection to a sequence lazily.

2. Step 2: Check other options for correctness

   sequenceOf() creates a sequence from given elements, not a list; toSequence() and Sequence() constructor do not exist.

3. Final Answer:

   val seq = listOf(1, 2, 3).asSequence() -> Option C

4. Quick Check:

   Use asSequence() to convert collections [OK]

Hint: Use asSequence() to convert collections to sequences [OK]

Common Mistakes:

• Using non-existent toSequence() method
• Confusing sequenceOf() with asSequence()
• Trying to call Sequence() constructor directly

3. Consider the following Kotlin code:

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

What is the output?

medium

A. [12, 14, 16]

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

C. [1, 2, 3, 4, 5]

D. [6, 8, 10]

Solution

1. Step 1: Apply map transformation

   Numbers 1 to 5 are doubled: [2, 4, 6, 8, 10].

2. Step 2: Apply filter condition

   Keep only numbers greater than 5: [6, 8, 10].

3. Final Answer:

   [6, 8, 10] -> Option D

4. Quick Check:

   Map then filter = [6, 8, 10] [OK]

Hint: Map first, then filter to get final list [OK]

Common Mistakes:

• Filtering before mapping
• Forgetting to convert sequence to list
• Assuming original range is unchanged

4. What is wrong with this Kotlin code snippet?

val list = listOf(1, 2, 3, 4, 5)
val seq = list.asSequence()
val result = seq.map { it * 2 }
println(result)

medium

A. The map function does not exist for sequences.

B. The map operation is not executed because sequences are lazy.

C. The println statement causes a syntax error.

D. You cannot convert a list to a sequence using asSequence().

Solution

1. Step 1: Understand sequence laziness

   Sequences process operations lazily, so map returns a sequence but does not execute immediately.

2. Step 2: Check what is printed

   Printing result prints the sequence object, not the transformed data, because no terminal operation like toList() was called.

3. Final Answer:

   The map operation is not executed because sequences are lazy. -> Option B

4. Quick Check:

   Sequences need terminal operation to execute [OK]

Hint: Call toList() or similar to execute sequence operations [OK]

Common Mistakes:

• Expecting immediate execution of map on sequences
• Thinking asSequence() is invalid
• Assuming println shows transformed data

5. You have a large database query result as a Kotlin list of 1 million records. You want to filter records where age > 30, then map to names, and finally collect the first 10 names. Which approach is best for performance?

hard

A. Use a sequence: convert list to sequence, filter, map, then take(10) and toList().

B. Use a collection: filter, map on the list, then take first 10 elements.

C. Convert list to array, then filter and map using loops.

D. Sort the list first, then filter and map.

Solution

1. Step 1: Consider data size and operations

   With 1 million records, processing eagerly wastes memory and time.

2. Step 2: Use sequence for lazy processing

   Sequence processes elements one by one, stops after taking 10, saving resources.

3. Step 3: Compare other options

   Collections process all data eagerly; arrays and sorting add unnecessary overhead.

4. Final Answer:

   Use a sequence: convert list to sequence, filter, map, then take(10) and toList(). -> Option A

5. Quick Check:

   Lazy sequence + take(10) = best for large data [OK]

Hint: Use sequences with take() to limit processing early [OK]

Common Mistakes:

• Processing entire list eagerly wasting memory
• Sorting unnecessarily before filtering
• Using arrays without lazy evaluation