Local functions (nested functions) in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a local function inside main.

Kotlin

fun main() {
    fun [1]() {
        println("Hello from local function")
    }
    greet()
}

Drag options to blanks, or click blank then click option'

Agreet

Bhello

CsayHello

DlocalFunc

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different function name than the one called.

Defining the function outside main.

The local function is called greet and is called inside main.

2fill in blank

medium

Complete the code to call the local function inside main.

Kotlin

fun main() {
    fun greet() {
        println("Hi there!")
    }
    [1]()
}

Drag options to blanks, or click blank then click option'

Agreet

Bhello

CsayHello

DlocalFunc

Attempts:

3 left

💡 Hint

Common Mistakes

Calling a function name that is not defined.

Forgetting the parentheses to call the function.

The local function greet is called inside main to print the message.

3fill in blank

hard

Fix the error by completing the code to return the sum using a local function.

Kotlin

fun sumNumbers(a: Int, b: Int): Int {
    fun add() = a [1] b
    return add()
}

Drag options to blanks, or click blank then click option'

A/

B-

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

Forgetting to return the result of the local function.

The local function add returns the sum of a and b using the + operator.

4fill in blank

hard

Fill both blanks to create a local function that checks if a number is even.

Kotlin

fun main() {
    fun [1](num: Int): Boolean {
        return num [2] 2 == 0
    }
    println(isEven(4))
}

Drag options to blanks, or click blank then click option'

AisEven

B%

C/

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using division / instead of modulus %.

Naming the function something unrelated.

The local function isEven checks if the number divided by 2 leaves a remainder of 0 using the modulus operator %.

5fill in blank

hard

Fill all three blanks to create a local function that filters and returns words longer than 3 letters.

Kotlin

fun main() {
    val words = listOf("cat", "house", "dog", "elephant")
    fun filterLongWords(list: List<String>): List<String> {
        return list.filter { word -> word.[1] > [2] }
    }
    val result = filterLongWords(words)
    println(result) // Should print words longer than [3] letters
}

Drag options to blanks, or click blank then click option'

Alength

B3

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using word.size which is not valid for strings.

Using the wrong number for comparison.

Confusing length with size.

The local function uses word.length to get the length of each word and filters those longer than 3 letters.

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