add 21 and 22

day21/Cargo.lock

@@ -0,0 +1,25 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "day21"
+version = "0.1.0"
+dependencies = [
+ "itertools",
+]
+
+[[package]]
+name = "either"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]

day21/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "day21"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+itertools = "*"

day21/src/main.rs

@@ -0,0 +1,141 @@
+use itertools::Itertools;
+
+const WEAPONS: [(&str, i32, i32, i32); 5] = [
+    ("Dagger", 8, 4, 0),
+    ("Shortsword", 10, 5, 0),
+    ("Warhammer", 25, 6, 0),
+    ("Longsword", 40, 7, 0),
+    ("Greataxe", 74, 8, 0),
+];
+
+const ARMOR: [(&str, i32, i32, i32); 5] = [
+    ("Leather", 13, 0, 1),
+    ("Chainmail", 31, 0, 2),
+    ("Splintmail", 53, 0, 3),
+    ("Bandedmail", 75, 0, 4),
+    ("Platemail", 102, 0, 5),
+];
+
+const RINGS: [(&str, i32, i32, i32); 6] = [
+    ("Damage +1", 25, 1, 0),
+    ("Damage +2", 50, 2, 0),
+    ("Damage +3", 100, 3, 0),
+    ("Defense +1", 20, 0, 1),
+    ("Defense +2", 40, 0, 2),
+    ("Defense +3", 80, 0, 3),
+];
+
+#[derive(Clone, Debug)]
+struct Loadout {
+    weapon: Item,
+    armor: Option<Item>,
+    rings: Vec<Item>,
+}
+
+#[derive(Copy, Clone, Debug)]
+struct Item {
+    cost: i32,
+    damage: i32,
+    armor: i32,
+}
+
+impl Item {
+    fn new(cost: i32, damage: i32, armor: i32) -> Self {
+        Self {
+            cost,
+            damage,
+            armor,
+        }
+    }
+
+    fn from_table((_name, cost, damage, armor): (&str, i32, i32, i32)) -> Self {
+        Self {
+            cost,
+            damage,
+            armor,
+        }
+    }
+}
+
+impl Loadout {
+    fn new(weapon: Item, armor: Option<Item>, rings: Vec<Item>) -> Self {
+        Self {
+            weapon,
+            armor,
+            rings,
+        }
+    }
+
+    fn damage_value(&self) -> i32 {
+        self.weapon.damage + self.rings.iter().map(|r| r.damage).sum::<i32>()
+    }
+
+    fn armor_value(&self) -> i32 {
+        (match &self.armor {
+            Some(armor) => armor.armor,
+            None => 0,
+        }) + self.rings.iter().map(|r| r.armor).sum::<i32>()
+    }
+
+    fn cost(&self) -> i32 {
+        self.weapon.cost
+            + (match &self.armor {
+                Some(armor) => armor.cost,
+                None => 0,
+            })
+            + self.rings.iter().map(|r| r.cost).sum::<i32>()
+    }
+}
+
+fn main() {
+    let weapons: Vec<_> = WEAPONS.into_iter().map(Item::from_table).collect();
+    let armor: Vec<_> = ARMOR.into_iter().map(Item::from_table).collect();
+    let rings: Vec<_> = RINGS.into_iter().map(Item::from_table).collect();
+
+    let mut loadouts = vec![];
+
+    for w in &weapons {
+        for r in rings
+            .iter()
+            .combinations(0)
+            .chain(rings.iter().combinations(1))
+            .chain(rings.iter().combinations(2))
+        {
+            for a in &armor {
+                let loadout = Loadout::new(*w, Some(*a), r.iter().map(|r0| **r0).collect());
+                loadouts.push(loadout);
+            }
+            let loadout = Loadout::new(*w, None, r.iter().map(|r0| **r0).collect());
+            loadouts.push(loadout);
+        }
+    }
+
+    let boss = Loadout::new(Item::new(0, 8, 0), Some(Item::new(0, 0, 2)), vec![]);
+
+    let player_hp = 100.;
+    let boss_hp = 100.;
+
+    let mut cost_where_player_wins = vec![];
+    let mut cost_where_player_looses = vec![];
+
+    for l in &loadouts {
+        let player_dmg_per_turn = 1.max(l.damage_value() - boss.armor_value()) as f64;
+        let boss_dmg_per_turn = 1.max(boss.damage_value() - l.armor_value()) as f64;
+
+        let turns_to_kill_boss = (boss_hp / player_dmg_per_turn).ceil();
+        let turns_to_kill_player = (player_hp / boss_dmg_per_turn).ceil();
+
+        let player_wins = turns_to_kill_boss <= turns_to_kill_player;
+        if player_wins {
+            cost_where_player_wins.push(l.cost())
+        } else {
+            cost_where_player_looses.push(l.cost())
+        }
+    }
+
+    let result = cost_where_player_wins.iter().min().unwrap();
+    println!("{result}");
+
+    let result = cost_where_player_looses.iter().max().unwrap();
+    println!("{result}");
+}