Year 2017 Day 20

Author: maneatingape

README.md

@@ -255,6 +255,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 17 | [Spinlock](https://adventofcode.com/2017/day/17) | [Source](src/year2017/day17.rs) | 84 |
 | 18 | [Duet](https://adventofcode.com/2017/day/18) | [Source](src/year2017/day18.rs) | 7 |
 | 19 | [A Series of Tubes](https://adventofcode.com/2017/day/19) | [Source](src/year2017/day19.rs) | 20 |
+| 20 | [Particle Swarm](https://adventofcode.com/2017/day/20) | [Source](src/year2017/day20.rs) | 234 |
 | 23 | [Coprocessor Conflagration](https://adventofcode.com/2017/day/23) | [Source](src/year2017/day23.rs) | 55 |
 | 24 | [Electromagnetic Moat](https://adventofcode.com/2017/day/24) | [Source](src/year2017/day24.rs) | 280 |
 

benches/benchmark.rs

@@ -120,6 +120,7 @@ mod year2017 {
     benchmark!(year2017, day17);
     benchmark!(year2017, day18);
     benchmark!(year2017, day19);
+    benchmark!(year2017, day20);
     benchmark!(year2017, day23);
     benchmark!(year2017, day24);
 }

src/lib.rs

@@ -102,6 +102,7 @@ pub mod year2017 {
     pub mod day17;
     pub mod day18;
     pub mod day19;
+    pub mod day20;
     pub mod day23;
     pub mod day24;
 }

src/main.rs

@@ -167,6 +167,7 @@ fn year2017() -> Vec<Solution> {
         solution!(year2017, day17),
         solution!(year2017, day18),
         solution!(year2017, day19),
+        solution!(year2017, day20),
         solution!(year2017, day23),
         solution!(year2017, day24),
     ]

src/year2017/day20.rs

@@ -0,0 +1,128 @@
+//! # Particle Swarm
+//!
+//! ## Part One
+//!
+//! The particle that remains closest to the origin as time goes to infinity has the lowest
+//! acceleration, measured via its manhattan value. If more than one particle shares the same
+//! lowest acceleration then ties are broken by velocity then by position.
+//!
+//! ## Part Two
+//!
+//! The input is constructed so that all collisions happen within 40 ticks so a simple brute force
+//! solution is much faster than more elegant alternatives, for example solving the quadratic
+//! equation describing each particle's position.
+use crate::util::hash::*;
+use crate::util::iter::*;
+use crate::util::parse::*;
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+struct Vector {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
+impl Vector {
+    fn new(cs: [i32; 3]) -> Self {
+        Vector { x: cs[0], y: cs[1], z: cs[2] }
+    }
+
+    fn manhattan(&self) -> i32 {
+        self.x.abs() + self.y.abs() + self.z.abs()
+    }
+
+    fn tick(&mut self, other: &Vector) {
+        self.x += other.x;
+        self.y += other.y;
+        self.z += other.z;
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct Particle {
+    id: usize,
+    position: Vector,
+    velocity: Vector,
+    acceleration: Vector,
+}
+
+impl Particle {
+    fn tick(&mut self) {
+        self.velocity.tick(&self.acceleration);
+        self.position.tick(&self.velocity);
+    }
+}
+
+pub fn parse(input: &str) -> Vec<Particle> {
+    input
+        .iter_signed()
+        .chunk::<3>()
+        .chunk::<3>()
+        .enumerate()
+        .map(|(id, cs)| Particle {
+            id,
+            position: Vector::new(cs[0]),
+            velocity: Vector::new(cs[1]),
+            acceleration: Vector::new(cs[2]),
+        })
+        .collect()
+}
+
+pub fn part1(input: &[Particle]) -> usize {
+    let mut candidates = Vec::new();
+    let mut min = i32::MAX;
+
+    // Find particles with the lowest acceleration.
+    for particle in input {
+        let next = particle.acceleration.manhattan();
+
+        if next < min {
+            candidates.clear();
+            min = next;
+        }
+        if next == min {
+            candidates.push(*particle);
+        }
+    }
+
+    // Ensure all acceleration, velocity and position vectors are "aligned", that is the
+    // sign of each component is the same, for example a particle with a negative x acceleration
+    // should also have a negative x velocity and negative x position.
+    for _ in 0..1000 {
+        candidates.iter_mut().for_each(Particle::tick);
+    }
+
+    // Tie break by velocity then by position.
+    candidates.sort_unstable_by(|a, b| {
+        let first = a.velocity.manhattan().cmp(&b.velocity.manhattan());
+        let second = a.position.manhattan().cmp(&b.position.manhattan());
+        first.then(second)
+    });
+
+    candidates[0].id
+}
+
+pub fn part2(input: &[Particle]) -> usize {
+    let mut particles = input.to_vec();
+    let mut collisions = FastMap::with_capacity(input.len());
+    let mut exists = vec![i64::MAX; input.len()];
+
+    for time in 1..40 {
+        for (i, particle) in particles.iter_mut().enumerate() {
+            // Only consider particles that haven't collided in a previous tick.
+            // Multiple particles can collide in the same tick.
+            if exists[i] >= time {
+                particle.tick();
+
+                if let Some(j) = collisions.insert(particle.position, i) {
+                    exists[i] = time;
+                    exists[j] = time;
+                }
+            }
+        }
+
+        collisions.clear();
+    }
+
+    exists.iter().filter(|&&t| t == i64::MAX).count()
+}

tests/test.rs

@@ -104,6 +104,7 @@ mod year2017 {
     mod day17_test;
     mod day18_test;
     mod day19_test;
+    mod day20_test;
     mod day23_test;
     mod day24_test;
 }

tests/year2017/day20_test.rs

@@ -0,0 +1,19 @@
+use aoc::year2017::day20::*;
+
+const EXAMPLE: &str = "\
+p=<-6,0,0>, v=< 3,0,0>, a=< 0,0,0>
+p=<-4,0,0>, v=< 2,0,0>, a=< 0,0,0>
+p=<-2,0,0>, v=< 1,0,0>, a=< 0,0,0>
+p=< 3,0,0>, v=<-1,0,0>, a=< 0,0,0>";
+
+#[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), 1);
+}