Why lambdas enable functional style in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin lambda expression?

Consider the following Kotlin code using a lambda. What will it print?

Kotlin

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

A [1, 4, 9, 16]

B [1, 2, 3, 4]

C [2, 4, 6, 8]

D Compilation error

💡 Hint

The map function applies the lambda to each element.

The lambda { it * 2 } doubles each number in the list, so the output is [2, 4, 6, 8].

🧠 Conceptual

intermediate

Why do lambdas support functional programming in Kotlin?

Which statement best explains why lambdas enable a functional style in Kotlin?

A Lambdas enforce mutable state for variables.

B Lambdas automatically optimize code for faster execution.

C Lambdas replace all loops with recursion.

D Lambdas allow functions to be treated as values, enabling passing and returning functions.

💡 Hint

Think about how functions can be used in functional programming.

Functional programming treats functions as first-class citizens. Lambdas let you pass functions around easily.

🔧 Debug

advanced

What error does this Kotlin code with lambda cause?

What error will this Kotlin code produce when run? val list = listOf(1, 2, 3) val result = list.filter { it > 1 } .map { it.toString() } .reduce { acc, s -> acc + s } println(result)

Kotlin

val list = listOf(1, 2, 3)
val result = list.filter { it > 1 }
    .map { it.toString() }
    .reduce { acc, s -> acc + s }
println(result)

A Compilation error: reduce requires non-empty list

B No error, prints "23"

C RuntimeException: UnsupportedOperationException

D No error, prints "223"

💡 Hint

Check what filter and map produce before reduce.

Filter keeps 2 and 3, map converts to strings "2" and "3", reduce concatenates to "23".

❓ Predict Output

advanced

What is the output of this Kotlin code using lambdas and sequences?

What will this Kotlin code print? val seq = sequenceOf(1, 2, 3, 4) val result = seq.filter { it % 2 == 0 } .map { it * it } .toList() println(result)

Kotlin

val seq = sequenceOf(1, 2, 3, 4)
val result = seq.filter { it % 2 == 0 }
    .map { it * it }
    .toList()
println(result)

A [4, 16]

B [1, 4, 9, 16]

C [2, 4]

D Compilation error: sequence operations not allowed

💡 Hint

Filter keeps even numbers, map squares them.

Filter keeps 2 and 4, map squares them to 4 and 16, so output is [4, 16].

🚀 Application

expert

How many items are in the resulting list after this Kotlin lambda chain?

Given this Kotlin code, how many items are in the final list? val data = listOf("apple", "banana", "cherry", "date") val filtered = data.filter { it.length > 5 } val mapped = filtered.map { it.uppercase() } val result = mapped.drop(1) println(result.size)

Kotlin

val data = listOf("apple", "banana", "cherry", "date")
val filtered = data.filter { it.length > 5 }
val mapped = filtered.map { it.uppercase() }
val result = mapped.drop(1)
println(result.size)

A 1

B 3

C 2

D 0

💡 Hint

Count items with length > 5, then drop the first.

Only "banana" and "cherry" have length > 5 (2 items). Dropping 1 leaves 1 item.