BuildBlock for combining results in Swift - Time & Space Complexity

Time Complexity: BuildBlock for combining results

O(n)

Understanding Time Complexity

When combining multiple results using a BuildBlock, it is important to understand how the time taken grows as we add more items.

We want to know how the total work changes when we combine more results together.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

@resultBuilder
struct ResultBuilder {
  static func buildBlock(_ components: String...) -> String {
    components.joined(separator: ", ")
  }
}

let combined = ResultBuilder.buildBlock("A", "B", "C", "D")
print(combined)
    

This code combines multiple strings into one by joining them with commas.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Joining all string components into one string.
• How many times: The join operation internally processes each component once.

How Execution Grows With Input

As we add more strings to combine, the joining work grows roughly in direct proportion to the number of strings.

Input Size (n)	Approx. Operations
10	About 10 join steps
100	About 100 join steps
1000	About 1000 join steps

Pattern observation: The work grows evenly as we add more items, like counting up one by one.

Final Time Complexity

Time Complexity: O(n)

This means the time to combine results grows linearly with the number of items combined.

Common Mistake

[X] Wrong: "Combining more results takes the same time no matter how many there are."

[OK] Correct: Each additional item adds more work because the join operation must process every string.

Interview Connect

Understanding how combining results scales helps you explain performance when building complex outputs step-by-step.

Self-Check

"What if the buildBlock combined results using nested calls instead of joining all at once? How would the time complexity change?"