add 21 and 22

day22/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "day22"
+version = "0.1.0"

day22/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "day22"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

day22/src/main.rs

@@ -0,0 +1,255 @@
+use std::collections::{HashSet, VecDeque};
+
+fn main() {
+    // part 1: 900
+    // part 2: 1216
+    let player = Character::new(50, 500, 0);
+    let boss = Character::new(51, 0, 9);
+
+    let game = Game::new(player, boss);
+
+    let mut visited = HashSet::new();
+    visited.insert(game.clone());
+
+    let mut queue = VecDeque::new();
+
+    queue.push_back(game);
+
+    while let Some(state) = queue.pop_front() {
+        if !state.player.is_alive || !state.boss.is_alive {
+            continue;
+        }
+
+        for spell in get_spells() {
+            let new_state = state.execute_turn(spell);
+            if !visited.contains(&new_state) {
+                visited.insert(new_state.clone());
+                queue.push_back(new_state);
+            }
+        }
+    }
+    let mut best_mana_spent = 10_000_000;
+    for state in visited {
+        if state.player.is_alive && !state.boss.is_alive && state.mana_spent < best_mana_spent {
+            best_mana_spent = state.mana_spent;
+        }
+    }
+    println!("{best_mana_spent}");
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+struct Game {
+    player: Character,
+    boss: Character,
+    mana_spent: u64,
+}
+
+impl Game {
+    fn new(player: Character, boss: Character) -> Self {
+        Self {
+            player,
+            boss,
+            mana_spent: 0,
+        }
+    }
+
+    fn run_effects(&mut self) {
+        self.player.apply_effects();
+        self.player.effects_tick();
+
+        self.boss.apply_effects();
+        self.boss.effects_tick();
+    }
+
+    fn execute_turn(&self, spell: Spell) -> Self {
+        let mut new_state = self.clone();
+
+        new_state.mana_spent += spell.cost;
+        new_state.player_turn(spell);
+        new_state.boss_turn();
+
+        new_state
+    }
+
+    fn player_turn(&mut self, spell: Spell) {
+        // part 2 here
+        self.player.hp -= 1;
+
+        if self.player.hp == 0 {
+            self.player.is_alive = false;
+            return;
+        }
+        // end part 2
+
+        self.run_effects();
+
+        if spell.cost > self.player.mana {
+            self.player.is_alive = false;
+            return;
+        } else {
+            self.player.mana -= spell.cost;
+        }
+
+        if spell.remaining_duration > 0 {
+            match spell.name.as_str() {
+                "Shield" => {
+                    if self
+                        .player
+                        .effects
+                        .iter()
+                        .all(|s| s.name.as_str() != "Shield")
+                    {
+                        self.player.effects.push(spell);
+                    }
+                }
+                "Poison" => {
+                    if self
+                        .boss
+                        .effects
+                        .iter()
+                        .all(|s| s.name.as_str() != "Poison")
+                    {
+                        self.boss.effects.push(spell);
+                    }
+                }
+                "Recharge" => {
+                    if self
+                        .player
+                        .effects
+                        .iter()
+                        .all(|s| s.name.as_str() != "Recharge")
+                    {
+                        self.player.effects.push(spell);
+                    }
+                }
+                _ => panic!(),
+            }
+        } else {
+            self.boss.hp = self.boss.hp.saturating_sub(1.max(spell.damage));
+            self.player.hp += spell.heal;
+        }
+
+        if self.boss.hp == 0 {
+            self.boss.is_alive = false;
+        }
+    }
+
+    fn boss_turn(&mut self) {
+        self.run_effects();
+
+        if self.boss.hp == 0 {
+            self.boss.is_alive = false;
+            return;
+        }
+
+        self.player.hp = self
+            .player
+            .hp
+            .saturating_sub(1.max(self.boss.damage - self.player.armor()));
+
+        if self.player.hp == 0 {
+            self.player.is_alive = false;
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+struct Character {
+    hp: u64,
+    mana: u64,
+    damage: u64,
+    effects: Vec<Spell>,
+    is_alive: bool,
+}
+
+impl Character {
+    fn effects_tick(&mut self) {
+        let mut to_remove = vec![];
+
+        for (idx, effect) in self.effects.iter_mut().enumerate() {
+            effect.remaining_duration -= 1;
+            if effect.remaining_duration == 0 {
+                to_remove.push(idx);
+            }
+        }
+
+        for idx in to_remove.iter().rev() {
+            self.effects.remove(*idx);
+        }
+    }
+
+    fn new(hp: u64, mana: u64, damage: u64) -> Self {
+        Self {
+            hp,
+            mana,
+            damage,
+            effects: vec![],
+            is_alive: true,
+        }
+    }
+
+    fn armor(&self) -> u64 {
+        self.effects.iter().map(|e| e.armor).sum()
+    }
+
+    fn apply_effects(&mut self) {
+        let mut heal = 0;
+        let mut damage = 0;
+        let mut mana_increase = 0;
+
+        for effect in &self.effects {
+            heal += effect.heal;
+            damage += effect.damage;
+            mana_increase += effect.mana_increase;
+        }
+
+        self.hp += heal;
+        self.hp = self.hp.saturating_sub(damage);
+        self.mana += mana_increase;
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+struct Spell {
+    name: String,
+    remaining_duration: u64,
+    cost: u64,
+    armor: u64,
+    damage: u64,
+    mana_increase: u64,
+    heal: u64,
+}
+
+impl Spell {
+    fn new(
+        name: String,
+        remaining_duration: u64,
+        cost: u64,
+        armor: u64,
+        damage: u64,
+        mana_increase: u64,
+        heal: u64,
+    ) -> Self {
+        Self {
+            name,
+            remaining_duration,
+            cost,
+            armor,
+            damage,
+            mana_increase,
+            heal,
+        }
+    }
+}
+
+#[rustfmt::skip]
+fn get_spells() -> impl Iterator<Item = Spell> {
+    [
+        Spell::new("Magic Missile".to_string(), 0,  53, 0, 4,   0, 0),
+        Spell::new("Drain".to_string(),         0,  73, 0, 2,   0, 2),
+        Spell::new("Shield".to_string(),        6, 113, 7, 0,   0, 0),
+        Spell::new("Poison".to_string(),        6, 173, 0, 3,   0, 0),
+        Spell::new("Recharge".to_string(),      5, 229, 0, 0, 101, 0),
+    ]
+    .into_iter()
+}