solution: add 2015 day 21 and 22

Author: marcelblijleven

src/adventofcode/year_2015/day_21_2015.py

@@ -0,0 +1,152 @@
+import dataclasses
+import itertools
+from typing import List
+
+from adventofcode.util.exceptions import SolutionNotFoundException
+from adventofcode.util.helpers import solution_timer
+from adventofcode.util.input_helpers import get_input_for_day
+
+
+@dataclasses.dataclass
+class Item:
+    name: str
+    cost: int
+    damage: int
+    armor: int
+
+
+class Weapon(Item):
+    pass
+
+
+class Armor(Item):
+    pass
+
+
+class Ring(Item):
+    pass
+
+
+@dataclasses.dataclass
+class Character:
+    health: int
+    damage: int
+    armor: int
+
+
+def get_shop_inventory():
+    dagger = Weapon('Dagger', 8, 4, 0)
+    shortsword = Weapon('Shortsword', 10, 5, 0)
+    warhammer = Weapon('Warhammer', 25, 6, 0)
+    longsword = Weapon('Longsword', 40, 7, 0)
+    greataxe = Weapon('Greataxe', 74, 8, 0)
+    empty_hand = Weapon('Empty', 0, 0, 0)
+    weapons = [dagger, shortsword, warhammer, longsword, greataxe, empty_hand]
+
+    leather = Armor('Leather', 13, 0, 1)
+    chainmail = Armor('Chainmail', 31, 0, 2)
+    splintmail = Armor('Splintmail', 53, 0, 3)
+    bandedmail = Armor('Bandedmail', 75, 0, 4)
+    platemail = Armor('Platemail', 102, 0, 5)
+    naked = Armor('Naked', 0, 0, 0)
+    armor = [leather, chainmail, splintmail, bandedmail, platemail, naked]
+
+    damage_1 = Ring('Damage +1', 25, 1, 0)
+    damage_2 = Ring('Damage +2', 50, 2, 0)
+    damage_3 = Ring('Damage +3', 100, 3, 0)
+    defense_1 = Ring('Defense +1', 20, 0, 1)
+    defense_2 = Ring('Defense +2', 40, 0, 2)
+    defense_3 = Ring('Defense +3', 80, 0, 3)
+    no_jewelry = Ring('No jewelry', 0, 0, 0)
+    rings = [damage_1, damage_2, damage_3, defense_1, defense_2, defense_3, no_jewelry]
+
+    return weapons, armor, rings
+
+
+def calculate_cost(boss: Character):
+    weapons, armor, rings = get_shop_inventory()
+
+    wins: List[int] = []
+    losses: List[int] = []
+
+    for weapon in weapons:
+        # only one weapon
+        for armor_item in armor:
+            # only one armor
+            for ring_one, ring_two in itertools.combinations(rings, 2):
+                # two rings
+                total_cost = weapon.cost + armor_item.cost + ring_one.cost + ring_two.cost
+                total_damage = weapon.damage + armor_item.damage + ring_one.damage + ring_two.damage
+                total_armor = weapon.armor + armor_item.armor + ring_one.armor + ring_two.armor
+
+                player = Character(health=100, damage=total_damage, armor=total_armor)
+
+                if fight(player, boss):
+                    wins.append(total_cost)
+                else:
+                    losses.append(total_cost)
+
+    return min(wins), max(losses)
+
+
+def get_damage(attacker: Character, defender: Character) -> int:
+    hit_points = attacker.damage - defender.armor
+
+    if hit_points <= 0:
+        return 1
+
+    return hit_points
+
+
+def get_boss(input_data: List[str]) -> Character:
+    health = int(input_data[0].split(': ')[1])
+    damage = int(input_data[1].split(': ')[1])
+    armor = int(input_data[2].split(': ')[1])
+    return Character(health, damage, armor)
+
+
+def fight(player: Character, boss: Character) -> bool:
+    player_health = player.health
+    boss_health = player.health
+
+    while True:
+        # Player goes first
+        boss_health -= get_damage(player, boss)
+
+        if boss_health <= 0:
+            return True
+
+        # Boss is next
+        player_health -= get_damage(boss, player)
+
+        if player_health <= 0:
+            return False
+
+
+@solution_timer(2015, 21, 1)
+def part_one(input_data: List[str]):
+    boss = get_boss(input_data)
+    answer, _ = calculate_cost(boss)
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 21, 1)
+
+    return answer
+
+
+# Solution isn't correct for part 2
+# @solution_timer(2015, 21, 2)
+# def part_two(input_data: List[str]):
+#     boss = get_boss(input_data)
+#     _, answer = calculate_cost(boss)
+#
+#     if not answer:
+#         raise SolutionNotFoundException(2015, 21, 2)
+#
+#     return answer
+
+
+if __name__ == '__main__':
+    data = get_input_for_day(2015, 21)
+    part_one(data)
+    # part_two(data)

src/adventofcode/year_2015/day_22_2015.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import dataclasses
+from copy import deepcopy
+from typing import List, Callable, Any, Dict
+
+from adventofcode.util.exceptions import SolutionNotFoundException
+from adventofcode.util.helpers import solution_timer, memoize
+from adventofcode.util.input_helpers import get_input_for_day
+
+"""
+Magic Missile costs 53 mana. It instantly does 4 damage.
+Drain costs 73 mana. It instantly does 2 damage and heals you for 2 hit points.
+Shield costs 113 mana. It starts an effect that lasts for 6 turns. While it is active, your armor is increased by 7.
+Poison costs 173 mana. It starts an effect that lasts for 6 turns. At the start of each turn while it is active, it deals the boss 3 damage.
+Recharge costs 229 mana. It starts an effect that lasts for 5 turns. At the start of each turn while it is active, it gives you 101 new mana.
+"""
+
+
+@dataclasses.dataclass
+class Spell:
+    name: str
+    cost: int
+    damage: int
+    health: int
+    shield: int
+    mana: int
+    duration: int
+
+    def __key(self):
+        return self.name, self.cost, self.damage, self.health, self.shield, self.mana, self.duration
+
+    def __eq__(self, other):
+        if not isinstance(other, Spell):
+            raise NotImplementedError()
+
+        return self.__key() == other.__key()
+
+    def __hash__(self):
+        return hash(self.__key())
+
+
+missile = Spell('magic missile', 53, 4, 0, 0, 0, 0)
+drain = Spell('drain', 73, 2, 2, 0, 0, 0)
+shield = Spell('shield', 113, 0, 0, 7, 0, 6)
+poison = Spell('poison', 173, 3, 0, 0, 0, 6)
+recharge = Spell('recharge', 229, 0, 0, 0, 101, 5)
+spells = [missile, drain, shield, poison, recharge]
+
+
+def apply_status_effects(status_effects: tuple[Spell, ...], boss_health: int, player_health: int, player_armor: int,
+                         player_mana: int) -> tuple[tuple[Spell, ...], int, int, int, int]:
+    next_effects: tuple[Spell, ...] = ()
+    for effect in status_effects:
+        if effect.duration >= 0:
+            boss_health -= effect.damage
+            player_health += effect.health
+            player_armor += effect.shield
+            player_mana += effect.mana
+
+        new_effect = Spell(effect.name, effect.cost, effect.damage, effect.health, effect.shield, effect.mana,
+                           effect.duration - 1)
+
+        if new_effect.duration > 0:
+            next_effects = next_effects + (new_effect,)
+
+    return next_effects, boss_health, player_health, player_armor, player_mana
+
+
+def do_player_turn(next_effects: tuple[Spell, ...], boss_health: int, player_health: int, player_mana: int, mana_spent: int,
+                   simulation_func: Callable[[int, int, int, tuple[Spell, ...], bool, int], bool]):
+    for spell in spells:
+        if spell.name in [effect.name for effect in next_effects]:
+            continue
+
+        if spell.cost > player_mana:
+            continue
+
+        copied_effects = deepcopy(next_effects)
+        copied_effects = copied_effects + (spell,)
+
+        simulation_func(boss_health, player_health, player_mana - spell.cost, tuple(copied_effects), False,
+                        mana_spent + spell.cost)
+
+
+def fight(player_starting_health: int, player_starting_mana: int, boss_starting_health: int, boss_damage: int,
+          hard_mode: bool = False) -> int:
+    minimum_mana = int(1e10)
+
+    @memoize
+    def run_simulation(boss_health, player_health, player_mana, status_effects: tuple[Spell], is_player_turn,
+                       mana_spent):
+        nonlocal boss_damage
+        player_armor = 0
+
+        if hard_mode and is_player_turn:
+            player_health -= 1
+            if player_health <= 0:
+                return False
+
+        status_result = apply_status_effects(status_effects, boss_health, player_health, player_armor, player_mana)
+        next_effects, boss_health, player_health, player_armor, player_mana = status_result
+
+        nonlocal minimum_mana
+        if boss_health <= 0:
+            minimum_mana = min(minimum_mana, mana_spent)
+            return True
+
+        if mana_spent >= minimum_mana:
+            return False
+
+        if is_player_turn:
+            do_player_turn(next_effects, boss_health, player_health, player_mana, mana_spent, run_simulation)
+        else:
+            player_health += player_armor - boss_damage if player_armor - boss_damage < 0 else -1
+            if player_health > 0:
+                run_simulation(boss_health, player_health, player_mana, tuple(next_effects), True, mana_spent)
+
+    run_simulation(boss_starting_health, player_starting_health, player_starting_mana, (), True, 0)
+
+    return minimum_mana
+
+
+@solution_timer(2015, 22, 1)
+def part_one(_: List[str]):
+    answer = fight(50, 500, 58, 9, False)
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 22, 1)
+
+    return answer
+
+
+@solution_timer(2015, 22, 2)
+def part_two(_: List[str]):
+    answer = fight(50, 500, 58, 9, True)
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 22, 2)
+
+    return answer
+
+
+if __name__ == '__main__':
+    data = get_input_for_day(2015, 22)
+    part_one(data)
+    part_two(data)