Enum declaration and cases in Swift - Time & Space Complexity

Time Complexity: Enum declaration and cases

O(1)

Understanding Time Complexity

Enums group related values together in Swift. We want to see how the time to create or use enums changes as we add more cases.

How does the number of enum cases affect the work the program does?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

enum Direction {
    case north
    case south
    case east
    case west
}

func printDirection(_ dir: Direction) {
    switch dir {
    case .north: print("Going north")
    case .south: print("Going south")
    case .east: print("Going east")
    case .west: print("Going west")
    }
}

This code defines an enum with four directions and a function that prints a message based on the direction.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The switch statement directly jumps to the matching enum case using a compiler-optimized jump table.
• How many times: Constant time (O(1)), independent of the number of enum cases.

How Execution Grows With Input

As the number of enum cases grows, the switch execution time remains constant due to compiler optimizations like jump tables.

Input Size (n)	Approx. Operations
4	1
10	1
100	1

Pattern observation: The number of operations is constant regardless of the number of enum cases.

Final Time Complexity

Time Complexity: O(1)

This means the time to find the matching case is constant regardless of the number of enum cases.

Common Mistake

[X] Wrong: "Switching on enums checks cases one by one, taking time proportional to the number of cases."

[OK] Correct: Swift compiler optimizes simple enum switches to constant time using jump tables or direct dispatch.

Interview Connect

Understanding how enum case checks grow helps you explain how your code handles different options efficiently.

Self-Check

"What if we replaced the switch with a dictionary lookup for enum cases? How would the time complexity change?"

Practice

1. What is the purpose of an enum in Swift?

easy

A. To group related values under one name

B. To create a function

C. To declare a variable

D. To write a loop

Solution

1. Step 1: Understand what enums represent

   Enums group related values together to make code clearer and safer.

2. Step 2: Compare options with enum purpose

   Only To group related values under one name correctly describes grouping related values under one name.

3. Final Answer:

   To group related values under one name -> Option A

4. Quick Check:

   Enum purpose = Group related values [OK]

Hint: Enums group related values clearly and safely [OK]

Common Mistakes:

• Confusing enums with functions
• Thinking enums declare variables
• Mixing enums with loops

2. Which of the following is the correct way to declare an enum named Direction with cases north, south, east, and west?

easy

A. enum Direction = { north, south, east, west }

B. enum Direction: north, south, east, west {}

C. enum Direction { case north, south, east, west }

D. enum Direction { north; south; east; west }

Solution

1. Step 1: Recall Swift enum syntax

   Enums use the keyword enum, followed by the name and curly braces containing case declarations separated by commas.

2. Step 2: Check each option's syntax

   enum Direction { case north, south, east, west } uses correct syntax: enum Direction { case north, south, east, west }. Others use invalid syntax.

3. Final Answer:

   enum Direction { case north, south, east, west } -> Option C

4. Quick Check:

   Correct enum syntax = enum Direction { case north, south, east, west } [OK]

Hint: Use 'case' keyword with comma-separated values inside braces [OK]

Common Mistakes:

• Using '=' instead of braces
• Omitting 'case' keyword
• Separating cases with semicolons

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

enum Light {
    case red, yellow, green
}

let current = Light.red
switch current {
case .red:
    print("Stop")
case .yellow:
    print("Caution")
case .green:
    print("Go")
}

medium

A. No output

B. Go

C. Caution

D. Stop

Solution

1. Step 1: Identify the enum case assigned

   The variable current is assigned Light.red.

2. Step 2: Match the switch case for current

   The switch matches .red and prints "Stop".

3. Final Answer:

   Stop -> Option D

4. Quick Check:

   Light.red triggers "Stop" output [OK]

Hint: Match enum case in switch to get output [OK]

Common Mistakes:

• Confusing enum cases with strings
• Forgetting dot prefix in switch
• Assuming default output

4. Identify the error in this enum declaration:

enum Weather {
    case sunny
    case rainy
    case windy
    case
}

medium

A. Missing case name after 'case' keyword

B. Enum name is invalid

C. Curly braces are missing

D. Enum cases should be strings

Solution

1. Step 1: Review each enum case line

   The last line has case without a case name, which is invalid syntax.

2. Step 2: Confirm other parts are correct

   Enum name and braces are correct; cases do not need to be strings.

3. Final Answer:

   Missing case name after 'case' keyword -> Option A

4. Quick Check:

   Every 'case' must have a name [OK]

Hint: Each 'case' must have a name after it [OK]

Common Mistakes:

• Leaving 'case' empty
• Thinking cases need quotes
• Missing braces around enum

5. You want to create an enum Planet with cases for mercury, venus, and earth. Then, write a function that returns a friendly message for each planet. Which code correctly implements this?

hard

A. enum Planet { mercury, venus, earth }
func message(planet: Planet) -> String {
if planet == mercury { return "Closest to the Sun" }
else if planet == venus { return "Second planet" }
else { return "Our home" }
}

B. enum Planet { case mercury, venus, earth }
func message(for planet: Planet) -> String {
switch planet {
case .mercury: return "Closest to the Sun"
case .venus: return "Second planet"
case .earth: return "Our home"
}
}

C. enum Planet { case mercury, venus, earth }
func message(planet: Planet) -> String {
if planet == mercury { return "Closest to the Sun" }
else if planet == venus { return "Second planet" }
else { return "Our home" }
}

D. enum Planet { case mercury, venus, earth }
func message(for planet: Planet) -> String {
switch planet {
case mercury: return "Closest to the Sun"
case venus: return "Second planet"
case earth: return "Our home"
}
}

Solution

1. Step 1: Check enum declaration syntax

   Options A, C, and D declare enum correctly with case keyword; B misses it, so B is invalid.

2. Step 2: Check function parameter and switch usage

   enum Planet { case mercury, venus, earth } func message(for planet: Planet) -> String { switch planet { case .mercury: return "Closest to the Sun" case .venus: return "Second planet" case .earth: return "Our home" } } uses switch with dot syntax for cases and correct function signature. enum Planet { case mercury, venus, earth } func message(planet: Planet) -> String { if planet == mercury { return "Closest to the Sun" } else if planet == venus { return "Second planet" } else { return "Our home" } } uses if-else without dot syntax (.mercury), causing compile error. enum Planet { case mercury, venus, earth } func message(for planet: Planet) -> String { switch planet { case mercury: return "Closest to the Sun" case venus: return "Second planet" case earth: return "Our home" } } misses dot prefix in switch cases, causing error.

3. Final Answer:

   enum Planet { case mercury, venus, earth } func message(for planet: Planet) -> String { switch planet { case .mercury: return "Closest to the Sun" case .venus: return "Second planet" case .earth: return "Our home" } } -> Option B

4. Quick Check:

   Enum with 'case' and switch with dot cases [OK]

Hint: Use 'case' keyword and dot prefix in switch cases [OK]

Common Mistakes:

• Omitting 'case' keyword in enum
• Missing dot prefix in switch cases
• Using if without dot prefix for enum cases