1class Candy:
  2
  3    def __init__(self, mass: int, uranium: float):
  4        self._mass = mass
  5        self._uranium = uranium
  6
  7    def get_uranium_quantity(self):
  8        return self._mass * self._uranium
  9
 10    def get_mass(self):
 11        return self._mass
 12
 13
 14class Person:
 15
 16    def __init__(self, position: tuple):
 17        self._position = position
 18
 19    def get_position(self):
 20        return self._position
 21
 22    def set_position(self, position: tuple):
 23        self._position = position
 24
 25
 26class Kid(Person):
 27
 28    _critical_mass = 20
 29
 30    def __init__(self, position: tuple, initiative):
 31        super().__init__(position)
 32        self._initiative = initiative
 33        self._bag = []
 34
 35    def get_initiative(self):
 36        return self._initiative
 37
 38    def add_candy(self, candy: Candy):
 39        self._bag.append(candy)
 40
 41    def is_critical(self):
 42        radianion = 0
 43        for candy in self._bag:
 44            radianion += candy.get_uranium_quantity()
 45        return radianion > self._critical_mass
 46
 47
 48class Host(Person):
 49
 50    def __init__(self, position: tuple, candies: list):
 51        super().__init__(position)
 52        self._candies = []
 53        for candy in candies:
 54            self._candies.append(Candy(*candy))
 55
 56    def remove_candy(self, candy_criteria):
 57        if self._candies:
 58            selected_candy = candy_criteria(self._candies)
 59            self._candies.remove(selected_candy)
 60            return selected_candy
 61        return None
 62
 63
 64class FluxCapacitor:
 65
 66    def __init__(self, participants: set):
 67        self._kids = set()
 68        self._hosts = set()
 69        for person in participants:
 70            if isinstance(person, Kid):
 71                self._kids.add(person)
 72            else:
 73                self._hosts.add(person)
 74        self._kids = sorted(self._kids, key=lambda kid: kid.get_initiative(), reverse=True)
 75
 76    def get_victim(self):
 77        if len(self._hosts) == 0:
 78            return None
 79
 80        unvisited = {}
 81        for kid in self._kids:
 82            unvisited[kid.get_initiative()] = set()
 83            for host in self._hosts:
 84                unvisited[kid.get_initiative()].add(host.get_position())
 85
 86        while unvisited:
 87            for kid in self._kids:
 88                curr_pos = kid.get_position()
 89                next_pos =FluxCapacitor.closest_host(curr_pos, unvisited[kid.get_initiative()])
 90                kid.set_position(next_pos)
 91                for host in self._hosts:
 92                    if next_pos == host.get_position():
 93                        candy = host.remove_candy(FluxCapacitor.candy_criteria)
 94                        break
 95                if candy is not None:
 96                    kid.add_candy(candy)
 97                unvisited[kid.get_initiative()].remove(next_pos)
 98                if len(unvisited[kid.get_initiative()]) == 0:
 99                    unvisited.pop(kid.get_initiative())
100
101            kids_with_critical_mass = self._critical_mass_check()
102            if kids_with_critical_mass:
103                return kids_with_critical_mass
104
105        return None
106
107    def _critical_mass_check(self):
108        kids_with_critical_mass = set()
109        for kid in self._kids:
110            if kid.is_critical():
111                kids_with_critical_mass.add(kid)
112        return kids_with_critical_mass
113
114    @staticmethod
115    def closest_host(pos: tuple, remaining_hosts: set):
116        closest_dist = None
117
118        for host in remaining_hosts:
119            dist = ((pos[0] - host[0]) * (pos[0] - host[0])
120                        + (pos[1] - host[1]) * (pos[1] - host[1]))
121            if (closest_dist is None or dist < closest_dist
122                or (dist == closest_dist and next_pos[0] < pos[0])
123                or (dist == closest_dist and next_pos[0] == pos[0] and next_pos[1] < pos[1])):
124                closest_dist = dist
125                next_pos = host
126        return next_pos
127
128    @staticmethod
129    def candy_criteria(candies: list[Candy]):
130        chosen_candy = Candy(0, 0)
131        for candy in candies:
132            if candy.get_mass() > chosen_candy.get_mass():
133                chosen_candy = candy
134        return chosen_candy