Rust/2024/22: add solution

Rust/2024/22.rs

@@ -0,0 +1,64 @@
+#![feature(test)]
+
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use itertools::Itertools;
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
+type Input = Vec<u64>;
+
+fn setup(input: &str) -> Input {
+    input.trim().lines().map(|l| l.parse().unwrap()).collect()
+}
+
+fn evolve(secret: u64) -> impl Iterator<Item = u64> {
+    std::iter::successors(Some(secret), |&num| {
+        let num = ((num << 6) ^ num) & 0xFFFFFF;
+        let num = ((num >> 5) ^ num) & 0xFFFFFF;
+        let num = ((num << 11) ^ num) & 0xFFFFFF;
+        Some(num)
+    })
+}
+
+fn diffs_to_idx(diffs: [i64; 4]) -> usize {
+    diffs.into_iter().fold(0, |idx, x| {
+        debug_assert!((-9..=9).contains(&x));
+        idx * 19 + (x + 9) as usize
+    })
+}
+
+fn part1(input: &Input) -> u64 {
+    input
+        .par_iter()
+        .map(|&secret| evolve(secret).nth(2000).unwrap())
+        .sum()
+}
+
+fn part2(input: &Input) -> u64 {
+    let sequences = (0..19usize.pow(4))
+        .map(|_| AtomicU64::new(0))
+        .collect::<Vec<_>>();
+
+    input.par_iter().for_each(|&secret| {
+        let mut seen = [0u64; 19usize.pow(4).div_ceil(64)];
+        evolve(secret)
+            .map(|num| num % 10)
+            .tuple_windows()
+            .map(|(a, b)| (b as i64 - a as i64, b))
+            .take(2000)
+            .tuple_windows()
+            .map(|((a, _), (b, _), (c, _), (d, price))| ((a, b, c, d), price))
+            .for_each(|(seq, price)| {
+                let idx = diffs_to_idx(seq.into());
+                if seen[idx / 64] & (1 << (idx % 64)) != 0 {
+                    return;
+                }
+                seen[idx / 64] |= 1 << (idx % 64);
+                sequences[idx].fetch_add(price, Ordering::Relaxed);
+            });
+    });
+
+    sequences.into_iter().map(|x| x.into_inner()).max().unwrap()
+}
+
+aoc::main!(2024, 22, ex: 1, 2);

Rust/2024/main.rs

@@ -20,7 +20,7 @@ aoc::year! {
     "19.rs",
     "20.rs",
     "21.rs",
-    // "22.rs",
+    "22.rs",
     // "23.rs",
     // "24.rs",
     // "25.rs",

Rust/Cargo.toml

@@ -423,3 +423,6 @@ path = "2024/20.rs"
 [[bin]]
 name = "2024_21"
 path = "2024/21.rs"
+[[bin]]
+name = "2024_22"
+path = "2024/22.rs"

examples/2024/22/1

@@ -0,0 +1,4 @@
+1
+10
+100
+2024

examples/2024/22/1.1

@@ -0,0 +1 @@
+37327623

examples/2024/22/1.2

@@ -0,0 +1 @@
+24

examples/2024/22/2

@@ -0,0 +1,4 @@
+1
+2
+3
+2024

examples/2024/22/2.1

@@ -0,0 +1 @@
+37990510

examples/2024/22/2.2

@@ -0,0 +1 @@
+23