Tidy

Author: maneatingape

README.md

@@ -97,7 +97,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 21 | [Keypad Conundrum](https://adventofcode.com/2024/day/21) | [Source](src/year2024/day21.rs) | 111 |
 | 22 | [Monkey Market](https://adventofcode.com/2024/day/22) | [Source](src/year2024/day22.rs) | 1350 |
 | 23 | [LAN Party](https://adventofcode.com/2024/day/23) | [Source](src/year2024/day23.rs) | 43 |
-| 24 | [Crossed Wires](https://adventofcode.com/2024/day/24) | [Source](src/year2024/day24.rs) | 36 |
+| 24 | [Crossed Wires](https://adventofcode.com/2024/day/24) | [Source](src/year2024/day24.rs) | 23 |
 | 25 | [Code Chronicle](https://adventofcode.com/2024/day/25) | [Source](src/year2024/day25.rs) | 12 |
 
 ## 2023

src/year2024/day24.rs

@@ -2,6 +2,7 @@
 use crate::util::hash::*;
 use crate::util::iter::*;
 use crate::util::parse::*;
+use std::collections::VecDeque;
 
 type Input<'a> = (&'a str, Vec<[&'a str; 5]>);
 
@@ -14,39 +15,41 @@ pub fn parse(input: &str) -> Input<'_> {
 pub fn part1(input: &Input<'_>) -> u64 {
     let (prefix, gates) = input;
 
-    let mut names = FastMap::new();
-    let mut cache = FastMap::new();
-    let mut ops = FastMap::new();
+    let mut cache = vec![u8::MAX; 1 << 15];
+    let to_index = |s: &str| {
+        let b = s.as_bytes();
+        ((b[0] as usize & 31) << 10) + ((b[1] as usize & 31) << 5) + (b[2] as usize & 31)
+    };
 
     for line in prefix.lines() {
         let prefix = &line[..3];
         let suffix = &line[5..];
-
-        let size = names.len();
-        let index = *names.entry(prefix).or_insert(size);
-
-        cache.insert(index, suffix.unsigned());
+        cache[to_index(prefix)] = suffix.unsigned();
     }
 
-    for &[left, kind, right, _, to] in gates {
-        let size = names.len();
-        let left = *names.entry(left).or_insert(size);
+    let mut todo: VecDeque<_> = gates.iter().copied().collect();
 
-        let size = names.len();
-        let right = *names.entry(right).or_insert(size);
+    while let Some(gate @ [left, kind, right, _, to]) = todo.pop_front() {
+        let left = cache[to_index(left)];
+        let right = cache[to_index(right)];
 
-        let size = names.len();
-        let to = *names.entry(to).or_insert(size);
-
-        ops.insert(to, (left, kind, right));
+        if left == u8::MAX || right == u8::MAX {
+            todo.push_back(gate);
+        } else {
+            cache[to_index(to)] = match kind {
+                "AND" => left & right,
+                "OR" => left | right,
+                "XOR" => left ^ right,
+                _ => unreachable!(),
+            }
+        }
     }
 
     let mut result = 0;
 
-    for i in (0..64).rev() {
-        let key = format!("z{i:02}");
-        if let Some(&key) = names.get(key.as_str()) {
-            result = (result << 1) | helper(&mut cache, &mut ops, key);
+    for i in (to_index("z00")..to_index("z64")).rev() {
+        if cache[i] != u8::MAX {
+            result = (result << 1) | (cache[i] as u64);
         }
     }
 
@@ -102,27 +105,3 @@ pub fn part2(input: &Input<'_>) -> String {
     result.sort_unstable();
     result.join(",")
 }
-
-fn helper(
-    cache: &mut FastMap<usize, u64>,
-    ops: &mut FastMap<usize, (usize, &str, usize)>,
-    key: usize,
-) -> u64 {
-    if let Some(&value) = cache.get(&key) {
-        return value;
-    }
-
-    let (left, op, right) = ops[&key];
-    let left = helper(cache, ops, left);
-    let right = helper(cache, ops, right);
-
-    let value = match op {
-        "AND" => left & right,
-        "OR" => left | right,
-        "XOR" => left ^ right,
-        _ => unreachable!(),
-    };
-
-    cache.insert(key, value);
-    value
-}

src/year2024/day25.rs

@@ -1,41 +1,32 @@
 //! # Code Chronicle
+const MASK: u64 = 0b011111_011111_011111_011111_011111_011111_011111;
+
 pub fn parse(input: &str) -> &str {
     input
 }
 
 pub fn part1(input: &str) -> u32 {
-    let mut iter = input.bytes();
+    let mut iter = input.bytes().map(|b| (b & 1) as u64);
     let mut locks = Vec::with_capacity(250);
     let mut keys = Vec::with_capacity(250);
     let mut result = 0;
 
-    loop {
-        let mut bits = 0;
-
-        for _ in 0..41 {
-            let b = iter.next().unwrap();
-            bits = (bits << 1) | (b & 1) as u64;
-        }
-
-        bits &= 0b011111_011111_011111_011111_011111_011111_011111;
+    while let Some(first) = iter.next() {
+        let bits = (0..40).fold(first, |bits, _| (bits << 1) | iter.next().unwrap());
 
-        if bits & 0b011111_000000_000000_000000_000000_000000_000000 != 0 {
-            locks.push(bits);
+        if bits & 1 == 0 {
+            locks.push(bits & MASK);
         } else {
-            keys.push(bits);
+            keys.push(bits & MASK);
         }
 
         iter.next();
-        if iter.next().is_none() {
-            break;
-        }
+        iter.next();
     }
 
     for lock in &locks {
         for key in &keys {
-            if lock & key == 0 {
-                result += 1;
-            }
+            result += (lock & key == 0) as u32;
         }
     }