Day 21

Author: BakerNet

README.md

@@ -13,7 +13,7 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [2025](aoc2025) | 24/24 |
 | [2024](aoc2024) | 50/50 |
 | [2023](aoc2023) | 50/50 |
-| [2015](aoc2015) | 40/50 |
+| [2015](aoc2015) | 42/50 |
 
 ---
 

aoc2015/README.md

@@ -26,7 +26,7 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 18](https://adventofcode.com/2024/day/18) | [code](src/bin/18.rs) | ⭐ | ⭐ |
 | [Day 19](https://adventofcode.com/2024/day/19) | [code](src/bin/19.rs) | ⭐ | ⭐ |
 | [Day 20](https://adventofcode.com/2024/day/20) | [code](src/bin/20.rs) | ⭐ | ⭐ |
-| [Day 21](https://adventofcode.com/2024/day/21) | [code](src/bin/21.rs) | _ | _ |
+| [Day 21](https://adventofcode.com/2024/day/21) | [code](src/bin/21.rs) | ⭐ | ⭐ |
 | [Day 22](https://adventofcode.com/2024/day/22) | [code](src/bin/22.rs) | _ | _ |
 | [Day 23](https://adventofcode.com/2024/day/23) | [code](src/bin/23.rs) | _ | _ |
 | [Day 24](https://adventofcode.com/2024/day/24) | [code](src/bin/24.rs) | _ | _ |

aoc2015/data/examples/21.txt

@@ -0,0 +1,3 @@
+Hit Points: 17
+Damage: 7
+Armor: 2

aoc2015/src/bin/21.rs

@@ -0,0 +1,171 @@
+#![feature(int_roundings)]
+use std::str::Lines;
+
+use itertools::Itertools;
+
+advent_of_code::solution!(21);
+
+#[derive(Debug, Clone, Copy)]
+struct Item(u64, i64, i64);
+
+const WEAPONS: [Item; 5] = [
+    Item(8, 4, 0),
+    Item(10, 5, 0),
+    Item(25, 6, 0),
+    Item(40, 7, 0),
+    Item(74, 8, 0),
+];
+
+const ARMOURS: [Item; 6] = [
+    Item(0, 0, 0), // dummy armour
+    Item(13, 0, 1),
+    Item(31, 0, 2),
+    Item(53, 0, 3),
+    Item(75, 0, 4),
+    Item(102, 0, 5),
+];
+
+const DMG_RINGS: [Item; 4] = [
+    Item(0, 0, 0), // dummy ring
+    Item(25, 1, 0),
+    Item(50, 2, 0),
+    Item(100, 3, 0),
+];
+
+const ARM_RINGS: [Item; 4] = [
+    Item(0, 0, 0), // dummy ring
+    Item(20, 0, 1),
+    Item(40, 0, 2),
+    Item(80, 0, 3),
+];
+
+#[derive(Debug, Clone, Copy)]
+struct Loadout {
+    weapon: Item,
+    armour: Item,
+    ring1: Item,
+    ring2: Item,
+}
+
+impl Default for Loadout {
+    fn default() -> Self {
+        Self {
+            weapon: WEAPONS[0],
+            armour: ARMOURS[0],
+            ring1: DMG_RINGS[0],
+            ring2: ARM_RINGS[0],
+        }
+    }
+}
+
+impl Loadout {
+    fn loadouts_to_try(part2: bool) -> Vec<Loadout> {
+        // buying a sword is clearly never the right play in part 2 - upgrades are too cost efficient
+        let mut rings = DMG_RINGS.iter().copied().collect_vec();
+        rings.extend(ARM_RINGS.iter().copied());
+        let ring_sets = rings.iter().combinations(2).collect_vec();
+        let mut loadouts = Vec::with_capacity(ring_sets.len() * ARMOURS.len() * WEAPONS.len());
+        let weps = if part2 {
+            vec![WEAPONS[0]]
+        } else {
+            WEAPONS.iter().copied().collect_vec()
+        };
+        for rs in ring_sets {
+            for a in ARMOURS.iter().copied() {
+                for w in weps.iter().copied() {
+                    loadouts.push(Loadout {
+                        weapon: w,
+                        armour: a,
+                        ring1: *rs[0],
+                        ring2: *rs[1],
+                    });
+                }
+            }
+        }
+        loadouts.sort_by_key(|r| if part2 { u64::MAX - r.cost() } else { r.cost() });
+        loadouts
+    }
+
+    fn damage(&self) -> i64 {
+        self.weapon.1 + self.ring1.1 + self.ring2.1
+    }
+
+    fn def(&self) -> i64 {
+        self.armour.2 + self.ring1.2 + self.ring2.2
+    }
+
+    fn cost(&self) -> u64 {
+        self.weapon.0 + self.armour.0 + self.ring1.0 + self.ring2.0
+    }
+}
+
+fn parse_input(input: &str) -> (i64, i64, i64) {
+    let mut lines = input.lines();
+    let to_i64 = |lines: &mut Lines<'_>| {
+        lines
+            .next()
+            .expect("Should find line")
+            .split_whitespace()
+            .last()
+            .expect("Should find value")
+            .parse::<i64>()
+            .expect("Value should parse")
+    };
+    let boss_hp = to_i64(&mut lines);
+    let boss_damage = to_i64(&mut lines);
+    let boss_def = to_i64(&mut lines);
+    (boss_hp, boss_damage, boss_def)
+}
+
+pub fn part_one(input: &str) -> Option<u64> {
+    let (boss_hp, boss_damage, boss_def) = parse_input(input);
+    #[cfg(test)]
+    let my_hp = 8_i64;
+    #[cfg(not(test))]
+    let my_hp = 100_i64;
+    let loadouts = Loadout::loadouts_to_try(false);
+    loadouts.iter().find_map(|lo| {
+        let turns_to_kill_boss = boss_hp.div_ceil(1.max(lo.damage() - boss_def));
+        let turns_to_kill_me = my_hp.div_ceil(1.max(boss_damage - lo.def()));
+        if turns_to_kill_boss <= turns_to_kill_me {
+            Some(lo.cost())
+        } else {
+            None
+        }
+    })
+}
+
+pub fn part_two(input: &str) -> Option<u64> {
+    let (boss_hp, boss_damage, boss_def) = parse_input(input);
+    #[cfg(test)]
+    let my_hp = 8_i64;
+    #[cfg(not(test))]
+    let my_hp = 100_i64;
+    let loadouts = Loadout::loadouts_to_try(true);
+    loadouts.iter().find_map(|lo| {
+        let turns_to_kill_boss = boss_hp.div_ceil(1.max(lo.damage() - boss_def));
+        let turns_to_kill_me = my_hp.div_ceil(1.max(boss_damage - lo.def()));
+        if turns_to_kill_boss > turns_to_kill_me {
+            Some(lo.cost())
+        } else {
+            None
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_part_one() {
+        let result = part_one(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(123));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(230));
+    }
+}