Let function with safe calls in Kotlin - Time & Space Complexity

Time Complexity: Let function with safe calls

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run code with the let function and safe calls changes as the input size grows.

Specifically, how does using let with safe calls affect the number of steps the program takes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

val list: List = listOf("a", null, "b", "c", null)

list.forEach { item ->
    item?.let {
        println(it.uppercase())
    }
}
    

This code goes through a list of strings that might be null. For each non-null item, it prints the uppercase version.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The forEach loop goes through each item in the list once.
• How many times: It runs exactly once for each element in the list, so if the list has n items, it runs n times.

How Execution Grows With Input

As the list gets bigger, the number of times the loop runs grows directly with the number of items.

Input Size (n)	Approx. Operations
10	About 10 checks and possible prints
100	About 100 checks and possible prints
1000	About 1000 checks and possible prints

Pattern observation: The work grows evenly as the list grows. Double the list, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the code grows in a straight line with the number of items in the list.

Common Mistake

[X] Wrong: "Using let with safe calls makes the code slower by adding extra loops or checks that multiply the work."

[OK] Correct: The let function just runs once per non-null item inside the existing loop. It does not add extra loops, only a small check, so the overall work still grows linearly.

Interview Connect

Understanding how safe calls and let affect performance helps you write clear and efficient Kotlin code. It shows you can reason about how your code scales with input size, a key skill in programming.

Self-Check

"What if we replaced forEach with a nested loop inside the let block? How would the time complexity change?"