1import math
  2
  3MAX_INT = math.inf
  4MAX_URANIUM = 20
  5
  6class Candy:
  7    def __init__(self, mass, uranium):
  8        self.__mass = mass
  9        self.__uranium = uranium
 10
 11    def get_uranium_quantity(self):
 12        return self.__mass * self.__uranium
 13
 14    def get_mass(self):
 15        return self.__mass
 16
 17
 18class Person:
 19    def __init__(self, tuple_of_coordinates):
 20        self.tuple_of_coordinates = tuple_of_coordinates
 21
 22    def set_position(self, new_tuple_of_coordinates):
 23        self.tuple_of_coordinates = new_tuple_of_coordinates
 24
 25    def get_position(self):
 26        return self.tuple_of_coordinates
 27
 28
 29class Kid(Person):
 30    def __init__(self, tuple_of_coordinates, initiative):
 31        super().__init__(tuple_of_coordinates)
 32        self.__initiative = initiative
 33        self.box_of_candies = []
 34        self._level_of_uranium = 0.0
 35        self.sorted_hosts = []
 36        self.is_adult = False
 37        self.is_alive = True
 38
 39    def get_initiative(self):
 40        return self.__initiative
 41
 42    def add_candy(self, candy):
 43        self.box_of_candies.append(candy)
 44        self._level_of_uranium += candy.get_uranium_quantity()
 45
 46    def is_critical(self):
 47        return self._level_of_uranium > MAX_URANIUM
 48
 49    def __gt__(self, other):
 50        return self.get_initiative() > other.get_initiative()
 51
 52
 53class Host(Person):
 54    def __init__(self, tuple_of_coordinates, candies):
 55        super().__init__(tuple_of_coordinates)
 56        self.__candies = candies
 57        self.box_of_candies = [Candy(candy_params[0], candy_params[1]) for candy_params in candies]
 58        self.is_adult = True
 59        self.sorted_kids = []
 60
 61    @staticmethod
 62    def heaviest_candy(list_of_candies):
 63        max_candy = None
 64        max_candy_size = 0
 65        for candy in list_of_candies:
 66            if candy.get_mass() > max_candy_size:
 67                max_candy_size = candy.get_mass()
 68                max_candy = candy
 69
 70        return max_candy
 71
 72    @property
 73    def is_out_of_candy(self):
 74        return len(self.box_of_candies) == 0
 75
 76    def remove_candy(self, remove_candy_algorithm):
 77        if self.is_out_of_candy:
 78            return None
 79        return remove_candy_algorithm
 80
 81    def remove_candy_by_mass(self, list_of_candies):
 82        list_of_candies.remove(self.heaviest_candy(list_of_candies))
 83        return self.heaviest_candy(list_of_candies)
 84
 85
 86class FluxCapacitor:
 87    def __init__(self, participants):
 88        self.participants = participants
 89        self.kids = {}
 90        self.hosts = {}
 91        self.classify_participants()
 92
 93    @staticmethod
 94    def unalive_person(dict_of_people, person, is_alive):
 95        dict_of_people[person] = is_alive
 96
 97    @staticmethod
 98    def get_closest_distance_to_host(dict_of_hosts, target_coordinates):
 99        list_of_hosts = [host for host in dict_of_hosts]
100        min_distance = MAX_INT
101        min_coordinates = (MAX_INT, MAX_INT)
102        closest_host = None
103        for host in list_of_hosts:
104            tuple_of_coordinates = host.get_position()
105            distance = math.dist(tuple_of_coordinates, target_coordinates)
106            if distance < min_distance:
107                min_distance = distance
108                min_coordinates = tuple_of_coordinates
109                closest_host = host
110            elif distance == min_distance:
111                if tuple_of_coordinates[0] < min_coordinates[0]:
112                    min_coordinates = tuple_of_coordinates
113                    closest_host = host
114                elif tuple_of_coordinates[0] == min_coordinates[0]:
115                    min_coordinates = tuple_of_coordinates if tuple_of_coordinates[1] > min_coordinates[1] else min_coordinates
116                    closest_host = host if tuple_of_coordinates[1] < min_coordinates[1] else closest_host
117        return closest_host
118
119
120    def sort_hosts_by_distance_from_kid(self, kid):
121        copy_of_hosts = self.hosts.copy()
122        while len(copy_of_hosts) != 0:
123            closest_host = self.get_closest_distance_to_host(copy_of_hosts, kid.get_position())
124            if closest_host not in kid.sorted_hosts:
125                kid.sorted_hosts.append(closest_host)
126            popped = copy_of_hosts.pop(closest_host)
127
128        return kid.sorted_hosts
129
130    def sort_kids_by_initiative_for_host(self, host):
131        copy_of_kids = self.kids.copy()
132        for kid in copy_of_kids:
133            if host == self.get_closest_distance_to_host(self.hosts, kid.get_position()):
134                if kid not in host.sorted_kids and self.kids[kid] == False:
135                    host.sorted_kids.append(kid)
136        host.sorted_kids.sort(key=lambda kid:kid.get_initiative(), reverse=True)
137        return host.sorted_kids
138
139    def classify_participants(self):
140        for person in self.participants:
141            if not person.is_adult:
142                self.unalive_person(self.kids, person, False)
143            else:
144                if len(person.box_of_candies) != 0:
145                   self.unalive_person(self.hosts, person, False)
146
147    def get_victim(self):
148        dead_children = set()
149
150        while True:
151            if not self.hosts:
152                if bool(dead_children) != 0:
153                    return dead_children
154                else:
155                    return None
156            for kid in self.kids:
157                self.sort_hosts_by_distance_from_kid(kid)
158                closest_host = self.get_closest_distance_to_host(self.hosts, kid.get_position())
159
160                if self.kids[kid] is True:
161                    if kid in closest_host.sorted_kids:
162                        closest_host.sorted_kids.remove(kid)
163                    continue
164
165                try:
166                    out_of_candy = closest_host.is_out_of_candy
167                except AttributeError:
168                    continue
169
170                if closest_host.is_out_of_candy:
171                    kid.set_position(closest_host.get_position())
172
173                    if closest_host in kid.sorted_hosts:
174                        kid.sorted_hosts.remove(closest_host)
175                    continue
176
177                self.sort_kids_by_initiative_for_host(closest_host)
178                if kid == closest_host.sorted_kids[0]:
179
180                    given_candy = closest_host.heaviest_candy(closest_host.box_of_candies)
181                    kid.add_candy(given_candy)
182                    closest_host.remove_candy_by_mass(closest_host.box_of_candies)
183
184                    kid.set_position(closest_host.get_position())
185
186                    closest_host.sorted_kids.remove(kid)
187                    kid.sorted_hosts.remove(closest_host)
188
189                if kid.is_critical():
190                    dead_children.add(kid)
191                    self.unalive_person(self.kids, kid, True)
192
193                if closest_host.is_out_of_candy:
194                    self.hosts.pop(closest_host)
195
196            if bool(dead_children) != 0:
197                 return dead_children
198
199        return dead_children