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

Time Complexity: Type conversion is always explicit

O(n)

Understanding Time Complexity

When we convert types in Swift, the computer must do extra work to change one type to another.

We want to see how this extra work grows when we convert many values.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

let numbers = [1, 2, 3, 4, 5]
var doubles: [Double] = []

for number in numbers {
    let converted = Double(number)
    doubles.append(converted)
}

This code converts each integer in an array to a double and stores it in a new array.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the array and converting each integer to a double.
• How many times: Once for each item in the input array.

How Execution Grows With Input

Each new number means one more conversion and one more append operation.

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

Pattern observation: The work grows directly with the number of items.

Final Time Complexity

Time Complexity: O(n)

This means the time to convert grows in a straight line as the list gets bigger.

Common Mistake

[X] Wrong: "Type conversion happens automatically and instantly without extra work."

[OK] Correct: Each conversion requires the computer to do work, so it takes time proportional to how many items you convert.

Interview Connect

Understanding how explicit type conversion affects performance helps you write clear and efficient code, a skill valued in many programming tasks.

Self-Check

What if we converted a nested array of integers to doubles? How would the time complexity change?