1class Potion:
  2
  3    def __init__(self, effects, duration) :
  4        self.effects = effects
  5        self.duration = duration
  6        self.intensity_of_effects = {effect: 1 for effect in self.effects}  
  7        self.used = False
  8        self.chemical_mix = False
  9
 10    def __add__(self, other):
 11        self.check_and_raise_error()
 12        other.check_and_raise_error()
 13
 14        combined_effects = dict(self.effects)
 15        for effect_name, effect_function in other.effects.items():
 16            if effect_name in combined_effects:
 17                combined_effects[effect_name] = lambda target: (
 18                self.effects[effect_name](target),
 19                effect_function(target)
 20                )
 21            else:
 22                combined_effects[effect_name] = effect_function
 23        result_duration = max(self.duration, other.duration)
 24        result_potion = Potion(combined_effects, result_duration)
 25        result_potion.intensity_of_effects = {
 26            effect_name: self.intensity_of_effects.get(effect_name, 0) + other.intensity_of_effects.get(effect_name, 0)
 27            for effect_name in combined_effects}
 28        self.used = True
 29        self.chemical_mix = True
 30        other.used = True
 31        self.chemical_mix = True
 32        return result_potion
 33
 34    def __sub__(self, other):
 35        if not set(other.effects.keys()).issubset(self.effects.keys()):
 36            raise TypeError("Cannot subtract potion with different effects.")
 37        self.check_and_raise_error()
 38        other.check_and_raise_error()
 39
 40        result_potion = Potion(dict(self.effects), self.duration)
 41        for effect_name, intensity in other.intensity_of_effects.items():
 42            result_potion.intensity_of_effects[effect_name] = result_potion.intensity_of_effects[effect_name] - intensity \
 43                if (result_potion.intensity_of_effects[effect_name] - intensity) > 0 \
 44                else result_potion.intensity_of_effects.pop(effect_name, None)
 45        return result_potion
 46    
 47    def __mul__(self, factor):
 48        if not isinstance(factor, int) or factor <= 0:
 49            raise ValueError("Factor must be a positive integer.")
 50        self.check_and_raise_error()
 51
 52        result_potion = Potion(dict(self.effects), self.duration)
 53        result_potion.intensity_of_effects = {
 54            effect_name: round(intensity * factor) if factor < 1 else intensity * factor
 55            for effect_name, intensity in self.intensity_of_effects.items()
 56        }
 57        return result_potion
 58
 59    def __truediv__(self, divisor):
 60        if not isinstance(divisor, int) or divisor <= 0:
 61            raise ValueError("Divisor must be a positive integer.")
 62        self.check_and_raise_error()
 63        result_potions = [Potion(dict(self.effects), self.duration) for _ in range(divisor)]
 64        for effect_name, intensity in self.intensity_of_effects.items():
 65            divided_intensity = int(intensity / divisor) if intensity % divisor <= 0.5 else int(intensity / divisor) + 1
 66            for result_potion in result_potions:
 67                result_potion.intensity_of_effects[effect_name] = divided_intensity
 68        return tuple(result_potions)
 69
 70    def __getattr__(self, name):
 71        if self.used:
 72            raise TypeError("Potion is now part of something bigger than itself.")
 73
 74        if name in self.effects:
 75            return lambda target: self.apply_effect(name, target)
 76        else:
 77            raise AttributeError(f"'Potion' object has no attribute '{name}'.")
 78
 79    def __eq__(self, other):
 80        return self.effects == other.effects and self.intensity_of_effects == other.intensity_of_effects
 81
 82    def __lt__(self, other):
 83        return sum(self.intensity_of_effects.values()) < sum(other.intensity_of_effects.values())
 84
 85    def __gt__(self, other):
 86        return sum(self.intensity_of_effects.values()) > sum(other.intensity_of_effects.values())
 87    
 88    def _check_effects(self):
 89        if self.used is False:
 90            self.used = all(self.intensity_of_effects[effect_name] == 0 for effect_name in self.effects)
 91    
 92    def check_and_raise_error(self):
 93        if self.chemical_mix:
 94            raise TypeError("Potion is now part of something bigger than itself.")
 95        self._check_effects()
 96        if self.used:
 97            raise TypeError("Potion is depleted.")  
 98        
 99    def apply_effect(self, effect_name, target):
100        self.check_and_raise_error()
101
102        if effect_name not in self.effects:
103            raise ValueError(f"Effect '{effect_name}' not found in potion effects.")
104
105        if self.intensity_of_effects[effect_name] == 0:
106            raise TypeError("Effect is depleted.")
107
108        self.effects[effect_name](target)
109        self.intensity_of_effects[effect_name] -= 1
110        
111
112class ГоспожатаПоХимия:
113
114    def __init__(self):
115        self.tick_count = 0
116
117    def apply(self, target, potion):
118        potion.check_and_raise_error()
119
120        effects_sorted = sorted(potion.effects.keys(), key=lambda effect: sum(map(ord, effect)), reverse=True) 
121        for effect_name in effects_sorted:
122            try:
123                potion.apply_effect(effect_name, target)
124            except TypeError: # in order to aplly all effects
125                continue
126        potion.used = True
127
128    def tick(self):
129        self.tick_count += 1
130
131    def reset_tick(self):
132        self.tick_count = 0