Where clauses for complex constraints in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to filter numbers greater than 10 using a where clause.

Swift

let numbers = [5, 12, 7, 20, 3]
let filtered = numbers.filter { number in
    number [1] 10
}

Drag options to blanks, or click blank then click option'

A<

B<=

C>

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > causes wrong filtering.

Using == filters only numbers equal to 10.

The where clause filters numbers greater than 10, so the operator should be >.

2fill in blank

medium

Complete the code to filter strings with length less than 5 using a where clause.

Swift

let words = ["apple", "cat", "banana", "dog"]
let shortWords = words.filter { word in
    word.count [1] 5
}

Drag options to blanks, or click blank then click option'

A<

B>=

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using > or >= filters longer words.

Using == filters only words with exactly 5 characters.

The where clause filters words with length less than 5, so the operator should be <.

3fill in blank

hard

Fix the error in the where clause to filter even numbers.

Swift

let nums = [1, 2, 3, 4, 5, 6]
let evens = nums.filter { num in
    num [1] 2 == 0
}

Drag options to blanks, or click blank then click option'

A%

B/

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using / divides the number and returns a quotient, not remainder.

Using * or + does not check evenness.

The modulo operator % checks if the remainder is zero, which means the number is even.

4fill in blank

hard

Fill both blanks to filter words starting with 'a' and having length greater than 3.

Swift

let words = ["apple", "ant", "bat", "arc", "axe"]
let filtered = words.filter { word in
    word.hasPrefix([1]) && word.count [2] 3
}

Drag options to blanks, or click blank then click option'

A"a"

B"b"

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong prefix string filters wrong words.

Using < filters shorter words, not longer.

The prefix should be "a" and length should be greater than 3, so > is correct.

5fill in blank

hard

Fill all three blanks to create a dictionary of words with their lengths, filtering words longer than 4 characters.

Swift

let words = ["swift", "code", "play", "learn"]
let wordLengths = [[1]: [2] for word in words where word.count [3] 4]

Drag options to blanks, or click blank then click option'

Aword

Bword.count

C>

Dword.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using word.length is invalid in Swift.

Using < filters shorter words, not longer.

The dictionary keys are words, values are their counts, and filter uses > 4 for length.

Practice

1. What is the main purpose of a where clause in Swift when used with generics?

easy

A. To define a function's return type

B. To declare a new generic type

C. To add extra conditions that generic types must satisfy

D. To create a loop over a collection

Solution

1. Step 1: Understand generics and constraints

   Generics allow flexible types, but sometimes we want to restrict them to certain types or protocols.

2. Step 2: Role of where clause

   The where clause adds extra conditions to generic parameters, ensuring they meet specific requirements.

3. Final Answer:

   To add extra conditions that generic types must satisfy -> Option C

4. Quick Check:

   Where clause = extra generic constraints [OK]

Hint: Where clauses add conditions to generics or loops [OK]

Common Mistakes:

• Confusing where clause with function return type
• Thinking where declares new types
• Using where to create loops

2. Which of the following is the correct syntax for using a where clause in a generic function in Swift?

easy

A. func example<T>(value: T) where T: Equatable {}

B. func example(value: T) {}

C. func example<T>(value: T) if T: Equatable {}

D. func example<T>(value: T) where T == Equatable {}

Solution

1. Step 1: Recall correct where clause syntax

   In Swift, the where clause comes after the generic parameter list and before the function body.

2. Step 2: Check each option

   func example<T>(value: T) where T: Equatable {} uses correct syntax: func example<T>(value: T) where T: Equatable {}. Others misuse placement or keywords.

3. Final Answer:

   func example<T>(value: T) where T: Equatable {} -> Option A

4. Quick Check:

   Where clause after generics = correct syntax [OK]

Hint: Where clause always follows generic parameters () [OK]

Common Mistakes:

• Placing where inside angle brackets
• Using if instead of where
• Using == instead of : for protocol conformance

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

func printIfEqual(_ a: T, _ b: U) where T == U, T: Equatable {
    if a == b {
        print("Equal")
    } else {
        print("Not Equal")
    }
}

printIfEqual(5, 5)
printIfEqual("hi", "hello")

medium

A. Equal\nEqual

B. Compilation error

C. Not Equal\nNot Equal

D. Equal\nNot Equal

Solution

1. Step 1: Understand the where clause constraints

   The function requires T and U to be the same type and conform to Equatable, so both arguments must be comparable and same type.

2. Step 2: Analyze the calls

   First call: 5 and 5 are Ints, equal, so prints "Equal". Second call: "hi" and "hello" are Strings, same type, but not equal, so prints "Not Equal".

3. Final Answer:

   Equal Not Equal -> Option D

4. Quick Check:

   Same type & Equatable check = output [OK]

Hint: Check type equality and Equatable conformance for output [OK]

Common Mistakes:

• Assuming different types allowed
• Expecting compilation error
• Ignoring Equatable conformance

4. Identify the error in this Swift function using a where clause:

func compareValues(a: T, b: U) where T: Comparable, U: Comparable {
    if a < b {
        print("a is less")
    } else {
        print("b is less or equal")
    }
}

medium

A. Missing return type in function signature

B. Cannot compare different generic types with < operator

C. where clause syntax is incorrect

D. Function parameters should be optional

Solution

1. Step 1: Understand the where clause constraints

   The function requires T and U to be Comparable, but they can be different types.

2. Step 2: Check the comparison operation

   Comparing a < b is invalid because Swift cannot compare two different types even if both are Comparable.

3. Final Answer:

   Cannot compare different generic types with < operator -> Option B

4. Quick Check:

   Different Comparable types can't be compared directly [OK]

Hint: Comparable types must be same to compare with < [OK]

Common Mistakes:

• Assuming Comparable allows cross-type comparison
• Ignoring type mismatch in operators
• Thinking where clause syntax is wrong

5. Given a generic function that filters an array of elements only if they conform to both Comparable and Numeric, which where clause correctly expresses this constraint?

func filterNumbers<T>(items: [T]) -> [T] where ... {
    return items.filter { $0 > 0 }
}

hard

A. T: Comparable & Numeric

B. T: Comparable, Numeric

C. T: Comparable where T: Numeric

D. T: Numeric or Comparable

Solution

1. Step 1: Understand multiple protocol constraints

   To require a type to conform to multiple protocols, use the & symbol between them.

2. Step 2: Analyze each option

   T: Comparable & Numeric correctly uses T: Comparable & Numeric. T: Comparable, Numeric uses comma which is invalid syntax. T: Comparable where T: Numeric misuses where inside where clause. T: Numeric or Comparable uses 'or' which is not valid.

3. Final Answer:

   T: Comparable & Numeric -> Option A

4. Quick Check:

   Use & to combine protocols in where clause [OK]

Hint: Use & to combine multiple protocol constraints [OK]

Common Mistakes:

• Using commas instead of &
• Misplacing where keyword
• Using 'or' instead of &