1class Candy:
  2    
  3    def __init__(self, mass, uranium):
  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):
 17        self._position = position
 18
 19    def get_position(self):
 20        return self._position
 21    
 22    def set_position(self, new_position):
 23        self._position = new_position
 24
 25
 26class Kid(Person):
 27    
 28    URANIUM_SUM_LIMIT = 20
 29    def __init__(self, position, initiative):
 30        super().__init__(position)
 31        self._initiative = initiative
 32        self._candies = []
 33
 34    def get_initiative(self):
 35        return self._initiative
 36    
 37    def add_candy(self, candy):
 38        self._candies.append(candy)
 39
 40    def is_critical(self):
 41        return sum(map(Candy.get_uranium_quantity, self._candies)) > self.URANIUM_SUM_LIMIT
 42    
 43
 44class Host(Person):
 45    
 46    def __init__(self, position, candies):
 47        super().__init__(position)
 48        self._candies = [Candy(*candy) for candy in candies]
 49
 50    def remove_candy(self, function_predicate):
 51        if not self._candies:
 52            return None
 53        else:
 54            candy_to_remove = function_predicate(self._candies)
 55            self._candies.remove(candy_to_remove)
 56            return candy_to_remove
 57    
 58    @staticmethod
 59    def get_max_candy(candies):
 60        return max(candies, key=lambda candy: candy._mass)
 61
 62
 63class FluxCapacitor:
 64    
 65    def __init__(self, participants):
 66        self._hosts = []
 67        self._kids = []
 68        for person in participants:
 69            if type(person) is Host:
 70                self._hosts.append(person)    
 71            else:
 72                self._kids.append(person)
 73
 74    def get_victim(self):
 75        kids_data = list(map(list, map(lambda kid: [kid, self._hosts.copy()], self._kids)))
 76        counter_all_hosts_already_visited = 0
 77        while counter_all_hosts_already_visited < len(self._hosts):
 78            counter_all_hosts_already_visited += 1
 79            host_data = list(map(lambda host: [], self._hosts))
 80            for kid_data in kids_data:
 81                closest_host = None
 82                closest_host_dist = -1
 83                curr_closest_host_index = 0
 84                closet_host_index = 0
 85                for host in kid_data[1]:
 86                    if host is None:
 87                        curr_closest_host_index += 1
 88                        continue
 89                    curr_dist_to_host = ((list(host._position)[0] - list(kid_data[0]._position)[0]) ** 2
 90                                          + (list(host._position)[1] - list(kid_data[0]._position)[1]) ** 2) ** 0.5
 91                    if closest_host_dist == -1 or closest_host_dist > curr_dist_to_host:
 92                        closest_host = host
 93                        closest_host_dist = curr_dist_to_host
 94                        closet_host_index = curr_closest_host_index
 95                    elif ((closest_host_dist == curr_dist_to_host) and
 96                    (host._position[0] < closest_host._position[0] or
 97                         (host._position[0] == closest_host._position[0] and
 98                          (host._position[1] < closest_host._position[1])))):
 99                        closest_host = host
100                        closest_host_dist = curr_dist_to_host
101                        closet_host_index = curr_closest_host_index
102                    curr_closest_host_index+=1
103
104                kid_data[0]._position = closest_host._position
105                host_data[closet_host_index].append(kid_data[0]) 
106                kid_data[1][closet_host_index] = None
107                
108            counter_curr_host = 0
109            for kids_going_to in host_data:
110                kids_going_to.sort(reverse=True, key=lambda kid: kid._initiative)
111                for kid in kids_going_to:  
112                    candy_to_add = self._hosts[counter_curr_host].remove_candy(Host.get_max_candy)
113                    if candy_to_add is not None:
114                        kid.add_candy(candy_to_add)
115                counter_curr_host+=1
116            kids_above_safe_uranium_level = set()
117            for kid in self._kids:
118                if kid.is_critical():
119                    kids_above_safe_uranium_level.add(kid)
120            if kids_above_safe_uranium_level:
121                return kids_above_safe_uranium_level
122        return None