When expression as powerful switch in Kotlin - Time & Space Complexity

Time Complexity: When expression as powerful switch

O(1)

Understanding Time Complexity

We want to understand how the time it takes to run a Kotlin when expression changes as we add more cases.

How does checking many conditions affect the program's speed?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun describeNumber(x: Int): String {
    return when (x) {
        1 -> "One"
        2 -> "Two"
        3 -> "Three"
        4 -> "Four"
        5 -> "Five"
        else -> "Unknown"
    }
}
    

This code checks the value of x and returns a matching word or "Unknown" if no match is found.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: No repeating operations; compiler optimizes when on integers to a jump table or similar structure.
• How many times: Constant time (O(1)) lookup, independent of the number of cases.

How Execution Grows With Input

The Kotlin compiler translates when expressions with constant integer values into efficient bytecode instructions (like tableswitch), resulting in constant time execution.

Number of Cases (n)	Approx. Checks
5	~1 check
10	~1 check
100	~1 check

Pattern observation: Execution time remains constant regardless of the number of cases.

Final Time Complexity

Time Complexity: O(1)

This means the time to find a match stays constant even as you add more cases, thanks to compiler optimizations.

Common Mistake

[X] Wrong: "The when expression checks each case sequentially like chained if-else, so it's O(n)."

[OK] Correct: For integer constants, the Kotlin compiler (targeting JVM/JS/Native) uses jump tables or hash-based lookups, making it constant time, not linear.

Interview Connect

Understanding compiler optimizations for control structures like when shows deeper knowledge of performance, valued in system design and optimization interviews.

Self-Check

What if the when expression used ranges or types instead of single values? How would that affect the time complexity?

Hint: Ranges may use binary search (O(log n)), but single constants remain O(1). Check bytecode!