sub 100ms again (just need 6 more days lol)

Author: viandoxdev

2019/src/challenges/day12.rs

@@ -1,35 +1,86 @@
 use std::num::ParseIntError;
 
 use anyhow::Result;
-use itertools::Itertools;
 use num::Integer;
-use rustc_hash::FxHashSet;
 
 #[derive(Debug, Clone, Copy)]
 struct Moon {
-    x: i32,
-    y: i32,
-    z: i32,
-    vx: i32,
-    vy: i32,
-    vz: i32,
+    p: [i32; 3],
+    v: [i32; 3],
 }
 
 impl Moon {
-    pub fn new(x: i32, y: i32, z: i32) -> Self {
+    fn new(x: i32, y: i32, z: i32) -> Self {
         Self {
-            x,
-            y,
-            z,
-            vx: 0,
-            vy: 0,
-            vz: 0,
+            p: [x, y, z],
+            v: [0; 3],
         }
     }
+    #[inline(always)]
+    fn kinetic_energy(&self) -> i32 {
+        self.v[0].abs() + self.v[1].abs() + self.v[2].abs()
+    }
+    #[inline(always)]
+    fn potential_energy(&self) -> i32 {
+        self.p[0].abs() + self.p[1].abs() + self.p[2].abs()
+    }
+    #[inline(always)]
+    fn energy(&self) -> i32 {
+        self.kinetic_energy() * self.potential_energy()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct State {
+    moons: [Moon; 4],
+}
+
+impl State {
+    #[inline]
+    fn step_coord<const C: usize>(&mut self) {
+        for a in 0..4 {
+            for b in (a + 1)..4 {
+                self.moons[a].v[C] += (self.moons[b].p[C] - self.moons[a].p[C]).signum();
+                self.moons[b].v[C] += (self.moons[a].p[C] - self.moons[b].p[C]).signum();
+            }
+        }
+        for a in 0..4 {
+            self.moons[a].p[C] += self.moons[a].v[C];
+        }
+    }
+    #[inline(always)]
+    fn eq_coord<const C: usize>(&self, other: &Self) -> bool {
+        self.moons[0].p[C] == other.moons[0].p[C]
+        && self.moons[1].p[C] == other.moons[1].p[C]
+        && self.moons[2].p[C] == other.moons[2].p[C]
+        && self.moons[3].p[C] == other.moons[3].p[C]
+        && self.moons[0].v[C] == other.moons[0].v[C]
+        && self.moons[1].v[C] == other.moons[1].v[C]
+        && self.moons[2].v[C] == other.moons[2].v[C]
+        && self.moons[3].v[C] == other.moons[3].v[C]
+    }
+    #[inline]
+    fn cycle<const C: usize>(&self) -> usize {
+        let mut length = 1;
+        let mut state = *self;
+        state.step_coord::<C>();
+        while !self.eq_coord::<C>(&state) {
+            state.step_coord::<C>();
+            length += 1;
+        }
+
+        length
+    }
+    #[inline(always)]
+    fn step(&mut self) {
+        self.step_coord::<0>();
+        self.step_coord::<1>();
+        self.step_coord::<2>();
+    }
 }
 
 pub async fn day12(input: String) -> Result<(String, String)> {
-    let moons = input
+    let state = input
         .trim()
         .chars()
         .filter(|c| c.is_ascii_digit() || matches!(c, '-' | ',' | '\n'))
@@ -43,72 +94,26 @@ pub async fn day12(input: String) -> Result<(String, String)> {
             Ok(Moon::new(components[0], components[1], components[2]))
         })
         .collect::<Result<Vec<Moon>, ParseIntError>>()?;
+    let state = State {
+        moons: [state[0], state[1], state[2], state[3]],
+    };
 
     let part1 = {
-        let mut moons = moons.clone();
+        let mut state = state.clone();
         for _ in 0..1000 {
-            // Gravity
-            for (a, b) in (0..moons.len()).tuple_combinations() {
-                moons[a].vx += (moons[b].x - moons[a].x).signum();
-                moons[a].vy += (moons[b].y - moons[a].y).signum();
-                moons[a].vz += (moons[b].z - moons[a].z).signum();
-                moons[b].vx += (moons[a].x - moons[b].x).signum();
-                moons[b].vy += (moons[a].y - moons[b].y).signum();
-                moons[b].vz += (moons[a].z - moons[b].z).signum();
-            }
-
-            // Velocity
-            for m in &mut moons {
-                m.x += m.vx;
-                m.y += m.vy;
-                m.z += m.vz;
-            }
+            state.step();
         }
-
-        moons
-            .iter()
-            .map(|&m| (m.x.abs() + m.y.abs() + m.z.abs()) * (m.vx.abs() + m.vy.abs() + m.vz.abs()))
-            .sum::<i32>()
+        state.moons.iter().map(Moon::energy).sum::<i32>()
     };
 
     let part2 = {
-        // Make sure the size is known at compile time so the compiler has a better shot at
-        // optimizing
-        let mut m = [moons[0], moons[1], moons[2], moons[3]];
-        macro_rules! find_cycle {
-            ($pos:ident, $vel:ident) => {
-                'block: {
-                    let mut states = FxHashSet::<([i32; 4], [i32; 4])>::default();
-
-                    for i in 0.. {
-                        if !states.insert(([m[0].$pos, m[1].$pos, m[2].$pos, m[3].$pos], [m[0].$vel, m[1].$vel, m[2].$vel, m[3].$vel])) {
-                            break 'block i as u128
-                        }
-
-                        for a in 0..4 {
-                            for b in (a+1)..4 {
-                                m[a].$vel += (m[b].$pos - m[a].$pos).signum();
-                                m[b].$vel += (m[a].$pos - m[b].$pos).signum();
-                            }
-                        }
-
-                        for a in 0..4 {
-                            m[a].$pos += m[a].$vel;
-                        }
-                    }
-
-                    unreachable!()
-                }
-            };
-        }
-        let x_cycle = find_cycle!(x, vx);
-        let y_cycle = find_cycle!(y, vy);
-        let z_cycle = find_cycle!(z, vz);
+        let x_cycle = state.cycle::<0>();
+        let y_cycle = state.cycle::<1>();
+        let z_cycle = state.cycle::<2>();
 
         let xy_cycle = x_cycle.lcm(&y_cycle);
         z_cycle * xy_cycle / z_cycle.gcd(&xy_cycle)
     };
 
     Ok((part1.to_string(), part2.to_string()))
 }
-