Switch with value binding in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of switch with value binding and where clause

What is the output of this Swift code?

Swift

let point = (3, 4)
switch point {
case let (x, y) where x == y:
    print("On the line x == y")
case let (x, y) where x == -y:
    print("On the line x == -y")
case let (x, y):
    print("Somewhere else at (\(x), \(y))")
}

A On the line x == y

B On the line x == -y

C Somewhere else at (3, 4)

D No output

💡 Hint

Check the conditions in the where clauses carefully.

The point (3, 4) does not satisfy x == y or x == -y, so it matches the last case and prints the coordinates.

❓ Predict Output

intermediate

Switch with value binding and tuple pattern

What will this Swift code print?

Swift

let coordinate = (0, 5)
switch coordinate {
case (0, let y):
    print("On the y-axis at \(y)")
case (let x, 0):
    print("On the x-axis at \(x)")
case let (x, y):
    print("Somewhere else at (\(x), \(y))")
}

A On the x-axis at 0

B On the y-axis at 5

C Somewhere else at (0, 5)

D No output

💡 Hint

Look at the tuple pattern matching order.

The coordinate (0, 5) matches the first case where x is 0 and y is bound to 5.

🔧 Debug

advanced

Identify the error in switch with value binding

What error does this Swift code produce?

Swift

let number = 10
switch number {
case let x where x > 5:
    print("Greater than 5")
case let x where x < 5:
    print("Less than 5")
case let x where x == 5:
    print("Equal to 5")
}

A No error, prints 'Greater than 5'

B RuntimeError: No matching case found

C SyntaxError: Missing parentheses in where clause

D SyntaxError: Missing colon after case condition

💡 Hint

Check the syntax of each case line carefully.

The last case is missing a colon at the end of the case line, causing a syntax error.

❓ Predict Output

advanced

Switch with nested value binding and pattern matching

What is the output of this Swift code?

Swift

enum Result {
    case success(data: Int)
    case failure(error: String)
}

let result = Result.success(data: 42)
switch result {
case .success(let data) where data > 40:
    print("Big success with \(data)")
case .success(let data):
    print("Success with \(data)")
case .failure(let error):
    print("Failed with error: \(error)")
}

A Big success with 42

B Success with 42

C Failed with error: 42

D No output

💡 Hint

Check the where clause condition in the first case.

The result is a success with data 42, which is greater than 40, so the first case matches.

🧠 Conceptual

expert

Value binding behavior in switch cases

Consider this Swift code snippet. What will be the value of variable 'message' after execution?

Swift

let value = (2, 3)
var message = ""
switch value {
case let (x, y) where x == y:
    message = "Equal"
case let (x, y) where x > y:
    message = "X is greater"
case let (x, y):
    message = "X is less"
}

A "X is less"

B "X is greater"

C "Equal"

D "No match"

💡 Hint

Compare the values of x and y carefully.

Since 2 is less than 3, the last case matches and message is set to "X is less".

Practice

1. What does value binding in a switch statement allow you to do in Swift?

easy

A. Capture parts of the matched value for use inside the case block

B. Change the type of the value being switched on

C. Skip checking the value and run all cases

D. Automatically loop through all possible values

Solution

1. Step 1: Understand value binding concept

   Value binding lets you take a part of the value matched in a case and give it a name to use inside that case.

2. Step 2: Recognize its purpose in switch

   This helps you work with the matched data directly without extra code.

3. Final Answer:

   Capture parts of the matched value for use inside the case block -> Option A

4. Quick Check:

   Value binding = capture matched value parts [OK]

Hint: Value binding captures matched data for use inside cases [OK]

Common Mistakes:

• Thinking it changes the value type
• Believing it skips cases
• Assuming it loops automatically

2. Which of the following is the correct syntax for value binding in a Swift switch case?

easy

A. case x let:

B. case let x:

C. case let:

D. case var:

Solution

1. Step 1: Recall correct value binding syntax

   In Swift, value binding uses let or var before a variable name in the case pattern, like case let x:.

2. Step 2: Check options for correct order

   Only case let x: uses let followed by a variable name correctly.

3. Final Answer:

   case let x: -> Option B

4. Quick Check:

   Correct syntax = case let variable: [OK]

Hint: Remember: 'case let variable:' is the right order [OK]

Common Mistakes:

• Placing variable before let
• Omitting variable name
• Using let without variable

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

let point = (3, 0)
switch point {
 case let (x, 0):
     print("On the x-axis at \(x)")
 case let (0, y):
     print("On the y-axis at \(y)")
 default:
     print("Somewhere else")
}

medium

A. On the x-axis at 3

B. On the y-axis at 0

C. Somewhere else

D. Syntax error

Solution

1. Step 1: Match the tuple with cases

   The tuple is (3, 0). The first case matches any tuple where the second value is 0, binding the first to x.

2. Step 2: Execute matching case

   Since (3, 0) matches case let (x, 0):, it prints "On the x-axis at 3".

3. Final Answer:

   On the x-axis at 3 -> Option A

4. Quick Check:

   Tuple (3,0) matches x-axis case [OK]

Hint: Check tuple pattern carefully to find matching case [OK]

Common Mistakes:

• Confusing x and y positions
• Choosing default case incorrectly
• Assuming syntax error

4. Identify the error in this Swift switch statement using value binding:

let number = 5
switch number {
 case let x where x > 0:
     print("Positive")
 case let x where x < 0:
     print("Negative")
 case x == 0:
     print("Zero")
}

medium

A. Missing 'let' keyword in the last case

B. Incorrect use of 'where' in first two cases

C. Invalid pattern syntax in the last case

D. Switch statement missing default case

Solution

1. Step 1: Review last case syntax

   The last case uses case x == 0:, which is not valid pattern syntax in Swift.

2. Step 2: Correct pattern usage

   It should use value binding with a where clause, like case let x where x == 0:.

3. Final Answer:

   Invalid pattern syntax in the last case -> Option C

4. Quick Check:

   Pattern must be 'case let x where condition' [OK]

Hint: Use 'case let x where condition' for conditions [OK]

Common Mistakes:

• Writing conditions directly after case without let
• Omitting where keyword
• Assuming default case is mandatory

5. Given an array of optional integers, how can you use a switch with value binding to print only the non-nil values?

let numbers: [Int?] = [3, nil, 7, nil, 1]
for number in numbers {
    switch number {
    case let x:
        print(x)
    case nil:
        print("No value")
    }
}

What is the problem and how to fix it?

hard

A. The order of cases is wrong; put 'case nil' before 'case let x' to match nil first

B. Add a default case to handle nil values

C. Replace 'case let x' with 'case let x!' to unwrap optionals

D. Use 'case let x?' to bind only non-nil values, and 'case nil' for nil

Solution

1. Step 1: Understand optional pattern matching

   Using case let x: matches all values including nil, so case nil: is never reached.

2. Step 2: Use optional pattern binding

   Use case let x?: to match only non-nil values and bind them, and case nil: to match nil explicitly.

3. Final Answer:

   Use 'case let x?' to bind only non-nil values, and 'case nil' for nil -> Option D

4. Quick Check:

   Optional binding uses 'case let x?' [OK]

Hint: Use 'case let x?' to match non-nil optionals [OK]

Common Mistakes:

• Matching nil after a catch-all case
• Using force unwrap (!) in case pattern
• Missing explicit nil case