Example 1: Using map in Swift

Swift’s map function transforms each element in a collection based on a provided closure.

let numbers = [1, 2, 3, 4]
let squaredNumbers = numbers.map { $0 * $0 }
print(squaredNumbers)  // Output: [1, 4, 9, 16]

• What happens under the hood? map iterates through each element of the array, applying the closure. The time complexity is O(n), where n is the number of elements.
• Optimizations to consider: For extremely large datasets, could the operation benefit from parallel processing or streaming the data?

Example 2: Choosing the Right Data Structure

Imagine you need to count the occurrences of words in a list. Swift’s Dictionary is a great choice because it provides efficient key-based lookups.

let words = ["apple", "banana", "apple", "orange", "banana", "apple"]
var wordCount: [String: Int] = [:]

for word in words {
    wordCount[word, default: 0] += 1
}

print(wordCount)  // Output: ["apple": 3, "banana": 2, "orange": 1]

• Time Complexity: The dictionary’s key lookup and insertion operations are O(1) on average, making it an efficient choice.
• Why this matters: Using an array instead would require a linear search for each word, resulting in O(n²) complexity.

Example 3: Sorting with Algorithms

Swift provides a built-in sort method, but understanding sorting algorithms can help you decide whether it’s the best choice for your use case.

let unsortedNumbers = [5, 3, 8, 1, 2]
let sortedNumbers = unsortedNumbers.sorted()
print(sortedNumbers)  // Output: [1, 2, 3, 5, 8]

• What happens under the hood? Swift’s sorted() uses an optimized implementation of the Timsort algorithm, which has a time complexity of O(n log n) in the worst case.
• When to consider alternatives: If you know your dataset is nearly sorted, a simpler algorithm like insertion sort (O(n)) might perform better for small datasets.

Example 4: Functional Programming with reduce

Using reduce, you can compute aggregated results in a single pass.

let numbers = [1, 2, 3, 4]
let sumOfSquares = numbers.reduce(0) { $0 + $1 * $1 }
print(sumOfSquares)  // Output: 30

• What happens under the hood? reduce iterates through the array, combining each element with an accumulated result. Time complexity is O(n).
• Pitfall to avoid: Ensure the initial value (0 in this case) and the closure logic are correct to avoid subtle bugs.

Bridging the Gap Between Tools and Fundamentals

Swift’s standard library functions, while powerful, are only as good as the developer’s understanding. For instance:

• map, filter, and reduce are great for concise functional transformations, but they iterate over the entire collection. For lazy evaluation, consider using Sequence with methods like lazy.map:

let numbers = (1...1_000_000).lazy.map { $0 * 2 }
print(numbers.prefix(5))  // Output: [2, 4, 6, 8, 10]

Practice Problem: Find the Top K Frequent Elements

This example combines data structures and algorithms to solve a practical problem efficiently.

let numbers = [1, 1, 1, 2, 2, 3]
let k = 2

func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
    var frequency: [Int: Int] = [:]
    for num in nums {
        frequency[num, default: 0] += 1
    }
    
    let sortedFrequencies = frequency.sorted { $0.value > $1.value }
    return sortedFrequencies.prefix(k).map { $0.key }
}

print(topKFrequent(numbers, k))  // Output: [1, 2]

• Data Structure Used: Dictionary for frequency counting (O(n)).
• Algorithm Applied: Sorting the dictionary values (O(n log n)).