Where clauses for complex constraints in Swift - Time & Space Complexity

Time Complexity: Where clauses for complex constraints

O(n)

Understanding Time Complexity

When using where clauses for complex constraints in Swift, it's important to see how they affect the speed of your code.

We want to know how the time needed changes as the input grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func filterPairs(pairs: [(Int, Int)]) -> [(Int, Int)] {
    return pairs.filter { (a, b) in
        a > 0 && b > 0 && (a + b) % 2 == 0
    }
}
    

This code filters a list of number pairs, keeping only those where both numbers are positive and their sum is even.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The filter method loops through each pair once.
• How many times: It checks every pair exactly one time.

How Execution Grows With Input

As the number of pairs grows, the time to check them grows too.

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

Pattern observation: The number of checks grows directly with the number of pairs.

Final Time Complexity

Time Complexity: O(n)

This means the time needed grows in a straight line with the number of pairs you check.

Common Mistake

[X] Wrong: "Adding more conditions inside the filter closure makes the code slower by multiplying the time."

[OK] Correct: Each condition is checked once per item, so adding conditions adds a small fixed cost per item, but the overall time still grows linearly with input size.

Interview Connect

Understanding how filtering with complex conditions affects time helps you write clear and efficient code, a skill valued in many coding challenges.

Self-Check

"What if we replaced filter with a nested loop checking pairs against each other? How would the time complexity change?"