day11/src/main.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::VecDeque;
 
 fn main() {
     let input = std::fs::read_to_string("input").unwrap();
@@ -7,68 +7,85 @@ fn main() {
     println!("{}", pt2(&stones));
 }
 
-fn pt1(stones: &[u64]) -> usize {
+fn pt1(stones: &[u128]) -> usize {
-    b4(stones, 25)
+    blink3(stones.to_vec(), 25)
 }
 
-fn pt2(stones: &[u64]) -> usize {
+fn pt2(stones: &[u128]) -> usize {
-    b4(stones, 75)
+    let mut total = 0;
-}
+    for stone in stones {
-
+        total += blink3(vec![*stone], 75);
-fn b4(stones: &[u64], blinks: usize) -> usize {
-    let mut cache = HashMap::new();
-    for &stone in stones {
-        cache
-            .entry(stone)
-            .and_modify(|n| *n += 1usize)
-            .or_insert(1usize);
     }
+    total
+}
+
+fn blink2(stones: &[u128], blinks: usize) -> usize {
+    let mut stones = VecDeque::from_iter(stones.iter().copied());
 
     for _blink in 0..blinks {
-        let mut new_cache = HashMap::new();
+        let mut rots = 0;
-        for (stone, count) in cache.into_iter() {
+        while rots < stones.len() {
+            let stone = stones[0];
+            let digits = stone.to_string();
+
             match stone {
                 0 => {
-                    new_cache
+                    stones[0] = 1;
-                        .entry(1)
+                    stones.rotate_left(1);
-                        .and_modify(|n| *n += count)
+                    rots += 1;
-                        .or_insert(count);
                 }
-                _ if (stone.checked_ilog10().unwrap_or(0) + 1) % 2 == 0 => {
+                _ if digits.len() % 2 == 0 => {
-                    let (left, right) = split(stone);
+                    let mid = digits.len() / 2;
-                    new_cache
+                    let left = digits[0..mid].parse().unwrap();
-                        .entry(left)
+                    let right = digits[mid..].parse().unwrap();
-                        .and_modify(|n| *n += count)
+                    stones[0] = left;
-                        .or_insert(count);
+                    stones.rotate_left(1);
-                    new_cache
+                    stones.push_front(right);
-                        .entry(right)
+                    stones.rotate_left(1);
-                        .and_modify(|n| *n += count)
+                    rots += 2;
-                        .or_insert(count);
                 }
                 _ => {
-                    let new = stone * 2024;
+                    stones[0] = stone * 2024;
-                    new_cache
+                    stones.rotate_left(1);
-                        .entry(new)
+                    rots += 1;
-                        .and_modify(|n| *n += count)
-                        .or_insert(count);
                 }
             }
         }
-        cache = new_cache;
+        stones.rotate_right(rots);
+    }
+    stones.len()
+}
+
+fn blink3(mut stones: Vec<u128>, blinks: usize) -> usize {
+    let mut total = stones.len();
+    for blink in 0..blinks {
+        let mut rights = Vec::new();
+        for stone in stones.iter_mut() {
+            let digits = stone.to_string();
+            match stone {
+                0 => {
+                    *stone = 1;
+                }
+                _ if digits.len() % 2 == 0 => {
+                    let mid = digits.len() / 2;
+                    let left = digits[0..mid].parse().unwrap();
+                    let right = digits[mid..].parse().unwrap();
+                    *stone = left;
+                    rights.push(right);
+                    total += 1;
+                }
+                _ => {
+                    *stone *= 2024;
+                }
+            }
+        }
+        total += blink3(rights, blinks - blink);
     }
 
-    cache.values().sum()
+    total
 }
 
-fn split(num: u64) -> (u64, u64) {
+fn parse(input: &str) -> Vec<u128> {
-    let num_digits = num.ilog10() + 1;
-    let div = num_digits / 2;
-    let left = num.div_euclid(10u64.pow(div));
-    let right = num.rem_euclid(10u64.pow(div));
-    (left, right)
-}
-
-fn parse(input: &str) -> Vec<u64> {
     input
         .trim()
         .split(' ')
@@ -85,4 +102,10 @@ mod test {
         let stones = parse("125 17");
         assert_eq!(55312, pt1(&stones));
     }
+
+    #[test]
+    fn p2() {
+        let stones = parse("125 17");
+        assert_eq!(55312, blink3(stones, 25));
+    }
 }