messages = ["go", "fly", "a", "kite"]

def join_strings(messages: list[str]) -> str:
    result = ""
    for message in messages:
        result = result + ", " + message
    return result

def map_title_case(messages: list[str]) -> list[str]:
    result = []
    for message in messages:
        result.append(message.title())
    return result

# ____ <-- What goes here?

print(messages)

Select every option that applies, then check.

• map_title_case(messages)
  join_strings(messages)
  

  Not quite. Both calls return new values, but nothing stores them: messages still holds the original lowercase list, so print(messages) shows it unchanged.

• messages = join_strings(map_title_case(messages))
  

  Correct. The title-cased list that map_title_case returns goes straight into join_strings, and the joined string is stored back in messages before it is printed.

• map_title_case()
  join_strings()
  

  Not quite. Both functions have a messages parameter, so calling them without an argument raises a TypeError.

• join_strings(map_title_case(messages))
  

  Not quite. The composition is right, but its result is thrown away: messages is never updated, so the original list is printed.

• print(map_title_case(messages))
  print(join_strings(messages))
  

  Not quite. This prints the title-cased list, then the original lowercase strings joined together, and the final print(messages) still shows the original list.

• messages = map_title_case(messages)
  messages = join_strings(messages)
  

  Correct. The same composition in two steps: messages first holds the title-cased list, then the joined string.
• None are necessary, because the variables share the same name.
  Not quite. The messages parameters are local to each function; the global messages only changes when you assign a function's result to it.

What are advantages and reasons to compose loops?

Select every option that applies, then check.

• Breaking up complex loops into separate functions makes each function easier to debug.
  Correct. Each function only does one thing, so if you make a mistake, you can track it down very quickly.
• Smaller loop functions are easier to write because each piece is simpler.
  Correct. A helper that applies one pattern is relatively easy to define and test, compared to one loop that combines several patterns.
• Loop composition makes loops faster because they are broken up.
  Not quite. Composition makes code easier to write, test and debug, not faster: each helper usually walks through the list again.
• Loop composition takes less time because variables can be shared between the functions.
  Not quite. Each function has its own local variables; values move between the functions as arguments and return values.
• We don't need loops at all if we are composing functions.
  Not quite. The loops are still there, inside the helper functions; composing just keeps each loop small.

def average(numbers: list[int]) -> float:
    if not numbers:
        return None
    for number in numbers:
        return sum(numbers) / count(numbers)

Select one answer, then check.

• This function does not need a for loop.
  Correct. sum and count already loop over the list. The for loop returns during its first pass, so it adds nothing: return sum(numbers) / count(numbers) on its own is enough.
• This code is perfectly fine.
  Not quite. It returns the right value, but only because the loop returns straight away on its first pass: the loop serves no purpose.
• The arguments to sum and count should be number, not numbers.
  Not quite. sum and count consume a whole list; number is a single element of it.
• You shouldn't need to sum or count in order to calculate the average of a list of numbers.
  Not quite. The average is the sum of the elements divided by the number of elements, so you need both.
• You cannot check whether a list is empty with the condition in the if statement.
  Not quite. An empty list is falsy, so if not numbers: is exactly how to guard against an empty list.
• The result of the count function needs to be passed as an argument to the sum function.
  Not quite. The two results are divided, sum(numbers) / count(numbers); neither function consumes the other's result.

def convert_grade(grade: int) -> str:
    pass

def map_convert_grades(grades: list[int]) -> list[str]:
    pass

def remove_failed_grades(text_grades: list[str]) -> list[str]:
    pass

def get_passing_text_grades(grades: list[int]) -> list[str]:
    pass

Select every option that applies, then check.

• The map_convert_grades function will directly call convert_grade
  Correct. map_convert_grades applies the Map pattern: it calls convert_grade on each grade in the list.
• The get_passing_text_grades function will directly call remove_failed_grades
  Correct. After converting, the main function filters the text grades with remove_failed_grades, which consumes and produces a list of strings.
• The get_passing_text_grades function will directly call map_convert_grades
  Correct. The main function first turns its list of integer grades into text grades with map_convert_grades: remove_failed_grades(map_convert_grades(grades)).
• The get_passing_text_grades function will directly call convert_grade
  Not quite. convert_grade handles a single grade, while the main function works on whole lists, so it reaches convert_grade through map_convert_grades.
• The remove_failed_grades function will directly call convert_grade
  Not quite. remove_failed_grades consumes text grades (strings), but convert_grade consumes an integer.
• The map_convert_grades function will directly call remove_failed_grades
  Not quite. map_convert_grades should only convert every grade; removing failed grades is a separate step.
• The map_convert_grades function will directly call get_passing_text_grades
  Not quite. get_passing_text_grades is the main function that calls map_convert_grades; calling it back would go round in circles.
• The convert_grade function will directly call get_passing_text_grades
  Not quite. convert_grade works on one integer grade; it has no use for the main function, which consumes a whole list.