Explicit type annotation in Swift - Time & Space Complexity

Time Complexity: Explicit type annotation

O(n)

Understanding Time Complexity

Let's see how adding explicit type annotations affects the speed of Swift code.

We want to know if telling Swift the exact type changes how long the code takes to run.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

var numbers: [Int] = []
for i in 1...n {
    numbers.append(i)
}

This code creates an empty list of integers and adds numbers from 1 to n one by one.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that adds each number to the list.
• How many times: Exactly n times, once for each number from 1 to n.

How Execution Grows With Input

Each time n grows, the loop runs that many times, adding one number each time.

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

Pattern observation: The work grows directly with n; double n means double the work.

Final Time Complexity

Time Complexity: O(n)

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

Common Mistake

[X] Wrong: "Adding explicit type annotations makes the code slower because it adds extra work."

[OK] Correct: The type annotation is just a hint for the compiler and does not add extra loops or steps during runtime.

Interview Connect

Understanding how code runs with or without type hints shows you know what really affects speed, a skill useful in many coding tasks.

Self-Check

"What if we replaced the array with a linked list? How would the time complexity change?"