Why collection operations replace loops in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ query_result

intermediate

Output of collection operation replacing a loop

What is the output of this Kotlin code that uses a collection operation instead of a loop?

Kotlin

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

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

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

C [1, 4, 9, 16, 25]

D Compilation error

💡 Hint

The map function applies the given operation to each element.

The map operation creates a new list by multiplying each number by 2, replacing the need for a loop.

🧠 Conceptual

intermediate

Why use collection operations over loops?

Which of the following is the main advantage of using collection operations like map and filter instead of traditional loops?

A They make code more concise and easier to read.

B They require less memory than loops.

C They always run faster than loops.

D They allow modifying the original collection directly.

💡 Hint

Think about code clarity and simplicity.

Collection operations express intent clearly and reduce boilerplate code compared to loops.

📝 Syntax

advanced

Identify the correct Kotlin collection operation syntax

Which option correctly filters a list to keep only even numbers using a collection operation?

Kotlin

val nums = listOf(1, 2, 3, 4, 5, 6)

A nums.map { it % 2 == 0 }

B nums.forEach { it % 2 == 0 }

C nums.filter { it % 2 == 0 }

D nums.reduce { acc, i -> acc + i }

💡 Hint

Filtering keeps elements that match a condition.

filter returns a list of elements matching the condition; map transforms elements; forEach performs actions without returning a list; reduce combines elements.

❓ optimization

advanced

Optimizing collection operations to avoid intermediate lists

Which Kotlin collection operation chain avoids creating intermediate lists and processes elements lazily?

A numbers.filter { it > 5 }.map { it * 2 }

B numbers.map { it * 2 }.filter { it > 5 }

C numbers.forEach { it * 2 }.filter { it > 5 }

D numbers.asSequence().map { it * 2 }.filter { it > 5 }.toList()

💡 Hint

Sequences process elements lazily, unlike lists.

Using asSequence() creates a lazy sequence that avoids intermediate collections until toList() is called.

🔧 Debug

expert

Debugging unexpected output from collection operations

Given this Kotlin code, what is the output and why? val words = listOf("apple", "banana", "cherry") val result = words.map { it.length > 5 } println(result)

A [5, 6, 6]

B [false, true, true]

C ["apple", "banana", "cherry"]

D Compilation error

💡 Hint

map transforms each element based on the lambda expression.

The lambda checks if each word's length is greater than 5, returning a list of Booleans.