1def max_candy_by_mass(candies: list):
  2    """Return the Candy with the most Mass."""
  3    return max(candies, key=lambda candy: candy.get_mass())
  4
  5
  6def get_host_with_min_distance(kid, hosts):
  7    """Return the Host with the least Distance to the Kid."""
  8    return min(hosts,
  9               key=(lambda host: (host.get_distance_to_person(kid), host.get_position()[0], host.get_position()[1])))
 10
 11
 12class Candy:
 13    """A Class that represents a Candy."""
 14
 15    def __init__(self, mass: float, uranium: float):
 16        self._mass = mass
 17        self._uranium = uranium
 18
 19    def get_mass(self):
 20        """Return the Mass of the Candy."""
 21        return self._mass
 22
 23    def get_uranium_quantity(self):
 24        """Return the total Amount of Uranium in the Candy."""
 25        return self._mass * self._uranium
 26
 27
 28class Person:
 29    """A Class that Represents a Person."""
 30
 31    def __init__(self, position: tuple):
 32        self._position = None
 33        self.set_position(position)
 34        self._basket = []
 35
 36    def get_position(self):
 37        """Return the Position of the Person."""
 38        return self._position
 39
 40    def set_position(self, position: tuple):
 41        """Change the Position of the Person."""
 42        self._position = position
 43
 44    def get_distance_to_person(self, person):
 45        """Return the Distance from the current Person to the passed in Person."""
 46        return ((self._position[0] - person.get_position()[0]) ** 2 + (
 47                self._position[1] - person.get_position()[1]) ** 2) ** 0.5
 48
 49    def is_basket_empty(self):
 50        """Return true if the Basket is empty."""
 51        return not self._basket
 52
 53    def __repr__(self):
 54        return f'{self._position}, Basket: {len(self._basket)}'
 55
 56
 57class Kid(Person):
 58    """A Class that represents a Kid."""
 59
 60    CRITICAL_URANIUM_AMOUNT_IN_GRAMS = 20
 61
 62    def __init__(self, position: tuple, initiative: int):
 63        super().__init__(position)
 64        self._initiative = initiative
 65
 66    def get_initiative(self):
 67        """Return the Initiative of the Kid."""
 68        return self._initiative
 69
 70    def add_candy(self, candy: Candy or None):
 71        """Add a Candy to the Basket."""
 72        if not candy:
 73            return
 74
 75        self._basket.append(candy)
 76
 77    def is_critical(self):
 78        """Return true if the Uranium Amount in the Basket is more than 20g."""
 79        return self.get_total_uranium_in_basket() > Kid.CRITICAL_URANIUM_AMOUNT_IN_GRAMS
 80
 81    def get_total_uranium_in_basket(self):
 82        """Get the total Amount of Uranium in the Basket."""
 83        return sum([candy.get_uranium_quantity() for candy in self._basket])
 84
 85    def __repr__(self):
 86        return (f'{super().__repr__()}, Initiative: {self._initiative},'
 87                f' Total Uranium: {self.get_total_uranium_in_basket():.2f}g')
 88
 89
 90class Host(Person):
 91    """A Class that represents a Host."""
 92
 93    def __init__(self, position: tuple, candies: list):
 94        super().__init__(position)
 95        self._basket = candies[:]
 96
 97    def remove_candy(self, candy_choosing_function):
 98        """Select a Candy from the Basket based on the passed in Function."""
 99        if not self._basket:
100            return None
101
102        chosen_candy = candy_choosing_function(self._basket)
103        self._basket.remove(chosen_candy)
104        return chosen_candy or None
105
106
107class FluxCapacitor:
108    """Class that represents a simulation of a Halloween night."""
109
110    def __init__(self, participants: set):
111        self._kids = []
112        self._hosts = []
113        self._hosts_visitation_table = {}
114        self._fill_participants(participants)
115
116    def _fill_participants(self, participants: set):
117        for participant in participants:
118            if type(participant) is Kid:
119                self._kids.append(participant)
120            else:
121                self._hosts.append(participant)
122
123    def get_victim(self):
124        """Simulate a Halloween night and return the first Kids that are critical."""
125        while not (critical_kids := self._simulate_one_iteration_of_trick_or_treat()):
126            if critical_kids is None:
127                return None
128
129        return set(critical_kids) or None
130
131    def _have_the_kids_visited_all_hosts(self):
132        """Return true if all the Kids have visited all the Hosts."""
133        return all([len(self._hosts_visitation_table.get(kid, set())) == len(self._hosts) for kid in self._kids])
134
135    def _simulate_one_iteration_of_trick_or_treat(self):
136        """Simulate one cycle of Kids taking Candy from Hosts.
137
138        Return the Kids that are critical after the Cycle or
139        None if the there are no more Kids or Hosts with Candy (The Simulation is over) or
140        an empty List if there are no critical Kids after the Cycle or
141        all the Kids have visited all the Hosts.
142        """
143
144        hosts_with_candies = list(filter(lambda curr_host: not curr_host.is_basket_empty(), self._hosts))
145        none_critical_kids_sorted_by_initiative = sorted(
146            filter(lambda curr_kid: not curr_kid.is_critical(), self._kids),
147            key=lambda curr_kid: curr_kid.get_initiative(), reverse=True
148        )
149
150        if (not none_critical_kids_sorted_by_initiative or
151                not hosts_with_candies or self._have_the_kids_visited_all_hosts()):
152            return None
153
154        critical_kids = []
155        for kid in none_critical_kids_sorted_by_initiative:
156            hosts_not_visited_by_current_kid = list(
157                filter(
158                    lambda curr_host: curr_host not in self._hosts_visitation_table.get(kid, set()),
159                    hosts_with_candies
160                )
161            )
162
163            if not hosts_not_visited_by_current_kid:
164                continue
165
166            min_dist_host = get_host_with_min_distance(kid, hosts_not_visited_by_current_kid)
167            kid.set_position(min_dist_host.get_position())
168
169            self._hosts_visitation_table[kid] = self._hosts_visitation_table.get(kid, set())
170            self._hosts_visitation_table[kid].add(min_dist_host)
171
172            removed_candy = min_dist_host.remove_candy(max_candy_by_mass)
173            kid.add_candy(removed_candy)
174
175            if kid.is_critical():
176                critical_kids.append(kid)
177
178        return critical_kids