Functions returning tuples in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift function returning a tuple?

Consider the following Swift function that returns a tuple. What will be printed when calling result?

Swift

func getCoordinates() -> (x: Int, y: Int) {
    return (x: 10, y: 20)
}

let result = getCoordinates()
print("x: \(result.x), y: \(result.y)")

A x: 0, y: 0

B x: 20, y: 10

C x: 10 y: 20

D x: 10, y: 20

💡 Hint

Look at the tuple labels and values returned by the function.

The function returns a tuple with x = 10 and y = 20. Accessing result.x and result.y prints those values exactly.

🧠 Conceptual

intermediate

What is the type of the tuple returned by this function?

Given this Swift function, what is the exact type of the returned tuple?

Swift

func getUserInfo() -> (name: String, age: Int) {
    return (name: "Alice", age: 30)
}

A (name: String, age: Int)

B (String, Int)

C (String, String)

D (Int, String)

💡 Hint

Check if the tuple has labels or not.

The function returns a tuple with labels 'name' and 'age' of types String and Int respectively, so the type includes labels.

🔧 Debug

advanced

Why does this Swift function cause a compile error?

Examine the function below. Why does it cause a compile error?

Swift

func calculate() -> (Int, Int) {
    return (x: 5, y: 10)
}

A The tuple values are not integers

B The function is missing a return statement

C The return tuple has labels but the function return type does not specify labels

D The function return type must be a class, not a tuple

💡 Hint

Check if tuple labels in return match the declared return type.

The function return type is an unlabeled tuple (Int, Int), but the return statement uses labeled tuple (x: 5, y: 10). This mismatch causes a compile error.

❓ Predict Output

advanced

What is the output of this function returning multiple values as a tuple?

What will be printed when running this Swift code?

Swift

func minMax(numbers: [Int]) -> (min: Int, max: Int)? {
    guard let first = numbers.first else { return nil }
    var currentMin = first
    var currentMax = first
    for number in numbers {
        if number < currentMin {
            currentMin = number
        } else if number > currentMax {
            currentMax = number
        }
    }
    return (min: currentMin, max: currentMax)
}

if let result = minMax(numbers: [3, 7, 2, 9, 4]) {
    print("Min is \(result.min), Max is \(result.max)")
} else {
    print("Empty array")
}

A Min is 2, Max is 9

B Min is 3, Max is 7

C Min is 9, Max is 2

D Empty array

💡 Hint

The function finds the smallest and largest numbers in the array.

The smallest number in the array is 2 and the largest is 9, so the output prints those values.

🧠 Conceptual

expert

How can you access tuple elements returned by a Swift function without using labels?

Given a Swift function that returns an unlabeled tuple, how do you access the elements?

Swift

func getValues() -> (Int, String) {
    return (42, "Answer")
}

let values = getValues()

A Use values[0] and values[1]

B Use values.0 for the first element and values.1 for the second element

C Use values.first and values.second

D Use values.x and values.y

💡 Hint

Unlabeled tuples use numeric indices starting at zero.

Unlabeled tuple elements are accessed by .0, .1, etc. Using .first or subscripts is invalid for tuples.

Practice

1. What does a Swift function returning a tuple allow you to do?

easy

A. Return only one value

B. Return values only as dictionaries

C. Return values only as arrays

D. Return multiple values grouped together

Solution

1. Step 1: Understand tuple return type

   Functions returning tuples can send back multiple values grouped as one compound value.

2. Step 2: Compare with other return types

   Unlike arrays or dictionaries, tuples keep related values together without extra structure.

3. Final Answer:

   Return multiple values grouped together -> Option D

4. Quick Check:

   Functions returning tuples = multiple grouped values [OK]

Hint: Tuples bundle multiple return values simply [OK]

Common Mistakes:

• Thinking functions can return only one value
• Confusing tuples with arrays or dictionaries
• Assuming tuples must have named elements

2. Which of the following is the correct syntax for a Swift function returning a tuple with named elements x and y as Int?

easy

A. func getCoordinates() -> (x Int, y Int) { return (10, 20) }

B. func getCoordinates() -> (x: Int, y: Int) { return (10, 20) }

C. func getCoordinates() -> (Int x, Int y) { return (10, 20) }

D. func getCoordinates() -> (x: Int; y: Int) { return (10, 20) }

Solution

1. Step 1: Check tuple syntax in return type

   Named tuple elements use the format (name: Type, name: Type), so (x: Int, y: Int) is correct.

2. Step 2: Verify return statement matches tuple

   Returning (10, 20) matches the tuple structure with two Int values.

3. Final Answer:

   func getCoordinates() -> (x: Int, y: Int) { return (10, 20) } -> Option B

4. Quick Check:

   Named tuple syntax = (name: Type, ...) [OK]

Hint: Use colon between name and type in tuple [OK]

Common Mistakes:

• Using type before name in tuple elements
• Separating tuple elements with semicolon instead of comma
• Omitting names or using wrong punctuation

3. What is the output of this Swift code?

func minMax(numbers: [Int]) -> (min: Int, max: Int) {
    var currentMin = numbers[0]
    var currentMax = numbers[0]
    for number in numbers[1...] {
        if number < currentMin { currentMin = number }
        if number > currentMax { currentMax = number }
    }
    return (currentMin, currentMax)
}

let result = minMax(numbers: [3, 7, 2, 9, 4])
print(result.min, result.max)

medium

A. 2 9

B. 3 7

C. 9 2

D. Error: tuple elements not accessible

Solution

1. Step 1: Trace min and max calculation

   Start with first number 3 as min and max. Iterate over 7, 2, 9, 4 updating min to 2 and max to 9.

2. Step 2: Access tuple elements by name

   Returned tuple has named elements min and max, so result.min is 2 and result.max is 9.

3. Final Answer:

   2 9 -> Option A

4. Quick Check:

   min = 2, max = 9 [OK]

Hint: Tuple elements accessed by name like properties [OK]

Common Mistakes:

• Confusing min and max values
• Trying to access tuple elements by index instead of name
• Forgetting to start loop from second element

4. Identify the error in this Swift function returning a tuple:

func divide(_ a: Int, _ b: Int) -> (quotient: Int, remainder: Int) {
    let q = a / b
    let r = a % b
    return q, r
}

medium

A. Return statement syntax is incorrect for tuple

B. Division by zero error possible

C. Tuple elements must be unnamed

D. Function parameters must be named

Solution

1. Step 1: Check return statement syntax

   Returning multiple values as a tuple requires parentheses: return (q, r), not return q, r.

2. Step 2: Confirm tuple element names are allowed

   Named tuple elements in return type are valid; parameters can be unnamed as shown.

3. Final Answer:

   Return statement syntax is incorrect for tuple -> Option A

4. Quick Check:

   Return tuple with parentheses [OK]

Hint: Use parentheses around tuple values in return [OK]

Common Mistakes:

• Omitting parentheses in return tuple
• Assuming parameters must be named
• Ignoring possible division by zero (not asked here)

5. You want to write a Swift function that returns the sum, average, and count of an array of Ints as a tuple with named elements. Which of these implementations correctly does this?

hard

A. func stats(numbers: [Int]) -> (Int, Int, Int) {
let sum = numbers.reduce(0, +)
let count = numbers.count
let avg = sum / count
return (sum, avg, count)
}

B. func stats(numbers: [Int]) -> (sum: Int, avg: Int, count: Int) {
let sum = numbers.reduce(0, +)
let count = numbers.count
let avg = sum / count
return (sum, avg, count)
}

C. func stats(numbers: [Int]) -> (sum: Int, avg: Double, count: Int) {
let sum = numbers.reduce(0, +)
let count = numbers.count
let avg = Double(sum) / Double(count)
return (sum, avg, count)
}

D. func stats(numbers: [Int]) -> (sum: Int, avg: Double, count: Int) {
let sum = numbers.reduce(0, +)
let count = numbers.count
let avg = sum / count
return (sum, avg, count)
}

Solution

1. Step 1: Check return type matches values

   Return type must be named tuple (sum: Int, avg: Double, count: Int). Correct implementation declares this exactly.

2. Step 2: Verify average calculation

   Average requires Double conversion: Double(sum) / Double(count) to get precise floating-point result, avoiding integer truncation.

3. Step 3: Confirm return statement matches tuple

   return (sum, avg, count) aligns with named elements in order and type.

4. Final Answer:

   func stats(numbers: [Int]) -> (sum: Int, avg: Double, count: Int) { let sum = numbers.reduce(0, +) let count = numbers.count let avg = Double(sum) / Double(count) return (sum, avg, count) } -> Option C

5. Quick Check:

   named tuple + Double(sum)/Double(count) [OK]

Hint: Match tuple element types exactly, convert for average [OK]

Common Mistakes:

• Using Int for average causing integer division
• Mismatching tuple element names and return values
• Omitting type conversion for average calculation