Lazy evaluation vs eager evaluation in Kotlin - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a lazy value in Kotlin.

Kotlin

val lazyValue: String by [1] {
    println("Computed!")
    "Hello"
}

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

Aeager

Bvar

Cval

Dlazy

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'val' or 'var' instead of 'lazy' for lazy initialization.

Trying to use 'eager' which is not a Kotlin keyword.

In Kotlin, lazy is used to create a lazily evaluated property.

2fill in blank

medium

Complete the code to create an eager list in Kotlin.

Kotlin

val numbers = listOf(1, 2, 3, 4).[1]()

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

AtoList

Bmap

Cfilter

DasSequence

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'asSequence' which creates a lazy sequence, not an eager list.

Using 'map' or 'filter' without collecting results eagerly.

toList() creates a new list eagerly from the original collection.

3fill in blank

hard

Fix the error in the code to make the sequence evaluated lazily.

Kotlin

val seq = listOf(1, 2, 3).[1]().map { it * 2 }

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

AasSequence

BtoList

Cmap

Dfilter

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'toList' which evaluates eagerly.

Applying 'map' directly on list which is eager.

asSequence() converts the list to a lazy sequence, delaying computation.

4fill in blank

hard

Fill both blanks to create a lazy sequence and then convert it back to a list eagerly.

Kotlin

val result = listOf(1, 2, 3).[1]().map { it + 1 }.[2]()

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

AasSequence

BtoList

Cfilter

Dmap

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'map' or 'filter' in wrong places.

Not converting back to list after lazy operations.

First, asSequence() creates a lazy sequence, then toList() collects results eagerly.

5fill in blank

hard

Fill all three blanks to create a lazy property, access it, and print its value.

Kotlin

val lazyVal: String by [1] {
    println("Computing...")
    "Kotlin"
}

fun main() {
    println(lazyVal)
    println(lazyVal.[2])
    println(lazyVal.[3])
}

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

Alazy

BtoUpperCase()

Clength

Dsubstring(0, 3)

Attempts:

3 left

💡 Hint

Common Mistakes

Using eager initialization instead of lazy.

Mixing up string methods or forgetting parentheses.

The property is lazy initialized with lazy. Then we print its length and uppercase form.

Practice

1. What is the main difference between lazy evaluation and eager evaluation in Kotlin?

easy

A. Lazy evaluation requires manual calls, eager evaluation never runs automatically.

B. Lazy evaluation computes values immediately, eager evaluation delays computation.

C. Lazy evaluation delays computation until the value is needed, eager evaluation computes immediately.

D. Lazy evaluation is only used for variables, eager evaluation only for functions.

Solution

1. Step 1: Understand lazy evaluation

   Lazy evaluation means the program waits to calculate a value until it is actually needed.

2. Step 2: Understand eager evaluation

   Eager evaluation means the program calculates the value right away when the code runs.

3. Final Answer:

   Lazy evaluation delays computation until the value is needed, eager evaluation computes immediately. -> Option C

4. Quick Check:

   Lazy = delay, Eager = immediate [OK]

Hint: Lazy waits, eager runs now. Remember delay vs immediate [OK]

Common Mistakes:

• Confusing which evaluation runs first
• Thinking lazy evaluation runs immediately
• Assuming eager evaluation delays work

2. Which of the following is the correct syntax to declare a lazy property in Kotlin?

easy

A. val x by lazy { 10 }

B. val x = lazy { 10 }

C. lazy val x = 10

D. val x = by lazy 10

Solution

1. Step 1: Recall Kotlin lazy syntax

   Kotlin uses val x by lazy { ... } to declare lazy properties.

2. Step 2: Check each option

   val x by lazy { 10 } matches the correct syntax. The other options are incorrect Kotlin syntax.

3. Final Answer:

   val x by lazy { 10 } -> Option A

4. Quick Check:

   Use 'by lazy { }' for lazy properties [OK]

Hint: Remember: 'val x by lazy { ... }' is correct syntax [OK]

Common Mistakes:

• Using 'lazy val' instead of 'val by lazy'
• Assigning lazy without 'by'
• Placing 'by lazy' after the value

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

val eager = "Eager".also { println("Eager initialized") }
val lazyVal by lazy { println("Lazy initialized"); "Lazy" }

fun main() {
    println("Start main")
    println(eager)
    println(lazyVal)
    println(lazyVal)
}

medium

A. Start main
Eager initialized
Eager
Lazy initialized
Lazy
Lazy

B. Eager initialized
Start main
Eager
Lazy initialized
Lazy
Lazy

C. Eager initialized
Start main
Eager
Lazy
Lazy initialized
Lazy

D. Start main
Eager
Lazy initialized
Lazy
Lazy initialized
Lazy

Solution

1. Step 1: Understand eager initialization

   The variable eager uses also, so "Eager initialized" prints immediately when declared.

2. Step 2: Understand lazy initialization and main flow

   Lazy variable lazyVal prints "Lazy initialized" only when first accessed. The main prints "Start main", then prints eager (already initialized), then accesses lazyVal twice. The first access triggers initialization print, second does not.

3. Final Answer:

   Eager initialized Start main Eager Lazy initialized Lazy Lazy -> Option B

4. Quick Check:

   Eager prints first, lazy prints on first access [OK]

Hint: Eager prints on declaration, lazy prints on first use [OK]

Common Mistakes:

• Assuming lazy prints before main
• Thinking lazy prints every access
• Mixing order of prints

4. Identify the error in this Kotlin code using lazy evaluation:

val lazyValue by lazy {
    println("Calculating...")
    42
}

fun main() {
    println(lazyValue)
    lazyValue = 50
}

medium

A. Cannot reassign a val property declared with 'by lazy'.

B. Missing parentheses after 'lazy' keyword.

C. Lazy block must return a String, not Int.

D. The println statement inside lazy block is not allowed.

Solution

1. Step 1: Check property mutability

   The property lazyValue is declared with val, meaning it cannot be reassigned after initialization.

2. Step 2: Analyze reassignment in main

   The code tries to assign lazyValue = 50, which is illegal for a val property and causes a compilation error.

3. Final Answer:

   Cannot reassign a val property declared with 'by lazy'. -> Option A

4. Quick Check:

   val lazy properties are read-only, no reassignment [OK]

Hint: val lazy properties cannot be reassigned after initialization [OK]

Common Mistakes:

• Trying to assign a new value to a val lazy property
• Confusing val with var for lazy properties
• Thinking lazy block must return String

5. You want to optimize a Kotlin program that loads a large configuration file only if needed. Which approach best uses lazy evaluation to improve performance?

hard

A. Use a var and assign loadConfig() inside main after checking a flag.

B. Call loadConfig() immediately at program start and store in a val.

C. Declare val config = loadConfig() inside a function that runs every time.

D. Declare the configuration as val config by lazy { loadConfig() } so it loads only on first access.

Solution

1. Step 1: Understand lazy loading benefit

   Loading a large config only when needed saves startup time and resources.

2. Step 2: Choose lazy evaluation syntax

   Using val config by lazy { loadConfig() } delays loading until first use, improving performance.

3. Final Answer:

   Declare the configuration as val config by lazy { loadConfig() } so it loads only on first access. -> Option D

4. Quick Check:

   Lazy loading delays heavy work until needed [OK]

Hint: Use 'by lazy' to delay heavy loading until first use [OK]

Common Mistakes:

• Loading config immediately even if not needed
• Using var without lazy, causing unnecessary loads
• Loading config repeatedly inside functions