Type conversion is always explicit in Kotlin - Time & Space Complexity

Time Complexity: Type conversion is always explicit

O(n)

Understanding Time Complexity

We want to understand how the time cost changes when converting types explicitly in Kotlin.

How does the number of operations grow as input size increases during explicit type conversion?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun convertList(numbers: List): List {
    val result = mutableListOf()
    for (num in numbers) {
        result.add(num.toDouble())
    }
    return result
}

This code converts a list of integers to a list of doubles by explicitly converting each element.

Identify Repeating Operations

• Primary operation: Looping through each element in the input list.
• How many times: Once for each element in the list (n times).

How Execution Grows With Input

Each element requires one explicit conversion operation, so the total work grows directly with the number of elements.

Input Size (n)	Approx. Operations
10	10 conversions
100	100 conversions
1000	1000 conversions

Pattern observation: The number of operations increases in a straight line as input size grows.

Final Time Complexity

Time Complexity: O(n)

This means the time to convert grows directly in proportion to the number of items you convert.

Common Mistake

[X] Wrong: "Type conversion happens automatically and costs no extra time."

[OK] Correct: In Kotlin, you must convert types explicitly, and each conversion takes time proportional to the number of elements converted.

Interview Connect

Understanding how explicit type conversions scale helps you write efficient code and explain your reasoning clearly in interviews.

Self-Check

"What if we used a sequence instead of a list for conversion? How would the time complexity change?"