Higher-order function declaration in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple higher-order function call

What is the output of this Kotlin code that uses a higher-order function?

Kotlin

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

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

A Error: Missing return type

B 5

C 15

D 0

💡 Hint

Look at how the lambda multiplies the input by 3.

The function operateOnNumber takes an integer and a function that transforms an integer. The lambda multiplies 5 by 3, so the output is 15.

🧠 Conceptual

intermediate

Understanding function types in Kotlin

Which of the following is the correct Kotlin function type declaration for a function that takes a String and returns a Boolean?

A Boolean -> String

B (String) -> Boolean

C fun(String): Boolean

D String -> Boolean

💡 Hint

Function types use the arrow notation with parentheses around parameters.

In Kotlin, function types are declared as (ParameterType) -> ReturnType. So a function taking a String and returning a Boolean is (String) -> Boolean.

🔧 Debug

advanced

Identify the error in this higher-order function declaration

What error does this Kotlin code produce?

Kotlin

fun applyTwice(x: Int, f: (Int) -> Int): Int {
    return f(f(x))
}

fun main() {
    println(applyTwice(2) { it + 3 })
}

A SyntaxError: Missing parentheses around function type parameter

B TypeError: Cannot invoke function

C No error, prints 8

D RuntimeException: Null pointer

💡 Hint

Check the function type syntax in the parameter list.

The function type parameter must be declared with parentheses around the parameter type: (Int) -> Int, not Int -> Int.

❓ Predict Output

advanced

Output of nested higher-order functions

What is the output of this Kotlin code?

Kotlin

fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int {
    return { x -> f(g(x)) }
}

fun main() {
    val add2 = { x: Int -> x + 2 }
    val times3 = { x: Int -> x * 3 }
    val combined = compose(add2, times3)
    println(combined(4))
}

A 14

B 18

C 24

D 20

💡 Hint

Remember the order of function composition: f(g(x)) means g runs first.

times3(4) = 12, then add2(12) = 14, so the output is 14.

🧠 Conceptual

expert

Effect of inline keyword on higher-order functions

What is the main benefit of declaring a higher-order function as inline in Kotlin?

A It disables the use of lambdas as parameters

B It allows the function to be called asynchronously

C It automatically caches the function result

D It reduces runtime overhead by avoiding object allocation for lambdas

💡 Hint

Think about performance and how lambdas are handled at runtime.

Inlining a higher-order function copies the function body at call sites, avoiding lambda object creation and improving performance.