With function behavior and use cases in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using with function?

Consider the following Kotlin code snippet using the with function. What will be printed when this code runs?

Kotlin

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("Alice", 30)
    val result = with(person) {
        age += 1
        "${name} is now $age years old"
    }
    println(result)
}

A Compilation error due to string interpolation

B Alice is now 30 years old

C Alice is now 31 years old

D Runtime error: Unresolved reference

💡 Hint

Remember that with allows you to access the object's members directly and the last expression is returned.

The with function takes person as its receiver. Inside the block, age is incremented by 1, so it becomes 31. The last expression is a string that uses the updated age and name. This string is returned and printed.

🧠 Conceptual

intermediate

What is the main difference between with and apply in Kotlin?

Choose the option that correctly describes the key difference between with and apply functions in Kotlin.

A <code>with</code> returns the lambda result, <code>apply</code> returns the receiver object

B <code>with</code> returns the receiver object, <code>apply</code> returns the lambda result

C Both <code>with</code> and <code>apply</code> return the receiver object

D Both <code>with</code> and <code>apply</code> return the lambda result

💡 Hint

Think about what each function returns after executing the block.

with executes the block with the receiver as context and returns the last expression of the block (lambda result). apply executes the block with the receiver as context but returns the receiver object itself.

🔧 Debug

advanced

Why does this Kotlin code using with function cause a compilation error?

Examine the code below. It tries to use with on a nullable String. Why does it fail to compile?

Kotlin

fun main() {
    val text: String? = null
    with(text) {
        println(length)
    }
}

A The println statement has a syntax error

B Cannot call with on a nullable receiver without safe call operator

C The length property does not exist on String

D with requires a lambda with receiver, but none is provided

💡 Hint

Consider how Kotlin handles nullable types and scope functions.

The variable text is nullable. Calling with(text) without a safe call operator ?. causes a compilation error because with expects a non-null receiver. You must use text?.let { with(it) { ... } } or check for null before calling with.

❓ Predict Output

advanced

What is the output of this Kotlin code using nested with functions?

Analyze the following Kotlin code with nested with calls. What will it print?

Kotlin

data class Address(var city: String, var zip: String)

data class User(var name: String, var address: Address)

fun main() {
    val user = User("Bob", Address("NYC", "10001"))
    val result = with(user) {
        with(address) {
            "${[e-mail]} lives in $city with zip $zip"
        }
    }
    println(result)
}

A Runtime error: Unresolved reference to name

B Compilation error due to nested with

C Bob lives in with zip 10001

D Bob lives in NYC with zip 10001

💡 Hint

Remember that nested with blocks can access outer variables if referenced properly.

The outer with(user) sets the context to user. Inside, the inner with(address) sets the context to address. The string uses name from the outer scope and city, zip from the inner scope. This prints the full sentence correctly.

🧠 Conceptual

expert

Which statement about Kotlin's with function is TRUE?

Select the correct statement about the behavior and use cases of Kotlin's with function.

A <code>with</code> can be used to execute multiple operations on an object and returns the last expression result, but it is not an extension function.

B <code>with</code> is an extension function on any object and returns the object itself after executing the block.

C <code>with</code> requires the receiver object to be nullable and safely unwraps it inside the block.

D <code>with</code> is used to create new objects and always returns a new instance.

💡 Hint

Think about the signature and return type of with.

with is a regular function (not an extension) that takes the receiver object as an argument and executes the block with that receiver as context. It returns the last expression of the block, not the receiver object. It does not require the receiver to be nullable and does not create new objects.

Practice

1. What is the main purpose of the with function in Kotlin?

easy

A. To define a new class inside a function

B. To create a new thread for concurrent execution

C. To execute multiple operations on the same object without repeating its name

D. To handle exceptions in a concise way

Solution

1. Step 1: Understand the role of with

   The with function groups multiple calls on the same object, so you don't repeat the object name.

2. Step 2: Compare with other options

   Options A, B, and D describe unrelated Kotlin features like class definition, threading, and exception handling.

3. Final Answer:

   To execute multiple operations on the same object without repeating its name -> Option C

4. Quick Check:

   with groups calls on one object = C [OK]

Hint: Remember: with avoids repeating object name [OK]

Common Mistakes:

• Confusing with with threading or concurrency
• Thinking with creates new classes
• Assuming with handles exceptions

2. Which of the following is the correct syntax to use with in Kotlin?

easy

A. with(object) { /* code block */ }

B. with { object -> /* code block */ }

C. with object { /* code block */ }

D. with(object) -> { /* code block */ }

Solution

1. Step 1: Recall the syntax of with

   The correct syntax is with(object) { /* code block */ }, where the object is passed as an argument and the block follows in braces.

2. Step 2: Identify incorrect syntax

   Options B, C, and D misuse arrow notation or omit parentheses, which are syntax errors.

3. Final Answer:

   with(object) { /* code block */ } -> Option A

4. Quick Check:

   Correct with syntax uses parentheses and braces = A [OK]

Hint: Use parentheses for object, braces for block in with [OK]

Common Mistakes:

• Omitting parentheses around the object
• Using arrow notation incorrectly
• Placing the block outside braces

3. What is the output of the following Kotlin code?

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("Alice", 25)
    val result = with(person) {
        age += 1
        "${name} is now $age years old"
    }
    println(result)
}

medium

A. Alice is now 25 years old

B. Runtime error due to modifying age

C. Compilation error due to string interpolation

D. Alice is now 26 years old

Solution

1. Step 1: Analyze the with block behavior

   The with function uses person as the context. Inside, age is incremented by 1, changing it from 25 to 26.

2. Step 2: Evaluate the returned string

   The last expression in the block is the string interpolation "${name} is now $age years old", which becomes "Alice is now 26 years old".

3. Final Answer:

   Alice is now 26 years old -> Option D

4. Quick Check:

   Age incremented inside with = D [OK]

Hint: Remember last expression in with is the return value [OK]

Common Mistakes:

• Forgetting that age is incremented inside with
• Thinking string interpolation causes error
• Assuming modifying properties causes runtime error

4. Identify the error in this Kotlin code using with:

fun main() {
    val list = listOf(1, 2, 3)
    with(list) {
        add(4)
        println(this)
    }
}

medium

A. Cannot call add on an immutable list

B. Missing parentheses in with call

C. Incorrect use of this inside with

D. Print statement syntax error

Solution

1. Step 1: Check the list type and mutability

   The list is created with listOf, which returns an immutable list that does not support add.

2. Step 2: Understand the error cause

   Calling add(4) on an immutable list causes a compile-time error because the method is not available.

3. Final Answer:

   Cannot call add on an immutable list -> Option A

4. Quick Check:

   Immutable list blocks add method = A [OK]

Hint: Use mutableListOf to add elements, not listOf [OK]

Common Mistakes:

• Assuming with changes mutability
• Thinking this is incorrect inside with
• Ignoring immutability of listOf

5. Given a mutable map of student names to scores, how can you use with to increase all scores by 5 points and return the updated map? Choose the correct Kotlin code snippet.

hard

A. with(students) { keys.forEach { it += 5 }; this }

B. with(students) { for (key in keys) this[key] = this[key]!! + 5; this }

C. with(students) { mapValues { it.value + 5 } }

D. with(students) { forEach { it.value += 5 }; this }

Solution

1. Step 1: Understand map mutability and with usage

   The map is mutable, so we can update values by keys inside with. with(students) { for (key in keys) this[key] = this[key]!! + 5; this } correctly loops keys and updates values.

2. Step 2: Analyze other options for correctness

   with(students) { keys.forEach { it += 5 }; this } tries to add 5 to keys (strings), which is invalid. with(students) { mapValues { it.value + 5 } } returns a new map but does not update original. with(students) { forEach { it.value += 5 }; this } tries to modify it.value in forEach, but map entries are immutable in this context.

3. Final Answer:

   with(students) { for (key in keys) this[key] = this[key]!! + 5; this } -> Option B

4. Quick Check:

   Update map values by keys inside with = B [OK]

Hint: Use keys to update mutable map values inside with [OK]

Common Mistakes:

• Trying to modify keys instead of values
• Assuming mapValues mutates original map
• Modifying map entries directly in forEach causes error