Passing lambdas to functions in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a lambda passed to a function

What is the output of this Kotlin code when the lambda is passed to the function?

Kotlin

fun operateOnNumber(x: Int, operation: (Int) -> Int): Int {
    return operation(x)
}

fun main() {
    val result = operateOnNumber(5) { it * 3 }
    println(result)
}

A 8

B 15

C Compilation error

D 5

💡 Hint

Remember that the lambda multiplies the input by 3.

The function operateOnNumber takes an integer and a lambda that multiplies the integer by 3. Passing 5 results in 5 * 3 = 15.

❓ Predict Output

intermediate

Lambda with multiple parameters

What will be printed by this Kotlin program?

Kotlin

fun combineStrings(a: String, b: String, combiner: (String, String) -> String): String {
    return combiner(a, b)
}

fun main() {
    val result = combineStrings("Hello", "World") { x, y -> "$x $y!" }
    println(result)
}

A Hello World!

B HelloWorld!

C Hello World

D Compilation error

💡 Hint

Look at how the lambda formats the strings with a space and exclamation mark.

The lambda combines the two strings with a space and adds an exclamation mark, resulting in "Hello World!".

🔧 Debug

advanced

Identify the error when passing a lambda

This Kotlin code does not compile. What is the cause of the error?

Kotlin

fun applyOperation(x: Int, operation: (Int) -> Int): Int {
    return operation(x)
}

fun main() {
    val result = applyOperation(10) { it + 5 }
    println(result)
}

A Type mismatch: lambda parameter type should be (Int) -> Int

B Syntax error: missing parentheses around lambda parameter type

C Runtime exception: null pointer

D No error, code compiles and runs

💡 Hint

Check the function parameter type declaration syntax for lambdas.

The parameter type for the lambda must be declared as (Int) -> Int, not Int -> Int. The missing parentheses cause a type mismatch error.

❓ Predict Output

advanced

Lambda capturing external variable

What is the output of this Kotlin code?

Kotlin

fun main() {
    var counter = 0
    val increment: () -> Int = { counter += 1; counter }
    println(increment())
    println(increment())
    println(counter)
}

A Compilation error

B

0
1
2

C

1
1
1

D

1
2
2

💡 Hint

The lambda modifies the external variable counter each time it is called.

Each call to increment increases counter by 1 and returns the new value. So first call returns 1, second returns 2, and counter is 2 at the end.

🧠 Conceptual

expert

Effect of inline lambdas on performance

Which statement about inline lambdas in Kotlin is true?

A Inline lambdas cannot capture variables from the outer scope.

B Inlining lambdas always increases the size of the compiled code without any performance benefit.

C Inlining lambdas reduces runtime overhead by avoiding object allocation and call overhead.

D Inlining lambdas disables the use of return statements inside the lambda.

💡 Hint

Think about how inlining affects function calls and memory allocation.

Inlining lambdas replaces the lambda call with the lambda body, avoiding creating function objects and call overhead, improving performance.

Practice

1. What is a lambda in Kotlin when passed to a function?

easy

A. A small block of code that can be passed and executed inside the function

B. A type of variable that stores numbers

C. A special kind of loop

D. A keyword to declare a class

Solution

1. Step 1: Understand what a lambda is

   A lambda is a small piece of code that you can write inline and pass around like a value.

2. Step 2: Recognize its use in functions

   Functions can accept lambdas to customize behavior without changing the function code.

3. Final Answer:

   A small block of code that can be passed and executed inside the function -> Option A

4. Quick Check:

   Lambda = small code block passed to function [OK]

Hint: Lambdas are code blocks you pass to functions [OK]

Common Mistakes:

• Thinking lambda is a variable type
• Confusing lambda with loops
• Believing lambda is a keyword for classes

2. Which of the following is the correct syntax to pass a lambda to a function in Kotlin?

easy

A. fun greet(action: Unit -> ()) { action() } greet { println("Hi") }

B. fun greet(action: () -> Unit) { action() } greet { println("Hi") }

C. fun greet(action: () -> Unit) { action } greet { println("Hi") }

D. fun greet(action: () -> Unit) { action() } greet(println("Hi"))

Solution

1. Step 1: Check function parameter type

   The function expects a lambda with no parameters and no return value: () -> Unit.

2. Step 2: Check how lambda is called and passed

   Inside the function, calling action() executes the lambda. Passing greet { println("Hi") } is correct syntax.

3. Final Answer:

   fun greet(action: () -> Unit) { action() } greet { println("Hi") } -> Option B

4. Quick Check:

   Correct lambda syntax = fun greet(action: () -> Unit) { action() } greet { println("Hi") } [OK]

Hint: Use () -> Unit and call lambda with () inside function [OK]

Common Mistakes:

• Wrong lambda type syntax
• Forgetting to call lambda with ()
• Passing lambda as function argument incorrectly

3. What will be the output of this Kotlin code?

fun operate(x: Int, action: (Int) -> Int): Int {
    return action(x)
}

fun main() {
    val result = operate(5) { it * 2 }
    println(result)
}

medium

A. 5

B. 25

C. 10

D. Compilation error

Solution

1. Step 1: Understand the operate function

   It takes an integer and a lambda that doubles the integer (it * 2).

2. Step 2: Calculate the result

   Passing 5 to the lambda doubles it to 10, which is returned and printed.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   5 * 2 = 10 [OK]

Hint: Trace lambda input and output carefully [OK]

Common Mistakes:

• Confusing input and output values
• Forgetting lambda parameter 'it'
• Assuming no return from lambda

4. Identify the error in this Kotlin code snippet:

fun applyOperation(x: Int, op: (Int) -> Int) {
    op(x)
}

fun main() {
    applyOperation(3) { println(it * 3) }
}

medium

A. No error, code runs fine

B. The function applyOperation should return Int but returns Unit

C. The lambda syntax is incorrect

D. The lambda passed does not return a value but function expects Int return

Solution

1. Step 1: Check function signature and lambda

   applyOperation expects a lambda returning Int, but the lambda only prints and returns Unit.

2. Step 2: Understand mismatch consequences

   Because the lambda returns Unit, but function expects Int, this causes a type mismatch error.

3. Final Answer:

   The lambda passed does not return a value but function expects Int return -> Option D

4. Quick Check:

   Lambda return type mismatch = The lambda passed does not return a value but function expects Int return [OK]

Hint: Match lambda return type with function parameter type [OK]

Common Mistakes:

• Ignoring return type mismatch
• Thinking println returns Int
• Assuming no return needed for lambdas

5. You want to write a Kotlin function filterAndTransform that takes a list of integers and two lambdas: one to filter the list and one to transform each filtered item. Which of these function signatures correctly allows passing both lambdas?

hard

A. fun filterAndTransform(list: List<Int>, filter: (Int) -> Boolean, transform: (Int) -> Int): List<Int>

B. fun filterAndTransform(list: List<Int>, filter: Int, transform: Int): List<Int>

C. fun filterAndTransform(list: List<Int>, filter: (Int) -> Int, transform: (Int) -> Boolean): List<Int>

D. fun filterAndTransform(list: List<Int>, filter: () -> Boolean, transform: () -> Int): List<Int>

Solution

1. Step 1: Identify correct lambda types for filtering and transforming

   Filtering needs a lambda that takes Int and returns Boolean; transforming needs a lambda that takes Int and returns Int.

2. Step 2: Match function signature with these lambda types

   fun filterAndTransform(list: List<Int>, filter: (Int) -> Boolean, transform: (Int) -> Int): List<Int> matches these types correctly; others have wrong parameter or return types.

3. Final Answer:

   fun filterAndTransform(list: List<Int>, filter: (Int) -> Boolean, transform: (Int) -> Int): List<Int> -> Option A

4. Quick Check:

   Filter returns Boolean, transform returns Int [OK]

Hint: Filter lambda returns Boolean, transform lambda returns transformed value [OK]

Common Mistakes:

• Using wrong lambda parameter or return types
• Confusing filter and transform lambda roles
• Using lambdas with no parameters