1import math
  2
  3
  4class Potion:
  5    def __init__(self, effects, duration, intensities=None):
  6        self.effects = effects
  7        self.intensities = intensities or {effect: 1 for effect in effects}
  8        self.duration = duration
  9        self.remaining_duration = duration
 10        self.initial_state = None
 11        self.applied_effects = set()
 12        self.used = False
 13
 14        for effect_name in effects:
 15            setattr(self, effect_name, lambda target, name=effect_name: self.apply_effect(name, target))
 16
 17    def apply_effect(self, effect, target, intensity=1):
 18        if self.used:
 19            raise TypeError("Potion is now part of something bigger than itself.")
 20
 21        if effect in self.applied_effects:
 22            raise TypeError("Effect is depleted.")
 23
 24        if effect in self.effects:
 25            if effect in self.intensities:
 26                intensity = self.intensities[effect]
 27
 28            if self.initial_state is None:
 29                self.initial_state = self.save_state(target)
 30
 31            for _ in range(intensity):
 32                self.effects[effect](target)
 33            self.applied_effects.add(effect)
 34        else:
 35            raise ValueError("Invalid effect name.")
 36
 37    def apply_all_effects(self, target):
 38        for effect in self.effects:
 39            self.apply_effect(effect, target)
 40
 41    def save_state(self, target):
 42        return vars(target).copy()
 43
 44    def revert_state(self, target):
 45        if self.initial_state is not None:
 46            for attr, value in self.initial_state.items():
 47                setattr(target, attr, value)
 48
 49    def round_intensity(self, intensity, power):
 50        if not isinstance(power, int) or power < 1:
 51            return math.floor(intensity * power) if intensity <= power else math.ceil(intensity * power)
 52        else:
 53            return intensity * power
 54
 55    def __add__(self, other):
 56        combined_effects = {}
 57        combined_intensities = {}
 58
 59        for effect, intensity in self.intensities.items():
 60            combined_effects[effect] = self.effects[effect]
 61            combined_intensities[effect] = intensity
 62
 63        for effect, intensity in other.intensities.items():
 64            if effect in combined_effects:
 65                combined_intensities[effect] += intensity
 66            else:
 67                combined_effects[effect] = other.effects[effect]
 68                combined_intensities[effect] = intensity
 69        combined_duration = max(self.duration, other.duration)
 70        self.used = True
 71        return Potion(combined_effects, combined_duration, intensities=combined_intensities)
 72
 73    def __mul__(self, power):
 74        updated_effects = {}
 75        updated_intensities = {}
 76
 77        for effect, intensity in self.intensities.items():
 78            updated_effects[effect] = self.effects[effect]
 79            updated_intensities[effect] = self.round_intensity(intensity, power)
 80
 81        self.used = True
 82        return Potion(updated_effects, self.duration * power, intensities=updated_intensities)
 83
 84    def __sub__(self, other):
 85        if not isinstance(other, Potion):
 86            raise TypeError("Subtraction can only be performed with another Potion.")
 87        if not all(effect in self.effects for effect in other.effects):
 88            raise TypeError("Cannot subtract. 'self' does not contain all effects of 'other'.")
 89
 90        subtracted_effects = {}
 91        subtracted_intensities = {}
 92        subtracted_duration = self.duration
 93
 94        for effect, intensity in self.intensities.items():
 95            other_intensity = other.intensities.get(effect, 0)
 96            new_intensity = intensity - other_intensity
 97            if new_intensity >= 0:
 98
 99                subtracted_effects[effect] = self.effects[effect]
100                subtracted_intensities[effect] = new_intensity
101            elif new_intensity < 0:
102                raise TypeError("Negative intensity not allowed during subtraction.")
103
104        self.used = True
105        return Potion(subtracted_effects, subtracted_duration, intensities=subtracted_intensities)
106
107    def __truediv__(self, divisor):
108        if not isinstance(divisor, int) or divisor < 1:
109            raise ValueError("Divisor must be a natural number greater than zero.")
110
111        part_duration = self.duration / divisor
112        part_intensities = {name: round(intensity / divisor) if intensity > 0 else 0 for name, intensity in
113                            self.intensities.items()}
114
115        parts = tuple(Potion(self.effects, part_duration, intensities=part_intensities) for _ in range(divisor))
116        self.used = True
117        return parts
118
119    def tick(self, target):
120        if self.duration > 0:
121            self.duration -= 1
122            if self.duration == 0:
123                self.used = True
124                if self.initial_state is not None:
125                    self.revert_state(target)
126
127    def __eq__(self, other):
128        return self.effects == other.effects and self.intensities == other.intensities
129
130    def __lt__(self, other):
131        return sum(self.intensities.values()) < sum(other.intensities.values())
132
133    def __gt__(self, other):
134        return sum(self.intensities.values()) > sum(other.intensities.values())
135
136    def __hash__(self):
137        return hash(tuple(sorted(self.effects.items())))
138
139    def __getattr__(self, attr):
140        if attr.startswith('make_') and attr[5:] in self.effects:
141            effect_name = attr[5:]
142
143            def repeated_effect(target, intensity=self.effects[effect_name]):
144                for _ in range(intensity):
145                    self.apply_effect(effect_name, target)
146
147            return repeated_effect
148
149        raise AttributeError(f"'Potion' object has no attribute '{attr}'")
150
151    def __call__(self, target):
152        self.apply_all_effects(target)
153
154
155class ГоспожатаПоХимия:
156    def __init__(self):
157        self.used_potions = set()
158        self.target = None
159
160    def apply(self, target, potion):
161        if potion in self.used_potions:
162            raise TypeError("Potion is depleted.")
163
164        if self.target is None:
165            self.target = target
166
167        effects_sorted = sorted(potion.intensities.keys(), key=lambda effect: sum(ord(char) for char in effect),
168                                reverse=True)
169
170        for effect in effects_sorted:
171            if effect not in potion.applied_effects:
172                for _ in range(potion.intensities[effect]):
173                    potion.apply_effect(effect, target)
174                potion.applied_effects.add(effect)
175
176        potion.used = True
177        self.used_potions.add(potion)
178
179    def tick(self):
180        potions_to_remove = set()
181
182        for potion in self.used_potions.copy():
183            potion.tick(self.target)
184
185            if potion.duration == 0:
186                potions_to_remove.add(potion)
187
188        for potion in potions_to_remove:
189            self.used_potions.remove(potion)