Main entry point and @main attribute in Swift - Time & Space Complexity

Time Complexity: Main entry point and @main attribute

O(n)

Understanding Time Complexity

When we look at the main entry point in Swift, we want to understand how the program starts and how the time it takes grows as the program runs.

We ask: How does the program's starting code affect the total work done as input size changes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

    @main
    struct MyApp {
      static func main() {
        let n = 10
        for i in 1...n {
          print(i)
        }
      }
    }
    

This code defines the program's main entry point using the @main attribute and prints numbers from 1 to n.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that prints numbers from 1 to n.
• How many times: It runs exactly n times, once for each number.

How Execution Grows With Input

As n grows, the number of print operations grows the same way.

Input Size (n)	Approx. Operations
10	10 print calls
100	100 print calls
1000	1000 print calls

Pattern observation: The work grows directly with n; doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the main function grows in a straight line as the input size n increases.

Common Mistake

[X] Wrong: "The @main attribute itself makes the program run slower as n grows."

[OK] Correct: The @main attribute just marks where the program starts; it does not add extra work. The time depends on what the main function does, not the attribute.

Interview Connect

Understanding how the main entry point works and how its code scales helps you explain program startup and performance clearly in interviews.

Self-Check

"What if we replaced the for-loop with a recursive function that prints numbers from 1 to n? How would the time complexity change?"

Practice

1. What does the @main attribute do in a Swift program?

easy

A. It marks the program's starting point where execution begins.

B. It defines a class as a data model.

C. It imports external libraries into the program.

D. It declares a variable as constant.

Solution

1. Step 1: Understand the role of @main

   The @main attribute tells Swift which type contains the program's entry point.

2. Step 2: Identify the program start

   This attribute marks where the program starts running, so it controls the first code executed.

3. Final Answer:

   It marks the program's starting point where execution begins. -> Option A

4. Quick Check:

   @main marks start point [OK]

Hint: Remember: @main means 'start here' in Swift programs [OK]

Common Mistakes:

• Confusing @main with import statements
• Thinking @main defines variables
• Assuming @main is for classes only

2. Which of the following is the correct way to declare the main entry point using @main in Swift?

easy

A. @main struct App { static func main() { print("Hello") } }

B. struct App { @main func main() { print("Hello") } }

C. @main func main() { print("Hello") }

D. func main() { @main print("Hello") }

Solution

1. Step 1: Check the placement of @main

   The @main attribute must be placed before a type (struct, class, or enum), not before a function.

2. Step 2: Verify the static main() method

   The type marked with @main must have a static main() method as the entry point.

3. Final Answer:

   @main struct App { static func main() { print("Hello") } } -> Option A

4. Quick Check:

   @main before type + static main() [OK]

Hint: Put @main before a type, not a function [OK]

Common Mistakes:

• Placing @main before a function instead of a type
• Missing static keyword on main()
• Using @main inside a function body

3. What will be the output of this Swift program?

@main struct MyApp {
    static func main() {
        print("Start")
        run()
    }
    static func run() {
        print("Running")
    }
}

medium

A. No output, program error

B. Running\nStart

C. Start

D. Start\nRunning

Solution

1. Step 1: Identify the program start

   The @main attribute marks MyApp as the entry point, so main() runs first.

2. Step 2: Trace the function calls

   main() prints "Start" then calls run(), which prints "Running".

3. Final Answer:

   Start Running -> Option D

4. Quick Check:

   main() prints Start then run() prints Running [OK]

Hint: Follow the call order inside static main() [OK]

Common Mistakes:

• Assuming run() runs before main()
• Forgetting to call run() inside main()
• Thinking @main runs run() automatically

4. Identify the error in this Swift program using @main:

@main class App {
    func main() {
        print("Hello")
    }
}

medium

A. The @main attribute cannot be used on a class.

B. The main() method must be static.

C. The print statement is invalid inside main().

D. The class must be a struct instead.

Solution

1. Step 1: Check the main() method signature

   The @main type must have a static main() method to serve as the entry point.

2. Step 2: Identify the missing static keyword

   Here, main() is an instance method, missing static, causing a compile error.

3. Final Answer:

   The main() method must be static. -> Option B

4. Quick Check:

   main() must be static in @main type [OK]

Hint: Static main() is required inside @main type [OK]

Common Mistakes:

• Omitting static keyword on main()
• Thinking @main can't be on classes
• Confusing instance and static methods

5. You want to create a Swift program that prints "Welcome!" only if a condition is true at startup. Using @main, which is the best way to implement this?

hard

A. struct App {
static func main() {
if true {
print("Welcome!")
}
}
}

B. @main struct App {
func main() {
if true {
print("Welcome!")
}
}
}

C. @main struct App {
static func main() {
if true {
print("Welcome!")
}
}
}

D. @main func main() {
if true {
print("Welcome!")
}
}

Solution

1. Step 1: Use @main on a type with static main()

   The program must have a type marked with @main and a static main() method to run at startup.

2. Step 2: Implement conditional print inside static main()

   Inside main(), use the if statement to print "Welcome!" only if the condition is true.

3. Final Answer:

   @main struct App { static func main() { if true { print("Welcome!") } } } -> Option C

4. Quick Check:

   @main type + static main() + condition inside main() [OK]

Hint: Always put @main on type with static main() method [OK]

Common Mistakes:

• Making main() an instance method
• Forgetting @main attribute on the type
• Trying to put @main on a function