day23 hmmm

src/tasks/day23.rs

@@ -30,6 +30,70 @@ pub fn task1() {
     println!("There are {} bots in range of the big bot.", bots_in_range);
 }
 
+pub fn task2() {
+    let input = utils::read_file("input/day23.txt");
+    let regex =
+        Regex::new(r"^pos=<(?P<x>-?\d+),(?P<y>-?\d+),(?P<z>-?\d+)>, r=(?P<range>\d+)$").unwrap();
+    let bots: Vec<Bot> = input
+        .lines()
+        .map(|line| {
+            let m = regex.captures(line).unwrap();
+            let x = m["x"].parse::<isize>().unwrap();
+            let y = m["y"].parse::<isize>().unwrap();
+            let z = m["z"].parse::<isize>().unwrap();
+            let range = m["range"].parse::<usize>().unwrap();
+
+            Bot { x, y, z, range }
+        })
+        .collect();
+
+    // let r_min = bots.iter().min_by_key(|it| it.range).unwrap().range;
+    // let r_max = bots.iter().max_by_key(|it| it.range).unwrap().range;
+    // println!("Radius min max: {}/{}", r_min, r_max);
+    // let x_min = bots.iter().min_by_key(|it| it.x).unwrap().x;
+    // let x_max = bots.iter().max_by_key(|it| it.x).unwrap().x;
+    // println!("X range: {}", x_max - x_min);
+    // let y_min = bots.iter().min_by_key(|it| it.y).unwrap().y;
+    // let y_max = bots.iter().max_by_key(|it| it.y).unwrap().y;
+    // println!("Y range: {}", y_max - y_min);
+    // let z_min = bots.iter().min_by_key(|it| it.z).unwrap().z;
+    // let z_max = bots.iter().max_by_key(|it| it.z).unwrap().z;
+    // println!("Z range: {}", z_max - z_min);
+
+    let neighbor_counts: Vec<(Bot, usize)> = bots
+        .iter()
+        .flat_map(|bot| bot.corners())
+        .map(|corner| {
+            let count = bots
+                .iter()
+                .filter(|bot| bot.distance(&corner) <= bot.range)
+                .count();
+            (corner, count)
+        })
+        .collect();
+
+    let max = neighbor_counts.iter().max_by_key(|it| it.1).unwrap().1;
+
+    let start = Bot {
+        x: 0,
+        y: 0,
+        z: 0,
+        range: 0,
+    };
+    let candidates = neighbor_counts.iter().filter(|it| it.1 == max).count();
+    println!("{} points in range of {} bots", candidates, max);
+    let candidate = neighbor_counts
+        .iter()
+        .filter(|it| it.1 == max)
+        .min_by_key(|it| it.0.distance(&start));
+
+    println!(
+        "Corner with most bots in range: {:?}",
+        candidate.unwrap().0.distance(&start)
+    );
+    // wrong: 37446460,43177892,57318660; 137943012; 102224079;
+}
+
 #[derive(Debug)]
 struct Bot {
     x: isize,
@@ -42,4 +106,45 @@ impl Bot {
     fn distance(&self, other: &Self) -> usize {
         ((other.x - self.x).abs() + (other.y - self.y).abs() + (other.z - self.z).abs()) as usize
     }
+
+    fn corners(&self) -> Vec<Self> {
+        vec![
+            Bot {
+                x: self.x + self.range as isize,
+                y: self.y,
+                z: self.z,
+                range: 0,
+            },
+            Bot {
+                x: self.x - self.range as isize,
+                y: self.y,
+                z: self.z,
+                range: 0,
+            },
+            Bot {
+                x: self.x,
+                y: self.y + self.range as isize,
+                z: self.z,
+                range: 0,
+            },
+            Bot {
+                x: self.x,
+                y: self.y - self.range as isize,
+                z: self.z,
+                range: 0,
+            },
+            Bot {
+                x: self.x,
+                y: self.y,
+                z: self.z + self.range as isize,
+                range: 0,
+            },
+            Bot {
+                x: self.x,
+                y: self.y,
+                z: self.z - self.range as isize,
+                range: 0,
+            },
+        ]
+    }
 }