Sorted and custom comparators in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift sorting code?

Consider the following Swift code that sorts an array of strings by their length in ascending order. What will be printed?

Swift

let words = ["apple", "banana", "fig", "date"]
let sortedWords = words.sorted { $0.count < $1.count }
print(sortedWords)

A ["apple", "banana", "date", "fig"]

B ["banana", "apple", "date", "fig"]

C ["fig", "date", "apple", "banana"]

D ["fig", "apple", "date", "banana"]

💡 Hint

Think about sorting by the number of letters in each word.

The code sorts the array by the length of each string from shortest to longest. "fig" has 3 letters, "date" 4, "apple" 5, and "banana" 6, so the sorted array is ["fig", "date", "apple", "banana"].

🧠 Conceptual

intermediate

Which option correctly sorts integers descending using a custom comparator?

In Swift, you want to sort an array of integers from largest to smallest. Which sorting call correctly achieves this?

A numbers.sorted(by: >)

B numbers.sorted(by: <)

C numbers.sorted { $0 < $1 }

D numbers.sorted { $0 == $1 }

💡 Hint

Think about the comparison operator that returns true when the first number is bigger.

Using the greater-than operator (>) sorts the array descending. The less-than operator (<) sorts ascending. The closure with equality (==) does not define a strict order and will not sort properly.

🔧 Debug

advanced

What error does this Swift sorting code produce?

Examine this Swift code snippet. What error will it cause when compiled?

Swift

let names = ["Anna", "Bob", "Charlie"]
let sortedNames = names.sorted { $0 > }
print(sortedNames)

A SyntaxError: Missing second operand in closure

B TypeError: Cannot compare String and Int

C RuntimeError: Index out of range

D No error, prints ["Charlie", "Bob", "Anna"]

💡 Hint

Look carefully at the closure syntax inside the sorted method.

The closure { $0 > } is incomplete because it lacks the second operand to compare with $0. This causes a syntax error.

❓ Predict Output

advanced

What is the output of this Swift code sorting tuples by second element?

Given the array of tuples, what will be printed after sorting by the second element ascending?

Swift

let pairs = [("a", 3), ("b", 1), ("c", 2)]
let sortedPairs = pairs.sorted { $0.1 < $1.1 }
print(sortedPairs)

A [("c", 2), ("b", 1), ("a", 3)]

B [("b", 1), ("c", 2), ("a", 3)]

C [("b", 1), ("a", 3), ("c", 2)]

D [("a", 3), ("c", 2), ("b", 1)]

💡 Hint

Focus on sorting by the second value in each tuple.

The sorting closure compares the second element of each tuple. The order by second element ascending is 1, 2, then 3, so the sorted array is [("b", 1), ("c", 2), ("a", 3)].

🚀 Application

expert

How many items are in the resulting array after this custom sort and filter?

Consider this Swift code that filters and sorts an array of integers. How many items remain after running it?

Swift

let numbers = [5, 3, 8, 1, 9, 2]
let filteredSorted = numbers.filter { $0 % 2 == 0 }.sorted(by: >)
print(filteredSorted.count)

A 5

B 3

C 4

D 2

💡 Hint

First find even numbers, then count how many remain after sorting.

The filter keeps only even numbers from [5, 3, 8, 1, 9, 2]: 8 and 2. After sorting descending: [8, 2]. The count is 2.

Practice

1. What does the sorted(by:) method do in Swift?

easy

A. It sorts an array using a custom rule you provide.

B. It removes duplicate elements from an array.

C. It reverses the order of elements in an array.

D. It filters elements based on a condition.

Solution

1. Step 1: Understand the purpose of sorted(by:)

   This method sorts elements of an array based on a closure that defines the order.

2. Step 2: Compare with other array methods

   Unlike filtering or reversing, sorted(by:) changes order based on a custom rule.

3. Final Answer:

   It sorts an array using a custom rule you provide. -> Option A

4. Quick Check:

   sorted(by:) = custom sorting [OK]

Hint: Remember: sorted(by:) arranges items your way [OK]

Common Mistakes:

• Confusing sorting with filtering
• Thinking it removes duplicates
• Assuming it reverses the array

2. Which of the following is the correct syntax to sort an array of integers in descending order using sorted(by:)?

easy

A. let sortedArray = numbers.sorted(by: { $1 > $0 })

B. let sortedArray = numbers.sorted(by: { $0 < $1 })

C. let sortedArray = numbers.sorted()

D. let sortedArray = numbers.sorted(by: { $0 > $1 })

Solution

1. Step 1: Understand sorting order

   To sort descending, the comparator must return true when the first element is greater than the second.

2. Step 2: Check each option

   let sortedArray = numbers.sorted(by: { $0 > $1 }) uses { $0 > $1 } which sorts descending. let sortedArray = numbers.sorted(by: { $0 < $1 }) sorts ascending. let sortedArray = numbers.sorted() sorts ascending by default. let sortedArray = numbers.sorted(by: { $1 > $0 }) reverses the comparison incorrectly.

3. Final Answer:

   let sortedArray = numbers.sorted(by: { $0 > $1 }) -> Option D

4. Quick Check:

   Descending sort uses $0 > $1 [OK]

Hint: Use $0 > $1 for descending sort [OK]

Common Mistakes:

• Using $0 < $1 for descending
• Forgetting to provide closure for custom order
• Confusing parameter order in closure

3. What is the output of the following Swift code?

let names = ["Anna", "Bob", "Charlie"]
let sortedNames = names.sorted(by: { $0.count < $1.count })
print(sortedNames)

medium

A. ["Bob", "Charlie", "Anna"]

B. ["Bob", "Anna", "Charlie"]

C. ["Charlie", "Anna", "Bob"]

D. ["Anna", "Bob", "Charlie"]

Solution

1. Step 1: Understand the sorting rule

   The closure sorts by string length ascending: shorter names come first.

2. Step 2: Apply sorting to the array

   "Bob" has 3 letters, "Anna" 4, "Charlie" 7. So order is ["Bob", "Anna", "Charlie"].

3. Final Answer:

   ["Bob", "Anna", "Charlie"] -> Option B

4. Quick Check:

   Sort by length ascending = ["Bob", "Anna", "Charlie"] [OK]

Hint: Sort by $0.count < $1.count for shortest first [OK]

Common Mistakes:

• Sorting alphabetically instead of by length
• Confusing < with > in closure
• Expecting original order

4. Identify the error in this Swift code that tries to sort an array of tuples by the second value:

let items = [("a", 3), ("b", 1), ("c", 2)]
let sortedItems = items.sorted(by: { $0.1 > $1.1 })
print(sortedItems)

medium

A. There is no error; the code sorts descending by second value.

B. The tuple elements cannot be accessed by index like $0.1.

C. The closure parameters should be $1.1 > $0.1 for ascending order.

D. The sorting closure must return an Int, not Bool.

Solution

1. Step 1: Check tuple access syntax

   Accessing tuple elements by $0.1 and $1.1 is correct in Swift closures.

2. Step 2: Verify sorting closure logic

   The closure returns true if first element's second value is greater, sorting descending by second value.

3. Final Answer:

   There is no error; the code sorts descending by second value. -> Option A

4. Quick Check:

   Tuple access and Bool return are correct [OK]

Hint: Tuple elements accessed as $0.1; closure returns Bool [OK]

Common Mistakes:

• Thinking tuple elements can't be accessed by index
• Expecting closure to return Int
• Confusing ascending and descending order

5. You have an array of dictionaries representing people: let people = [["name": "Alice", "age": 30], ["name": "Bob", "age": 25], ["name": "Charlie", "age": 30]]. How do you sort this array first by age ascending, then by name ascending if ages are equal?

hard

A. people.sorted { $0["age"] as! Int < $1["age"] as! Int && $0["name"] as! String < $1["name"] as! String }

B. people.sorted(by: { $0["age"] as! Int > $1["age"] as! Int || $0["name"] as! String > $1["name"] as! String })

C. people.sorted { ($0["age"] as! Int, $0["name"] as! String) < ($1["age"] as! Int, $1["name"] as! String) }

D. people.sorted(by: { $0["name"] as! String < $1["name"] as! String })

Solution

1. Step 1: Understand sorting by multiple keys

   Sorting by age ascending, then name ascending means comparing tuples of (age, name).

2. Step 2: Check each option's logic

   people.sorted { ($0["age"] as! Int, $0["name"] as! String) < ($1["age"] as! Int, $1["name"] as! String) } compares tuples directly, which sorts by age first, then name if ages equal. people.sorted { $0["age"] as! Int < $1["age"] as! Int && $0["name"] as! String < $1["name"] as! String } uses && which fails for correct ordering. people.sorted(by: { $0["age"] as! Int > $1["age"] as! Int || $0["name"] as! String > $1["name"] as! String }) sorts descending and mixes conditions incorrectly. people.sorted(by: { $0["name"] as! String < $1["name"] as! String }) sorts only by name.

3. Final Answer:

   people.sorted { ($0["age"] as! Int, $0["name"] as! String) < ($1["age"] as! Int, $1["name"] as! String) } -> Option C

4. Quick Check:

   Tuple comparison sorts by multiple keys [OK]

Hint: Compare tuples (age, name) for multi-level sorting [OK]

Common Mistakes:

• Using && instead of tuple comparison
• Sorting only by one key
• Mixing ascending and descending incorrectly