CQ problem 15

Author: clechasseur

codingquest_clp_solutions/input_data/.keep

@@ -0,0 +1,8 @@
+0 0 2 3 0 1 1 0
+1 0 3 1 0 0 0 0
+4 0 1 0 0 0 8 6
+0 0 0 0 0 7 0 0
+2 0 0 0 0 0 0 0
+6 4 4 0 0 1 0 0
+0 0 0 0 0 0 0 0
+5 5 3 0 0 0 0 0

codingquest_clp_solutions/input_data/example_15.txt

@@ -2,8 +2,16 @@ use std::fs;
 use std::path::PathBuf;
 
 pub fn get_problem_input_data(problem: u32) -> crate::Result<String> {
+    get_problem_data(problem, "problem")
+}
+
+pub fn get_problem_example_data(problem: u32) -> crate::Result<String> {
+    get_problem_data(problem, "example")
+}
+
+fn get_problem_data(problem: u32, prefix: &str) -> crate::Result<String> {
     Ok(fs::read_to_string(
-        [env!("CARGO_MANIFEST_DIR"), "input_data", &format!("problem_{problem}.txt")]
+        [env!("CARGO_MANIFEST_DIR"), "input_data", &format!("{prefix}_{problem}.txt")]
             .iter()
             .collect::<PathBuf>(),
     )?)

codingquest_clp_solutions/src/helpers.rs

@@ -7,10 +7,11 @@ use codingquest_clp::build_solvers;
 pub mod helpers;
 pub mod problem_13;
 pub mod problem_14;
+pub mod problem_15;
 
 pub type Error = codingquest_clp::Error;
 pub type Result<T> = codingquest_clp::Result<T>;
 
 build_solvers! {
-    [13, 14]
+    [13, 14, 15]
 }

codingquest_clp_solutions/src/lib.rs

@@ -0,0 +1,77 @@
+use std::collections::{HashMap, HashSet, VecDeque};
+
+use codingquest_clp::aoclp::positioning::pt::{matrix_to_map, Pt};
+use codingquest_clp::solvers_impl::input::get_input;
+use itertools::Itertools;
+
+use crate::helpers::get_problem_input_data;
+
+pub fn solve() -> u64 {
+    let bodies: CelestialBodies = sensor_data().into();
+    bodies.avg_mass()
+}
+
+fn sensor_data() -> Vec<Vec<u64>> {
+    get_input(get_problem_input_data(15).unwrap())
+        .unwrap()
+        .safe_into_many_vecs()
+}
+
+struct CelestialBody(HashMap<Pt, u64>);
+
+impl CelestialBody {
+    pub fn mass(&self) -> u64 {
+        self.0.values().sum()
+    }
+}
+
+impl From<HashMap<Pt, u64>> for CelestialBody {
+    fn from(value: HashMap<Pt, u64>) -> Self {
+        Self(value)
+    }
+}
+
+struct CelestialBodies(Vec<CelestialBody>);
+
+impl CelestialBodies {
+    pub fn avg_mass(&self) -> u64 {
+        self.0.iter().map(CelestialBody::mass).sum::<u64>() / (self.0.len() as u64)
+    }
+
+    fn body(start: Pt, data: &HashMap<Pt, u64>, cache: &mut HashSet<Pt>) -> CelestialBody {
+        let mut pieces = HashMap::new();
+        let mut stack = VecDeque::new();
+        pieces.insert(start, data[&start]);
+        stack.push_back(start);
+        while let Some(pt) = stack.pop_front() {
+            let neighbours = pt
+                .four_neighbours()
+                .filter(|neighbour| !cache.contains(neighbour))
+                .filter(|neighbour| !pieces.contains_key(neighbour))
+                .filter(|neighbour| data.get(neighbour).is_some_and(|&data| data != 0))
+                .collect_vec();
+            pieces.extend(neighbours.iter().map(|pt| (*pt, data[pt])));
+            stack.extend(neighbours.iter().copied());
+            cache.extend(neighbours);
+        }
+
+        pieces.into()
+    }
+}
+
+impl From<Vec<Vec<u64>>> for CelestialBodies {
+    fn from(value: Vec<Vec<u64>>) -> Self {
+        let data = matrix_to_map(value);
+        let (bodies, _) =
+            data.iter()
+                .fold((Vec::new(), HashSet::new()), |(mut bodies, mut cache), (pt, d)| {
+                    if !cache.contains(pt) && *d != 0 {
+                        let body = Self::body(*pt, &data, &mut cache);
+                        bodies.push(body);
+                    }
+                    (bodies, cache)
+                });
+
+        Self(bodies)
+    }
+}