map, filter, and reduce

Swift provides powerful functions for working with arrays: map, filter, and reduce. These functions allow you to transform, filter, and combine array elements.

Other languages

Before we go on, here’s some tips for users of other programming languages this year:

In this example, the function accepts one parameter called number and returns the square of that number. This function is applied to each of the numbers in the numbers array, creating a new array containing the squared numbers.

Filtering a array with filter

The filter function removes elements that don’t match a condition.

How does it work?

The basic structure of function looks like this:

let result = myArray.filter { item in
    return item == conditionalValue
}

Parts of map:

• { item in ... }: This is a function that takes one parameter:
  • item: The next value in the array.
  • The function must return true or false. If it returns true, the item is included in the new array.

Example: filtering for only even numbers

Using a for loop in Python:

numbers = [1, 2, 3, 4, 5]
even_numbers = []
for number in numbers:
    if number % 2 == 0:
        even_numbers.append(number)
print(even_numbers)  # Output: [2, 4]

Using filter in Swift:

let numbers = [1, 2, 3, 4, 5]
let evenNumbers = numbers.filter { number in
    return number % 2 == 0
}
print(evenNumbers) // Output: [2, 4]

In this example, removes any number that does not satisfy the condition (i.e., not even). That is because number % 2 == 0 is a Boolean expression that returns true or false.

📝 Task for filter

let words = ["apple", "cat", "banana", "dog", "grape", "kiwi"]

Combining elements with reduce

The reduce function is a way to combine all elements in a array into a single value. If you’ve used for loops in Python to sum numbers or join strings, reduce does the same thing, but in a more compact way.

How does it work?

The basic structure of reduce looks like this:

let result = array.reduce(initialValue) { result, item in
    return result + item
}

Parts of reduce:

• initialValue: This is where the total starts (like 0 for sum or "" for a sentence).
• { result, item in ... }: This is a function that takes two parameters:
  • result: The value so far.
  • item: The next value in the array.
  • In the function, you decide how to combine the items.

Example: adding numbers together

Using a for loop in Python:

numbers = [1, 2, 3, 4, 5]
total = 0
for number in numbers:
    total += number
print(total)  # Output: 15

Using reduce in Swift:

let numbers = [1, 2, 3, 4, 5]
let total = numbers.reduce(0) { result, number in
    return result + number
}
print(total) // Output: 15

Each number is added to the total, just like in the loop. However, using reduce avoids having to create a variable (which would, otherwise, never be modified). Remember that avoiding unnecessary var is a desirable behaviour in Swift as it makes code more secure by preventing accidental overwriting of data that should be protected!

Example 2: finding the largest number

Using a for loop in Python

values = [3, 7, 2, 8, 5]
max_value = values
for value in values:
    if value > max_value:
        max_value = value
print(max_value)  # Output: 8

let values = [3, 7, 2, 8, 5]
let maxValue = values.reduce(values) { result, number in
    return max(result, number)
}
print(maxValue)  // Output: 8

This checks each number and keeps the biggest one.

In the example, the initial value is set to the first value in the values array; the max function then compares that number (result, currently 3) with the next number (number, which is 7 in the first run). The largest value (7) is returned, replacing the initial value (and result) with 7. In the next run, 7 is compared with 2; as 7 is still the largest value, it is returned again.

Example 3: joining Words into a Sentence

Using a for loop in Python

words = ["Python", "is", "fun"]
sentence = ""
for word in words:
    sentence = sentence + " " + word.upper()
print(sentence)

Using reduce in Swift

let words = ["Swift", "is", "fun"]
let sentence = words.reduce("") { result, word in
    return result + " " + word.uppercased()
}
print(sentence) // Output: " SWIFT IS FUN"

This builds a sentence by adding spaces between words.

📝 Tasks for reduce

Task 1: numbers

let numbers = [7, 14, 21, 28, 35]

Task 2: strings

let words = ["apple", "banana", "grape", "strawberry", "kiwi"]

Summary

• map transforms elements into a new array.
• filter removes elements that don’t meet a condition.
• reduce combines elements into a single value.

These functions allow you to write more concise and functional Swift code.

📝 Task: Analysing student scores

You are given a array of student scores (out of 100). Your task is to process this array using map, filter, and reduce to find out the average score of students who passed (scored 50 or more).

Steps to Complete:

1. Use map to curve the scores by adding 5 extra points to each student’s score.
2. Use filter to keep only the passing scores (50 or more).
3. Use reduce to calculate the average score of the passing students.

Use the following input:

let scores = [45, 78, 89, 32, 50, 92, 67, 41, 99, 56]

Expected steps

1. Curve scores: [50, 83, 94, 37, 55, 97, 72, 46, 104, 61]
2. Keep passing scores: [50, 83, 94, 55, 97, 72, 104, 61]
3. Compute the average: (50 + 83 + 94 + 55 + 97 + 72 + 104 + 61) / 8 = 77
4. When you print the correct value, take a screenshot of your code and the result in the Terminal. Upload the screenshot to the “Map, Filter, and Reduce” assignment in Google Classroom.

🦸 For Super Players!

In this task, you will apply functional programming concepts in Swift using map, filter, and reduce to process and analyze movie ratings data. You will perform multiple transformations and calculations on the data using these higher-order functions.

You are provided with a dictionary where:

• The keys are movie titles (Strings).
• The values are arrays of integers representing user ratings (from 1 to 10).

let movieRatings: [String: ] = [
    "Inception": [9, 8, 10, 7, 6, 9, 8],
    "Interstellar": [10, 9, 10, 8, 7, 9],
    "The Dark Knight": [10, 10, 9, 9, 8, 10, 9],
    "Tenet": [7, 6, 8, 7, 5, 6, 7],
    "Dunkirk": [8, 9, 7, 8, 7, 8]
]

Steps

1. Calculate Average Ratings (using mapValues)
   • Convert the dictionary into one where each movie title maps to its average rating.
   • Hint: use mapValues instead of map. This only extracts and transforms the values from the dictionary, leaving the keys intact. This means the new dictionary will have the same keys but new values; in this case, the new value is the average rating.
2. Filter Movies with High Ratings (using filter)
   • Extract only movies with an average rating of 8.0 or higher.
3. Find the Highest Rated Movie (using map and reduce)**
   • Extract the highest-rated movie from the filtered movies.
   • Hint: Use map to get an array of tuples (title, averageRating), then reduce to find the highest.
4. Count Movies in Each Rating Category (using filter and reduce)**
   • Count how many movies fall into these rating categories:
     • 8.0 or higher
     • Between 6.0 and 7.99
     • Below 6.0
     • Hint: Use filter to classify movies into different categories, then reduce to count them.
5. Find the Total Number of Ratings Given (Using map and reduce)**
   • Compute the total number of ratings submitted across all movies.
   • Hint: Use map to extract the number of ratings per movie, then reduce to sum them.
6. Find the Highest Rated Movie Title in One Call (Using map, filter, and reduce Together)**
   • Find the title of the highest-rated movie (average rating of 8.0 or higher) in one functional chain.
   • Hint:
     1. Use map to create an array of tuples (title, averageRating).
     2. Use filter to remove movies with an average rating below 8.0.
     3. Use reduce to determine the movie with the highest rating.

Transforming an array with map

The map function applies a transformation to each element in a array and returns a new array with the modified values.

How does it work?

The basic structure of map looks like this:

let result = myArray.map { item in
    return doSomethingTo(item)
}

Parts of map:

• { item in ... }: This is a function that takes one parameter:
  • item: The next value in the array.
  • In your function, you decide how to transform each value.

Example: finding the square of numbers

Using a for Loop in Python:

numbers = [1, 2, 3, 4, 5]
squared_numbers = []
for number in numbers:
    squared_numbers.append(number * number)
print(squared_numbers)  # Output: [1, 4, 9, 16, 25]

Using map in Swift:

let numbers = [1, 2, 3, 4, 5]
let squaredNumbers = numbers.map { number in
    return number * number
}
print(squaredNumbers) // Output: [1, 4, 9, 16, 25]

📝 Task for map

let numbers = [1, 3, 5, 7, 9]