Year 2018 Day 25

Author: maneatingape

README.md

@@ -261,6 +261,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 22 | [Mode Maze](https://adventofcode.com/2018/day/22) | [Source](src/year2018/day22.rs) | 3410 |
 | 23 | [Experimental Emergency Teleportation](https://adventofcode.com/2018/day/23) | [Source](src/year2018/day23.rs) | 515 |
 | 24 | [Immune System Simulator 20XX](https://adventofcode.com/2018/day/24) | [Source](src/year2018/day24.rs) | 2054 |
+| 25 | [Four-Dimensional Adventure](https://adventofcode.com/2018/day/25) | [Source](src/year2018/day25.rs) | 338 |
 
 ## 2017
 

benches/benchmark.rs

@@ -148,6 +148,7 @@ mod year2018 {
     benchmark!(year2018, day22);
     benchmark!(year2018, day23);
     benchmark!(year2018, day24);
+    benchmark!(year2018, day25);
 }
 
 mod year2019 {

src/lib.rs

@@ -136,6 +136,7 @@ pub mod year2018 {
     pub mod day22;
     pub mod day23;
     pub mod day24;
+    pub mod day25;
 }
 
 /// # Rescue Santa from deep space with a solar system voyage.

src/main.rs

@@ -204,6 +204,7 @@ fn year2018() -> Vec<Solution> {
         solution!(year2018, day22),
         solution!(year2018, day23),
         solution!(year2018, day24),
+        solution!(year2018, day25),
     ]
 }
 

src/year2018/day25.rs

@@ -0,0 +1,68 @@
+//! # Four-Dimensional Adventure
+//!
+//! This problem is the classic [union find](https://en.wikipedia.org/wiki/Disjoint-set_data_structure).
+//! However since we only need the *count* of the distinct sets we can use a much simpler approach.
+//!
+//! Starting with an arbitrary point we find all other points within range, adding them to a
+//! todo list. We then transitively determine the neighbors of those points, and so on until
+//! all sets have been found.
+use crate::util::iter::*;
+use crate::util::parse::*;
+
+#[derive(Clone, Copy)]
+pub struct Point {
+    x: i32,
+    y: i32,
+    z: i32,
+    w: i32,
+}
+
+/// Simple 4D point implementation with Manhattan distance.
+impl Point {
+    fn from([x, y, z, w]: [i32; 4]) -> Self {
+        Point { x, y, z, w }
+    }
+
+    fn mahattan(&self, other: Self) -> i32 {
+        (self.x - other.x).abs()
+            + (self.y - other.y).abs()
+            + (self.z - other.z).abs()
+            + (self.w - other.w).abs()
+    }
+}
+
+pub fn parse(input: &str) -> Vec<Point> {
+    input.iter_signed::<i32>().chunk::<4>().map(Point::from).collect()
+}
+
+pub fn part1(input: &[Point]) -> usize {
+    let mut constellations = 0;
+    let mut remaining = input.to_vec();
+    let mut todo = Vec::with_capacity(input.len());
+
+    // Choose arbitrary point and start a new constellation.
+    while let Some(start) = remaining.pop() {
+        constellations += 1;
+        todo.push(start);
+
+        while let Some(point) = todo.pop() {
+            let mut i = 0;
+
+            // Find all neighbors, adding them to `todo` in order to transitively find all
+            // other points in the constellation.
+            while i < remaining.len() {
+                if point.mahattan(remaining[i]) <= 3 {
+                    todo.push(remaining.swap_remove(i));
+                } else {
+                    i += 1;
+                }
+            }
+        }
+    }
+
+    constellations
+}
+
+pub fn part2(_input: &[Point]) -> &'static str {
+    "n/a"
+}

tests/test.rs

@@ -137,6 +137,7 @@ mod year2018 {
     mod day22_test;
     mod day23_test;
     mod day24_test;
+    mod day25_test;
 }
 
 mod year2019 {

tests/year2018/day25_test.rs

@@ -0,0 +1,25 @@
+use aoc::year2018::day25::*;
+
+const EXAMPLE: &str = "\
+1,-1,0,1
+2,0,-1,0
+3,2,-1,0
+0,0,3,1
+0,0,-1,-1
+2,3,-2,0
+-2,2,0,0
+2,-2,0,-1
+1,-1,0,-1
+3,2,0,2";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 3);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), "n/a");
+}