Local functions (nested functions) in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested local function call

What is the output of this Kotlin code with a local function inside another function?

Kotlin

fun outer() {
    fun inner() {
        println("Hello from inner")
    }
    inner()
    println("Hello from outer")
}

fun main() {
    outer()
}

A Hello from inner

B

Hello from outer
Hello from inner

C Compilation error: inner function cannot be called

D

Hello from inner
Hello from outer

💡 Hint

Remember that local functions can be called inside their enclosing function.

The local function 'inner' is called first, printing its message, then the outer function prints its message.

❓ Predict Output

intermediate

Value returned by nested local function

What value does the function 'outer' return when called?

Kotlin

fun outer(): Int {
    fun inner(x: Int): Int {
        return x * 2
    }
    return inner(5) + 3
}

fun main() {
    println(outer())
}

A 13

B 10

C 8

D Compilation error: cannot return from local function

💡 Hint

Calculate inner(5) first, then add 3.

inner(5) returns 10, adding 3 gives 13.

🔧 Debug

advanced

Identify the error in nested function usage

What error does this Kotlin code produce?

Kotlin

fun outer() {
    inner()
    fun inner() {
        println("Inside inner")
    }
}

fun main() {
    outer()
}

A Compilation error: local function cannot be declared after usage

B Unresolved reference: inner

C Runtime exception: inner function not found

D No error, prints "Inside inner"

💡 Hint

Check the order of function declaration and usage.

The local function 'inner' is called before it is declared, causing an unresolved reference error.

❓ Predict Output

advanced

Effect of local function modifying outer variable

What is the output of this Kotlin code?

Kotlin

fun outer() {
    var count = 0
    fun increment() {
        count += 1
    }
    increment()
    increment()
    println(count)
}

fun main() {
    outer()
}

A 2

B 0

C 1

D Compilation error: cannot modify outer variable

💡 Hint

Local functions can access and modify variables from the outer function.

The local function increments 'count' twice, so the final value is 2.

🧠 Conceptual

expert

Scope and visibility of local functions

Which statement about local functions in Kotlin is TRUE?

A Local functions can be declared at the top level outside any function.

B Local functions can be accessed from any other function in the same file.

C Local functions can be called only inside the function where they are declared.

D Local functions can be called before their declaration anywhere in the program.

💡 Hint

Think about the visibility and scope rules of local functions.

Local functions are only visible and callable inside the function where they are declared.

Practice

1. What is a local function in Kotlin?

easy

A. A function defined outside any class

B. A function defined inside another function

C. A function that can only return integers

D. A function that must be public

Solution

1. Step 1: Understand function placement

   Local functions are defined inside other functions, not at the top level or in classes.

2. Step 2: Identify the correct definition

   A function defined inside another function correctly states that a local function is inside another function, which matches Kotlin's definition.

3. Final Answer:

   A function defined inside another function -> Option B

4. Quick Check:

   Local function = function inside function [OK]

Hint: Local functions are nested inside other functions [OK]

Common Mistakes:

• Thinking local functions are top-level
• Confusing local functions with anonymous functions
• Assuming local functions must be public

2. Which of the following is the correct syntax to declare a local function inside a Kotlin function?

easy

A. fun outer() { fun inner() { println("Hi") } }

B. fun outer() { def inner() { println("Hi") } }

C. fun outer() { function inner() { println("Hi") } }

D. fun outer() { inner() fun { println("Hi") } }

Solution

1. Step 1: Recall Kotlin function syntax

   Kotlin uses the keyword 'fun' to declare functions, including local ones.

2. Step 2: Check each option

   fun outer() { fun inner() { println("Hi") } } uses 'fun' correctly for both outer and inner functions. Others use invalid keywords or wrong order.

3. Final Answer:

   fun outer() { fun inner() { println("Hi") } } -> Option A

4. Quick Check:

   Local function syntax uses 'fun' keyword [OK]

Hint: Local functions use 'fun' keyword inside another function [OK]

Common Mistakes:

• Using 'def' or 'function' instead of 'fun'
• Placing 'fun' after the function call
• Missing braces for function body

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

fun greet() {
    val prefix = "Hello"
    fun sayName(name: String) {
        println("$prefix, $name!")
    }
    sayName("Alice")
}
fun main() {
    greet()
}

medium

A. Hello, Alice!

B. Hello Alice!

C. Error: prefix not accessible

D. No output

Solution

1. Step 1: Understand variable scope in local functions

   The local function 'sayName' can access 'prefix' from the outer function 'greet'.

2. Step 2: Trace the output of sayName("Alice")

   It prints "Hello, Alice!" exactly as formatted with the comma and exclamation mark.

3. Final Answer:

   Hello, Alice! -> Option A

4. Quick Check:

   Local function accesses outer variable = Hello, Alice! [OK]

Hint: Local functions can use outer variables directly [OK]

Common Mistakes:

• Assuming outer variables are inaccessible
• Missing punctuation in output
• Thinking code produces error

4. Identify the error in this Kotlin code snippet:

fun calculate() {
    fun add(a: Int, b: Int): Int {
        return a + b
    }
}
fun main() {
    println(add(3, 4))
}

medium

A. Missing return type for 'add'

B. Syntax error in function declaration

C. Cannot call local function 'add' from outside 'calculate'

D. No error, prints 7

Solution

1. Step 1: Understand local function visibility

   The function 'add' is local inside 'calculate' and cannot be accessed outside it.

2. Step 2: Check where 'add' is called

   'add(3, 4)' is called in 'main', outside 'calculate', causing an error.

3. Final Answer:

   Cannot call local function 'add' from outside 'calculate' -> Option C

4. Quick Check:

   Local functions are private to outer function [OK]

Hint: Local functions can't be called outside their outer function [OK]

Common Mistakes:

• Trying to call local function from outside
• Confusing local and top-level functions
• Ignoring function scope rules

5. You want to write a Kotlin function processNumbers that takes a list of integers and returns the sum of their squares. You decide to use a local function square inside it. Which of the following implementations correctly uses a local function to achieve this?

hard

A. fun processNumbers(nums: List<Int>): Int {
fun square(x: Int) = x * x
var sum = 0
for (n in nums) {
sum += n
}
return sum
}

B. fun processNumbers(nums: List<Int>): Int {
var sum = 0
for (n in nums) {
fun square(x: Int) = x * x
sum += square
}
return sum
}

C. fun processNumbers(nums: List<Int>): Int {
fun square(x: Int) = x * x
return nums.map square(it).sum()
}

D. fun processNumbers(nums: List<Int>): Int {
fun square(x: Int) = x * x
return nums.sumOf { square(it) }
}

Solution

1. Step 1: Understand local function usage and Kotlin collection functions

   Local function 'square' should be declared once inside 'processNumbers'. Using Kotlin's 'sumOf' is concise and correct.

2. Step 2: Analyze each option

   fun processNumbers(nums: List<Int>): Int { fun square(x: Int) = x * x return nums.sumOf { square(it) } } correctly declares the local function once and uses it with sumOf { square(it) }.
   fun processNumbers(nums: List<Int>): Int { var sum = 0 for (n in nums) { fun square(x: Int) = x * x sum += square } return sum } declares 'square' inside the loop but calls it without argument square(n), compile error.
   fun processNumbers(nums: List<Int>): Int { fun square(x: Int) = x * x return nums.map square(it).sum() } has syntax error: nums.map square(it).sum() missing lambda braces {}.
   fun processNumbers(nums: List<Int>): Int { fun square(x: Int) = x * x var sum = 0 for (n in nums) { sum += n } return sum } defines 'square' but uses sum += n, computes sum of numbers not squares.

3. Final Answer:

   fun processNumbers(nums: List<Int>): Int { fun square(x: Int) = x * x return nums.sumOf { square(it) } } -> Option D

4. Quick Check:

   Local function + sumOf = fun processNumbers(nums: List<Int>): Int { fun square(x: Int) = x * x return nums.sumOf { square(it) } } [OK]

Hint: Declare local function once; use sumOf for concise sum [OK]

Common Mistakes:

• Calling local function without required arguments
• Syntax error: missing braces in lambda expression
• Defining local function but forgetting to use it