names = ['Tasha', 'Bruce', 'Tony?', 'Steve?', 'Bucky']
known_names = []
taking = True
for name in names:
    if "?" in name:
        taking = False
    elif taking:
        known_names.append(name)

print(known_names)

Select one answer, then check.

• ['Tasha', 'Bruce']
  Correct. 'Tony?' contains a question mark, so taking becomes False. From then on nothing is appended, not even 'Bucky'.
• ['Tasha', 'Bruce', 'Tony?']
  Not quite. The name that matches the condition goes to the if branch, which only sets taking to False: it is never appended.
• ['Tasha', 'Bruce', 'Bucky']
  Not quite. That is what a Filter would give. Once taking is False it stays False, so 'Bucky' is not appended either.
• Tony?
  Not quite. The program prints the list known_names, not a single name.
• Bruce
  Not quite. The program prints the whole list known_names, not its last name.
• ['Tony?', 'Steve?', 'Bucky']
  Not quite. The Take pattern keeps the elements before the condition is first met, not the ones from that point on.

lowest = 100
grades = [90, 64, 72, 50]
for grade in grades:
    if lowest > grade:
        lowest = grade
print(lowest)

Select one answer, then check.

• Min/Max Pattern
  Correct. Each grade is compared with the accumulated lowest value and replaces it when it is lower: the Min pattern (here starting from 100 instead of the first element).
• Filter
  Not quite. A Filter builds a new list of the items that pass a condition; this loop keeps a single value.
• Take Pattern
  Not quite. There is no taking variable, and nothing stops the loop from looking at the later grades.
• Sum
  Not quite. Nothing is added up: lowest is replaced, not increased.
• Accumulator
  Not quite. The conditional compares each value with the accumulated value, which is what makes this the Min/Max pattern rather than a plain Accumulate.

def get_dog(animals: list[str]) -> str:
    last_dog = None
    for animal in animals:
        if "dog" in animal.lower():
            last_dog = animal
    return last_dog

Select one answer, then check.

• Find Pattern
  Correct. It walks through the whole list and keeps the last animal that matches the condition, starting from None: the Find pattern (find-last variant).
• Filter
  Not quite. A Filter would append every matching animal to a new list; this keeps only one.
• Take Pattern
  Not quite. Nothing stops the loop from taking elements: every animal is checked.
• Max Pattern
  Not quite. The condition doesn't compare each animal with the stored value; it only asks whether the animal is a dog.
• Accumulator
  Not quite. last_dog is replaced by a matching animal, not combined with every animal.