2018 day 24

Author: rene-d

2018/Cargo.toml

@@ -1,6 +1,6 @@
 # https://adventofcode.com/2018
 
 [workspace]
-members = ["day*"]
+members = ["day*", "toto"]
 
 resolver = "2"

2018/day21/day21.rs

@@ -1,5 +1,7 @@
 //! [Day 21: Chronal Conversion](https://adventofcode.com/2018/day/21)
 
+#![allow(clippy::cast_possible_truncation)]
+
 use std::collections::HashSet;
 use std::fmt::Error;
 

2018/day24/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "day24"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aoc = { path = "../../aoc" }
+regex = "1.10.2"
+
+[[bin]]
+name = "day24"
+# path = "day24.rs"

2018/day24/src/army.rs

@@ -0,0 +1,104 @@
+use std::ops::AddAssign;
+
+use crate::group::Fight;
+use crate::group::Group;
+
+#[derive(Debug, Clone)]
+pub struct Army {
+    name: String,
+    groups: Vec<Group>,
+}
+
+impl Army {
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            name: String::new(),
+            groups: vec![],
+        }
+    }
+}
+
+impl Default for Army {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl std::str::FromStr for Army {
+    type Err = Box<dyn std::error::Error>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut a = Army::new();
+        let mut id = 0;
+
+        for line in s.lines() {
+            if let Some(line) = line.strip_suffix(':') {
+                a.name = line.to_string();
+            } else {
+                let mut g: Group = line.parse()?;
+                id.add_assign(1);
+                g.set_id(&a.name, id);
+                a.groups.push(g);
+            }
+        }
+
+        Ok(a)
+    }
+}
+
+impl Army {
+    pub fn set_boost(&mut self, boost: u32) {
+        for group in &mut self.groups {
+            group.set_boost(boost);
+        }
+    }
+
+    #[must_use]
+    pub fn is_alive(&self) -> bool {
+        self.groups.iter().any(Group::is_alive)
+    }
+
+    #[must_use]
+    pub fn alive_units(&self) -> u32 {
+        self.groups.iter().map(Group::alive_units).sum()
+    }
+
+    #[must_use]
+    pub fn select_fights<'a>(&'a self, other: &'a Army) -> Vec<Fight<'a>> {
+        let mut fights: Vec<Fight<'a>> = vec![];
+
+        let mut attackers = self.alive_groups();
+        let mut targets = other.alive_groups();
+
+        // sort by effective power then initiative
+        attackers.sort_unstable();
+
+        for attacker in &attackers {
+            if let Some(i) = attacker.select_target(&targets) {
+                fights.push(Fight {
+                    attacker,
+                    opponent: targets[i],
+                });
+
+                targets.remove(i);
+            }
+        }
+
+        fights
+    }
+
+    #[must_use]
+    pub fn alive_groups(&self) -> Vec<&Group> {
+        self.groups.iter().filter(|g| g.is_alive()).collect()
+    }
+}
+
+impl std::fmt::Display for Army {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for g in &self.groups {
+            writeln!(f, "{g}")?;
+        }
+        Ok(())
+    }
+}

2018/day24/src/attacktype.rs

@@ -0,0 +1,25 @@
+use std::string::ParseError;
+
+/// Kind of attacks. Units can deal damage with these attacks, can be immune or weak.
+#[derive(PartialEq, Eq, Debug, Clone)]
+pub enum AttackType {
+    Fire,
+    Radiation,
+    Slashing,
+    Bludgeoning,
+    Cold,
+}
+
+impl std::str::FromStr for AttackType {
+    type Err = ParseError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "fire" => AttackType::Fire,
+            "radiation" => AttackType::Radiation,
+            "slashing" => AttackType::Slashing,
+            "bludgeoning" => AttackType::Bludgeoning,
+            "cold" => AttackType::Cold,
+            _ => panic!(),
+        })
+    }
+}

2018/day24/src/combat.rs

@@ -0,0 +1,86 @@
+use crate::army::Army;
+
+const MAX_FIGHTS: usize = 10000;
+
+#[derive(Clone)]
+pub struct Combat {
+    army1: Army,
+    army2: Army,
+}
+
+impl Default for Combat {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Combat {
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            army1: Army::new(),
+            army2: Army::new(),
+        }
+    }
+
+    #[must_use]
+    pub fn with_armies(army1: Army, army2: Army) -> Self {
+        Self { army1, army2 }
+    }
+
+    pub fn set_army1_boost(&mut self, boost: u32) {
+        self.army1.set_boost(boost);
+    }
+
+    #[must_use]
+    pub fn immune_alive_units(&self) -> u32 {
+        self.army1.alive_units()
+    }
+
+    #[must_use]
+    pub fn infection_alive_units(&self) -> u32 {
+        self.army2.alive_units()
+    }
+
+    #[must_use]
+    pub fn fight_to_death(&self) -> u32 {
+        for _ in 0..MAX_FIGHTS {
+            if let Some(winner) = self.fight() {
+                return winner.alive_units();
+            }
+        }
+        0
+    }
+
+    /// # Panics
+    /// si both armies are alive
+    #[must_use]
+    pub fn fight(&self) -> Option<&Army> {
+        let mut fights = self.army1.select_fights(&self.army2);
+        fights.extend(self.army2.select_fights(&self.army1));
+
+        // sort by initiative, greater first
+        fights.sort_unstable();
+
+        for f in &fights {
+            f.fight();
+        }
+
+        assert!(self.army1.is_alive() || self.army2.is_alive());
+
+        if !self.army1.is_alive() {
+            Some(&self.army2)
+        } else if !self.army2.is_alive() {
+            Some(&self.army1)
+        } else {
+            None
+        }
+    }
+}
+
+impl std::fmt::Display for Combat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.army1)?;
+        write!(f, "{}", self.army2)
+    }
+}