day 18 performance improvement

README.md

@@ -1,3 +1,9 @@
 # Advent of Rust 2024
 
-A few of the solutions for [Advent of Code 2024](https://adventofcode.com/2024) in Rust.
+A few of the solutions for [Advent of Code 2024](https://adventofcode.com/2024) in Rust.
+
+## Points
+
+I finally (as of October 2025) finished all existing puzzles and am a part of the 500 star club!
+
+![Screenshot from Advent of Code saying "Totals stars: 500"](assets/500stars.png)

src/day18.rs

@@ -0,0 +1,147 @@
+use std::{collections::VecDeque, fs::read_to_string};
+
+use itertools::Itertools;
+
+use crate::utils::grid::Grid;
+
+pub fn day_main() {
+    let input = read_to_string("input/day18.txt").unwrap();
+    let input = input.trim();
+    println!(" part1: {}", part1(input));
+    println!(" part2: {}", part2(input));
+}
+
+type RiddleResult = usize;
+
+fn part1(input: &str) -> RiddleResult {
+    solve1(input, 1024, 70)
+}
+
+fn solve1(input: &str, n: usize, coord_max: i64) -> usize {
+    let points = parse(input);
+    sp(&points[..n], coord_max).unwrap()
+}
+
+fn sp(points: &[(i64, i64)], coord_max: i64) -> Option<usize> {
+    let mut pcheck = Grid::from_default(coord_max + 1, coord_max + 1);
+    for p in points {
+        pcheck.set(*p, true);
+    }
+    let mut visited = Grid::from_default(coord_max + 1, coord_max + 1);
+    let mut queue = VecDeque::from_iter([(0, 0, 0)]);
+    while let Some((x, y, c)) = queue.pop_front() {
+        if x == coord_max && y == coord_max {
+            return Some(c);
+        }
+
+        if visited.get((x, y)) == Some(&true) {
+            continue;
+        }
+        visited.set((x, y), true);
+
+        for (dx, dy) in [(0, 1), (1, 0), (0, -1), (-1, 0)] {
+            let (a, b) = (x + dx, y + dy);
+            if (0..=coord_max).contains(&a)
+                && (0..=coord_max).contains(&b)
+                && pcheck.get((a, b)) == Some(&false)
+            {
+                queue.push_back((a, b, c + 1));
+            }
+        }
+    }
+    None
+}
+
+fn parse(input: &str) -> Vec<(i64, i64)> {
+    input
+        .trim()
+        .lines()
+        .map(|line| {
+            line.split(",")
+                .map(|v| v.parse().unwrap())
+                .collect_tuple()
+                .unwrap()
+        })
+        .collect_vec()
+}
+
+fn part2(input: &str) -> String {
+    solve2(input, 1024, 70)
+}
+
+fn solve2(input: &str, fixed: usize, max_coord: i64) -> String {
+    let points = parse(input);
+
+    // we want the first point with which there is no shortest path
+    let mut i = fixed;
+    let mut jump = (points.len() - fixed) / 2;
+    #[cfg(debug_assertions)]
+    let mut loops = 0;
+    loop {
+        #[cfg(debug_assertions)]
+        {
+            loops += 1;
+        }
+        let l = sp(&points[..i - 1], max_coord);
+        let r = sp(&points[..i], max_coord);
+        if l.is_some() && r.is_none() {
+            #[cfg(debug_assertions)]
+            {
+                let iters_needed = i - fixed;
+                dbg!(loops, iters_needed);
+            }
+            return format!("{},{}", points[i - 1].0, points[i - 1].1);
+        }
+        if l.is_some() {
+            i += jump;
+        } else {
+            i -= jump;
+        }
+        jump /= 2;
+        if jump == 0 {
+            jump += 1;
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::day18::{solve1, solve2};
+
+    const TEST_INPUT: &str = r"5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0
+";
+
+    #[test]
+    fn test1() {
+        assert_eq!(solve1(TEST_INPUT, 12, 6), 22);
+    }
+
+    #[test]
+    fn test2() {
+        assert_eq!(solve2(TEST_INPUT, 12, 6), "6,1");
+    }
+}

src/day21.rs

@@ -0,0 +1,299 @@
+use std::{collections::HashMap, fs::read_to_string};
+
+use itertools::Itertools;
+
+pub fn day_main() {
+    let input = read_to_string("input/day21.txt").unwrap();
+    let input = input.trim();
+    println!(" part1: {}", part1(input));
+    println!(" part2: {}", part2(input));
+}
+
+type RiddleResult = i64;
+
+fn part1(input: &str) -> RiddleResult {
+    let mut p = Precomputed::new(2);
+    input
+        .lines()
+        .map(|line| p.shortest(line) * value(line))
+        .sum()
+}
+
+fn value(line: &str) -> i64 {
+    line[0..3].parse::<i64>().unwrap()
+}
+
+fn part2(input: &str) -> RiddleResult {
+    let mut p = Precomputed::new(25);
+    input
+        .lines()
+        .map(|line| p.shortest(line) * value(line))
+        .sum()
+}
+
+struct Precomputed {
+    num_sp: HashMap<(char, char), Vec<&'static str>>,
+    arrow_sp: HashMap<(char, char), Vec<&'static str>>,
+    robot_layers: i64,
+    cache: HashMap<(char, char, i64), i64>,
+}
+
+impl Precomputed {
+    fn new(robot_layers: i64) -> Self {
+        let num_sp = num_sp();
+        let arrow_sp = arrow_sp();
+        Self {
+            num_sp,
+            arrow_sp,
+            robot_layers,
+            cache: HashMap::new(),
+        }
+    }
+
+    fn shortest(&mut self, digit_pad: &str) -> RiddleResult {
+        format!("A{digit_pad}")
+            .chars()
+            .tuple_windows()
+            .map(|(a, b)| {
+                let x = self
+                    .num_sp
+                    .get(&(a, b))
+                    .unwrap()
+                    .clone()
+                    .iter()
+                    .map(|sp| format!("A{sp}A")) // we add the A in the next layer at the end of each sequence
+                    .map(|sp| {
+                        let x = if sp.len() > 1 {
+                            sp.chars()
+                                .tuple_windows()
+                                .map(|(c, d)| self.get(c, d, self.robot_layers))
+                                .sum::<i64>()
+                        } else {
+                            1
+                        };
+                        // println!(" sp {a} to {b} (NUM): {sp} -- {x}");
+                        x
+                    })
+                    .min()
+                    .unwrap();
+                // println!("{a}{b}: {x}");
+                x
+            })
+            // .inspect(|r| println!("shortest part: {r}"))
+            .sum()
+    }
+
+    fn get(&mut self, a: char, b: char, n: i64) -> i64 {
+        if n == 0 {
+            return 1;
+        }
+        if let Some(result) = self.cache.get(&(a, b, n)) {
+            return *result;
+        }
+        let paths = self.arrow_sp.get(&(a, b)).unwrap().clone();
+        let result = paths
+            .iter()
+            .map(|sp| format!("A{sp}A"))
+            .map(|sp| {
+                let x = if sp.len() > 1 {
+                    sp.chars()
+                        .tuple_windows()
+                        .map(|(c, d)| self.get(c, d, n - 1))
+                        .sum::<i64>()
+                } else {
+                    1
+                };
+                // println!(
+                //     "{}sp {a} to {b} ({n}): {sp} -- {x}",
+                //     " ".repeat(self.robot_layers as usize + 2 - n as usize)
+                // );
+                x
+            })
+            .min()
+            .unwrap();
+        self.cache.insert((a, b, n), result);
+        result
+    }
+}
+
+fn arrow_sp() -> HashMap<(char, char), Vec<&'static str>> {
+    let mut starters = HashMap::new();
+
+    starters.insert(('A', '<'), vec!["<v<", "v<<"]);
+    starters.insert(('A', '^'), vec!["<"]);
+    starters.insert(('A', '>'), vec!["v"]);
+    starters.insert(('A', 'v'), vec!["<v", "v<"]);
+
+    starters.insert(('<', '^'), vec![">^"]);
+    starters.insert(('<', '>'), vec![">>"]);
+    starters.insert(('<', 'v'), vec![">"]);
+
+    starters.insert(('^', '>'), vec![">v", "v>"]);
+    starters.insert(('^', 'v'), vec!["v"]);
+
+    starters.insert(('>', 'v'), vec!["<"]);
+
+    let mut result = starters.clone();
+    for ((from, to), paths) in starters {
+        result.insert((to, from), invert(&paths));
+    }
+
+    for c in "A<>v^".chars() {
+        result.insert((c, c), vec![""]);
+    }
+
+    result
+}
+
+fn num_sp() -> HashMap<(char, char), Vec<&'static str>> {
+    let mut starters = HashMap::new();
+
+    starters.insert(('A', '0'), vec!["<"]);
+    starters.insert(('A', '1'), vec!["<^<", "^<<"]);
+    starters.insert(('A', '2'), vec!["<^", "^<"]);
+    starters.insert(('A', '3'), vec!["^"]);
+    starters.insert(('A', '4'), vec!["<^<^", "<^^<", "^<<^", "^<^<", "^^<<"]);
+    starters.insert(('A', '5'), vec!["<^^", "^<^", "^^<"]);
+    starters.insert(('A', '6'), vec!["^^"]);
+    starters.insert(
+        ('A', '7'),
+        vec![
+            "<^<^^", "<^^<^", "<^^^<", "^<<^^", "^<^<^", "^<^^<", "^^^<<",
+        ],
+    );
+    starters.insert(('A', '8'), vec!["<^^^", "^<^^", "^^<^", "^^^<"]);
+    starters.insert(('A', '9'), vec!["^^^"]);
+
+    starters.insert(('0', '1'), vec!["^<"]);
+    starters.insert(('0', '2'), vec!["^"]);
+    starters.insert(('0', '3'), vec!["^>", ">^"]);
+    starters.insert(('0', '4'), vec!["^<^", "^^<"]);
+    starters.insert(('0', '5'), vec!["^^"]);
+    starters.insert(('0', '6'), vec!["^^>", "^>^"]);
+    starters.insert(('0', '7'), vec!["^<^^", "^^<^", "^^^<"]);
+    starters.insert(('0', '8'), vec!["^^^"]);
+    starters.insert(('0', '9'), vec!["^^^>", "^^>^", "^>^^", ">^^^"]);
+
+    starters.insert(('1', '2'), vec![">"]);
+    starters.insert(('1', '3'), vec![">>"]);
+    starters.insert(('1', '4'), vec!["^"]);
+    starters.insert(('1', '5'), vec!["^>", ">^"]);
+    starters.insert(('1', '6'), vec!["^>>", ">^>", ">>^"]);
+    starters.insert(('1', '7'), vec!["^^"]);
+    starters.insert(('1', '8'), vec!["^^>", "^>^", ">^^"]);
+    starters.insert(('1', '9'), vec!["^^>>", "^>^>", "^>>^", ">^>^", ">>^^"]);
+
+    starters.insert(('2', '3'), vec![">"]);
+    starters.insert(('2', '4'), vec!["<^", "^<"]);
+    starters.insert(('2', '5'), vec!["^"]);
+    starters.insert(('2', '6'), vec!["^>", ">^"]);
+    starters.insert(('2', '7'), vec!["<^^", "^<^", "^^<"]);
+    starters.insert(('2', '8'), vec!["^^"]);
+    starters.insert(('2', '9'), vec!["^^>", "^>^", ">^^"]);
+
+    starters.insert(('3', '4'), vec!["<<^", "<^<", "^<<"]);
+    starters.insert(('3', '5'), vec!["<^", "^<"]);
+    starters.insert(('3', '6'), vec!["^"]);
+    starters.insert(
+        ('3', '7'),
+        vec!["<<^^", "<^<^", "<^^<", "^<^<", "^<<^", "^^<<"],
+    );
+    starters.insert(('3', '8'), vec!["<^^", "^<^", "^^<"]);
+    starters.insert(('3', '9'), vec!["^^"]);
+
+    starters.insert(('4', '5'), vec![">"]);
+    starters.insert(('4', '6'), vec![">>"]);
+    starters.insert(('4', '7'), vec!["^"]);
+    starters.insert(('4', '8'), vec!["^>", ">^"]);
+    starters.insert(('4', '9'), vec!["^>>", ">^>", ">>^"]);
+
+    starters.insert(('5', '6'), vec![">"]);
+    starters.insert(('5', '7'), vec!["<^", "^<"]);
+    starters.insert(('5', '8'), vec!["^"]);
+    starters.insert(('5', '9'), vec!["^>", ">^"]);
+
+    starters.insert(('6', '7'), vec!["<<^", "<^<", "^<<"]);
+    starters.insert(('6', '8'), vec!["<^", "^<"]);
+    starters.insert(('6', '9'), vec!["^"]);
+
+    starters.insert(('7', '8'), vec![">"]);
+    starters.insert(('7', '9'), vec![">>"]);
+
+    starters.insert(('8', '9'), vec![">"]);
+
+    let mut result = starters.clone();
+    for ((from, to), paths) in starters {
+        result.insert((to, from), invert(&paths));
+    }
+
+    result
+}
+
+fn invert(paths: &Vec<&'static str>) -> Vec<&'static str> {
+    paths.iter().map(|path| reverse_path(path)).collect()
+}
+
+fn reverse_path(path: &str) -> &'static str {
+    path.chars()
+        .rev()
+        .map(|d| opposite(d))
+        .collect::<String>()
+        .leak()
+}
+
+fn opposite(d: char) -> char {
+    match d {
+        '<' => '>',
+        '^' => 'v',
+        '>' => '<',
+        'v' => '^',
+        _ => panic!("unknown direction {d}"),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::day21::Precomputed;
+
+    use super::{part1, part2};
+
+    const TEST_INPUT: &str = r"029A
+980A
+179A
+456A
+379A
+";
+
+    #[test]
+    fn example1() {
+        assert_eq!(part1(TEST_INPUT), 126384);
+    }
+
+    #[test]
+    fn example1_mini() {
+        assert_eq!(part1("029A"), 68 * 29);
+    }
+
+    #[test]
+    fn shortest_human() {
+        let mut precomputed = Precomputed::new(2);
+        assert_eq!(precomputed.get('<', '^', 0), 1);
+    }
+
+    #[test]
+    fn shortest_1st() {
+        let mut p = Precomputed::new(2);
+        assert_eq!(p.get('A', '^', 1), 2);
+    }
+
+    #[test]
+    fn shortest_2nd() {
+        let mut p = Precomputed::new(2);
+        assert_eq!(p.get('A', '^', 2), 8);
+    }
+
+    #[test]
+    fn test2() {
+        assert_eq!(part2(TEST_INPUT), 0);
+    }
+}

src/day22.rs

@@ -1,4 +1,10 @@
-use std::{fs::read_to_string, ops::BitXor};
+use std::{
+    collections::{HashMap, HashSet},
+    fs::read_to_string,
+    ops::BitXor,
+};
+
+use itertools::Itertools;
 
 pub fn day_main() {
     let input = read_to_string("input/day22.txt").unwrap();
@@ -16,13 +22,17 @@ fn part1(input: &str) -> RiddleResult {
 fn solution(initial_secret: i64) -> i64 {
     let mut secret = initial_secret;
     for _ in 0..2000 {
-        secret = prune(mix(secret * 64, secret));
-        secret = prune(mix(secret / 32, secret));
-        secret = prune(mix(secret * 2048, secret))
+        secret = fun_name(secret);
     }
     secret
 }
 
+fn fun_name(secret: i64) -> i64 {
+    let secret = prune(mix(secret * 64, secret));
+    let secret = prune(mix(secret / 32, secret));
+    prune(mix(secret * 2048, secret))
+}
+
 fn mix(value: i64, secret: i64) -> i64 {
     value.bitxor(secret)
 }
@@ -31,15 +41,64 @@ fn prune(value: i64) -> i64 {
     value % 16777216
 }
 
-fn part2(_input: &str) -> RiddleResult {
-    0
+fn part2(input: &str) -> RiddleResult {
+    let deltas = input
+        .trim()
+        .lines()
+        .map(|is| is.parse().unwrap())
+        .map(|s| generate(s))
+        .collect_vec();
+
+    let mut best = HashMap::new();
+    deltas.into_iter().for_each(|monkey| {
+        let mut seen = HashSet::new();
+
+        for (a, b, c, d) in monkey.iter().tuple_windows() {
+            let t = (a.delta, b.delta, c.delta, d.delta);
+            if !seen.contains(&t) {
+                seen.insert(t);
+                if !best.contains_key(&t) {
+                    best.insert(t, 0);
+                }
+                best.entry(t).and_modify(|v| *v += d.price);
+            }
+        }
+    });
+
+    best.into_values().max().unwrap()
+}
+
+fn generate(start: i64) -> Vec<Foo> {
+    let mut result = Vec::with_capacity(2000);
+    result.push(Foo {
+        secret: start,
+        price: start % 10,
+        delta: -999999,
+    });
+    for i in 1..=2000 {
+        let prev = result[i - 1].secret;
+        let next = fun_name(prev);
+        let price = next % 10;
+        let delta = price - result[i - 1].price;
+        result.push(Foo {
+            secret: next,
+            price,
+            delta,
+        });
+    }
+    result
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct Foo {
+    secret: i64,
+    price: i64,
+    delta: i64,
 }
 
 #[cfg(test)]
 mod test {
-    use super::{part1, part2};
-
-    const TEST_INPUT: &str = r"";
+    use super::*;
 
     #[test]
     fn test1() {
@@ -57,6 +116,11 @@ mod test {
 
     #[test]
     fn test2() {
-        assert_eq!(part2(TEST_INPUT), 0);
+        let input = "1
+2
+3
+2024
+        ";
+        assert_eq!(part2(input), 23);
     }
 }

src/day23.rs

@@ -0,0 +1,150 @@
+use std::{
+    collections::{HashMap, HashSet},
+    fs::read_to_string,
+};
+
+use itertools::Itertools;
+
+pub fn day_main() {
+    let input = read_to_string("input/day23.txt").unwrap();
+    let input = input.trim();
+    println!(" part1: {}", part1(input));
+    println!(" part2: {}", part2(input));
+}
+
+type RiddleResult = usize;
+
+fn part1(input: &str) -> RiddleResult {
+    let neighbours = make_graph(input);
+    let mut sets = vec![];
+    for a in neighbours.keys() {
+        for b in &neighbours[a] {
+            let common = neighbours[a].intersection(&neighbours[b]);
+            for c in common {
+                let mut v = vec![a, b, c];
+                v.sort_unstable();
+                sets.push(v);
+            }
+        }
+    }
+    let sets = sets.iter().unique().collect_vec();
+    sets.iter()
+        .filter(|set| set.iter().any(|t| t.starts_with("t")))
+        .count()
+}
+
+fn make_graph(input: &str) -> HashMap<&str, HashSet<&str>> {
+    let mut neighbours: HashMap<&str, HashSet<&str>> = HashMap::new();
+    input.lines().for_each(|line| {
+        let (a, b) = line.split_once("-").unwrap();
+        neighbours
+            .entry(a)
+            .and_modify(|list| {
+                list.insert(b);
+            })
+            .or_insert_with(|| HashSet::from([b]));
+        neighbours
+            .entry(b)
+            .and_modify(|list| {
+                list.insert(a);
+            })
+            .or_insert_with(|| HashSet::from([a]));
+    });
+    neighbours
+}
+
+fn part2(input: &str) -> String {
+    let graph = make_graph(input);
+
+    let mut best = "".to_string();
+    for a in graph.keys() {
+        let mut edge_counts = HashMap::<&str, u32>::new();
+        for b in &graph[a] {
+            edge_counts.entry(b).and_modify(|v| *v += 1).or_insert(1);
+            for c in &graph[b] {
+                edge_counts.entry(c).and_modify(|v| *v += 1).or_insert(1);
+            }
+        }
+        // now we have all counts for shared edges
+        // next, we find the highest number k for which there are k nodes which are connected to at least k other nodes
+        let mut k = *edge_counts.values().max().unwrap();
+        while k > 0 {
+            let nodes = edge_counts
+                .iter()
+                .filter(|(_, v)| **v >= k)
+                .map(|(k, _)| k)
+                .collect_vec();
+
+            if nodes.len() < (k + 1) as usize {
+                k -= 1;
+                continue;
+            }
+
+            // now we check if indeed all of the candidate nodes are connected
+            let found = nodes
+                .iter()
+                .filter(|&x| nodes.iter().all(|y| y == x || graph[*x].contains(*y)))
+                .sorted_unstable()
+                .join(",");
+            // disclaimer: this works for this input but not in general (think of a graph where a is in the middle and the other nodes in
+            // a circle around it, each connected to their left and right neighbour. There could be 10 nodes with degree 3 in there
+            // but ofc they wouldn't be all connected - so this "solution" would return nothing, althoug a max clique of
+            // size 3 would exist)
+
+            if found.len() > best.len() {
+                best = found;
+            }
+            break;
+        }
+    }
+
+    best
+}
+
+#[cfg(test)]
+mod test {
+    use super::{part1, part2};
+
+    const TEST_INPUT: &str = r"kh-tc
+qp-kh
+de-cg
+ka-co
+yn-aq
+qp-ub
+cg-tb
+vc-aq
+tb-ka
+wh-tc
+yn-cg
+kh-ub
+ta-co
+de-co
+tc-td
+tb-wq
+wh-td
+ta-ka
+td-qp
+aq-cg
+wq-ub
+ub-vc
+de-ta
+wq-aq
+wq-vc
+wh-yn
+ka-de
+kh-ta
+co-tc
+wh-qp
+tb-vc
+td-yn";
+
+    #[test]
+    fn test1() {
+        assert_eq!(part1(TEST_INPUT), 7);
+    }
+
+    #[test]
+    fn test2() {
+        assert_eq!(part2(TEST_INPUT), "co,de,ka,ta");
+    }
+}

src/day24.rs

@@ -0,0 +1,225 @@
+use std::{collections::HashMap, fs::read_to_string, hash::Hash};
+
+use itertools::Itertools;
+
+pub fn day_main() {
+    let input = read_to_string("input/day24.txt").unwrap();
+    let input = input.trim();
+    println!(" part1: {}", part1(input));
+    println!(" part2: {}", part2(input));
+}
+
+type RiddleResult = u64;
+
+fn part1(input: &str) -> RiddleResult {
+    let (a, b) = input.split_once("\n\n").unwrap();
+    let program = b
+        .lines()
+        .map(|l| {
+            let (lhs, rhs) = l.split_once(" -> ").unwrap();
+            (rhs, lhs)
+        })
+        .collect_map();
+    let start_values = a
+        .lines()
+        .map(|l| {
+            let (x, y) = l.split_once(": ").unwrap();
+            let b = match y {
+                "0" => false,
+                "1" => true,
+                _ => panic!("bad values {y}"),
+            };
+            (x, b)
+        })
+        .collect_map();
+    let binary_result = program
+        .keys()
+        .filter(|k| k.starts_with("z"))
+        .sorted_unstable()
+        .map(|z| compute(&program, &start_values, z))
+        .map(|b| match b {
+            true => "1",
+            false => "0",
+        })
+        .rev()
+        .join("");
+
+    u64::from_str_radix(&binary_result, 2).unwrap()
+}
+
+fn compute(program: &HashMap<&str, &str>, start_values: &HashMap<&str, bool>, start: &str) -> bool {
+    if start_values.contains_key(start) {
+        return start_values[start];
+    }
+
+    let v = program[start].split(" ").collect_vec();
+    let lhs = compute(program, start_values, v[0]);
+    let rhs = compute(program, start_values, v[2]);
+    match v[1] {
+        "AND" => lhs & rhs,
+        "OR" => lhs | rhs,
+        "XOR" => lhs ^ rhs,
+        _ => panic!("bad operator {}", v[1]),
+    }
+}
+
+const SWAPS: [(&'static str, &'static str); 4] = [
+    ("rkf", "z09"),
+    ("jgb", "z20"),
+    ("vcg", "z24"),
+    ("rvc", "rrs"),
+];
+
+fn swap(s: &str) -> &str {
+    for (a, b) in &SWAPS {
+        if *a == s {
+            return b;
+        }
+        if *b == s {
+            return a;
+        }
+    }
+    s
+}
+
+fn part2(input: &str) -> String {
+    let (_, b) = input.split_once("\n\n").unwrap();
+    let program = b
+        .lines()
+        .map(|l| l.split_once(" -> ").unwrap())
+        .map(|(def, name)| (def, swap(name)))
+        .collect_map();
+
+    if program["y00 XOR x00"] != "z00" {
+        panic!("first bit is bad already");
+    }
+    let Some(mut c_prev) = find(&program, "y00", "AND", "x00") else {
+        panic!("first carrier missing");
+    };
+    for i in 1..=44 {
+        // println!();
+        // println!("## {i:02}");
+        let x_i = format!("x{:02}", i);
+        let y_i = format!("y{:02}", i);
+        let op = "XOR";
+        let Some(xor_i) = find(&program, x_i.as_str(), op, y_i.as_str()) else {
+            println!("xor_{:02} missing", i);
+            break;
+        };
+        // println!("xor_i = {xor_i}");
+        let Some(z_i) = find(&program, &xor_i, "XOR", &c_prev) else {
+            println!("z_{:02} missing", i);
+            break;
+        };
+        if format!("z{i:02}") != z_i {
+            println!("z_i is bad: {z_i}");
+            break;
+        }
+        let Some(and_inputs_i) = find(&program, &x_i, "AND", &y_i) else {
+            println!("and_inputs_{:02} missing", i);
+            break;
+        };
+        // println!("and_inputs_i = {and_inputs_i}");
+        let Some(and_all_i) = find(&program, &c_prev, "AND", &xor_i) else {
+            println!("and of last carrier with xor_{:02} missing", i);
+            break;
+        };
+        // println!("and_all_i = {and_all_i}");
+        let Some(c_i) = find(&program, &and_all_i, "OR", &and_inputs_i) else {
+            println!("c_{:02} missing", i);
+            break;
+        };
+        // println!("c_i = {c_i}");
+        c_prev = c_i;
+    }
+    SWAPS
+        .iter()
+        .map(|(a, b)| [a, b])
+        .flatten()
+        .sorted()
+        .join(",")
+}
+
+fn find(program: &HashMap<&str, &str>, a: &str, op: &str, b: &str) -> Option<String> {
+    program
+        .get(format!("{a} {op} {b}").as_str())
+        .or_else(|| program.get(format!("{b} {op} {a}").as_str()))
+        .map(|s| s.to_string())
+}
+
+/// Trait that provides a `collect_map` method for iterators over key-value tuples.
+pub trait CollectMap<K, V>: Iterator<Item = (K, V)>
+where
+    K: Eq + Hash,
+{
+    /// Collects the iterator into a `HashMap`.
+    fn collect_map(self) -> HashMap<K, V>;
+}
+
+// Blanket implementation for any compatible iterator
+impl<I, K, V> CollectMap<K, V> for I
+where
+    I: Iterator<Item = (K, V)>,
+    K: Eq + Hash,
+{
+    fn collect_map(self) -> HashMap<K, V> {
+        self.collect()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::part1;
+
+    const TEST_INPUT: &str = r"x00: 1
+x01: 0
+x02: 1
+x03: 1
+x04: 0
+y00: 1
+y01: 1
+y02: 1
+y03: 1
+y04: 1
+
+ntg XOR fgs -> mjb
+y02 OR x01 -> tnw
+kwq OR kpj -> z05
+x00 OR x03 -> fst
+tgd XOR rvg -> z01
+vdt OR tnw -> bfw
+bfw AND frj -> z10
+ffh OR nrd -> bqk
+y00 AND y03 -> djm
+y03 OR y00 -> psh
+bqk OR frj -> z08
+tnw OR fst -> frj
+gnj AND tgd -> z11
+bfw XOR mjb -> z00
+x03 OR x00 -> vdt
+gnj AND wpb -> z02
+x04 AND y00 -> kjc
+djm OR pbm -> qhw
+nrd AND vdt -> hwm
+kjc AND fst -> rvg
+y04 OR y02 -> fgs
+y01 AND x02 -> pbm
+ntg OR kjc -> kwq
+psh XOR fgs -> tgd
+qhw XOR tgd -> z09
+pbm OR djm -> kpj
+x03 XOR y03 -> ffh
+x00 XOR y04 -> ntg
+bfw OR bqk -> z06
+nrd XOR fgs -> wpb
+frj XOR qhw -> z04
+bqk OR frj -> z07
+y03 OR x01 -> nrd
+hwm AND bqk -> z03
+tgd XOR rvg -> z12
+tnw OR pbm -> gnj";
+    #[test]
+    fn test1() {
+        assert_eq!(part1(TEST_INPUT), 2024);
+    }
+}

src/day25.rs

@@ -0,0 +1,117 @@
+use std::fs::read_to_string;
+
+use itertools::Itertools;
+
+pub fn day_main() {
+    let input = read_to_string("input/day25.txt").unwrap();
+    let input = input.trim();
+    println!(" part1: {}", part1(input));
+}
+
+type RiddleResult = i64;
+
+fn part1(input: &str) -> RiddleResult {
+    let (locks, keys): (Vec<_>, Vec<_>) = input
+        .split("\n\n")
+        .map(|item| {
+            let block = item
+                .lines()
+                .map(|line| line.chars().collect_vec())
+                .collect_vec();
+            let lock = block[0].contains(&'#');
+            let summary: (u8, u8, u8, u8, u8) = if lock {
+                // lock
+                (0..5)
+                    .map(|x| {
+                        (0..6)
+                            .map(|y| block[y][x])
+                            .enumerate()
+                            .find(|(_, it)| *it == '.')
+                            .unwrap_or((6, '.'))
+                            .0 as u8
+                    })
+                    .collect_tuple()
+                    .unwrap()
+            } else {
+                (0..5)
+                    .map(|x| {
+                        7 - ((0..6)
+                            .map(|y| block[y][x])
+                            .enumerate()
+                            .find(|(_, it)| *it == '#')
+                            .unwrap_or((6, '.'))
+                            .0 as u8)
+                    })
+                    .collect_tuple()
+                    .unwrap()
+            };
+            (lock, summary.0, summary.1, summary.2, summary.3, summary.4)
+        })
+        .partition(|s| s.0);
+
+    let mut matches = 0;
+    for lock in locks {
+        for &key in &keys {
+            if lock.1 + key.1 < 8
+                && lock.2 + key.2 < 8
+                && lock.3 + key.3 < 8
+                && lock.4 + key.4 < 8
+                && lock.5 + key.5 < 8
+            {
+                matches += 1;
+            }
+        }
+    }
+    matches
+}
+
+#[cfg(test)]
+mod test {
+    use super::part1;
+
+    const TEST_INPUT: &str = r"#####
+.####
+.####
+.####
+.#.#.
+.#...
+.....
+
+#####
+##.##
+.#.##
+...##
+...#.
+...#.
+.....
+
+.....
+#....
+#....
+#...#
+#.#.#
+#.###
+#####
+
+.....
+.....
+#.#..
+###..
+###.#
+###.#
+#####
+
+.....
+.....
+.....
+#....
+#.#..
+#.#.#
+#####
+    ";
+
+    #[test]
+    fn test1() {
+        assert_eq!(part1(TEST_INPUT), 3);
+    }
+}

src/lib.rs

@@ -15,7 +15,12 @@ pub mod day14;
 pub mod day15;
 pub mod day16;
 pub mod day17;
+pub mod day18;
 pub mod day19;
+pub mod day21;
 pub mod day22;
+pub mod day23;
+pub mod day24;
+pub mod day25;
 // PLACEHOLDER
 pub mod utils;

src/main.rs

@@ -22,18 +22,28 @@ fn main() {
         (15, day15::day_main),
         (16, day16::day_main),
         (17, day17::day_main),
+        (18, day18::day_main),
         (19, day19::day_main),
+        (21, day21::day_main),
         (22, day22::day_main),
+        (23, day23::day_main),
+        (23, day23::day_main),
+        (24, day24::day_main),
+        (25, day25::day_main),
         // PLACEHOLDER
     ]);
     let day: Option<u8> = args().nth(1).and_then(|a| a.parse().ok());
     let Some(day) = day else {
+        let start = Instant::now();
         mains
             .iter()
             .sorted_by_key(|entry| entry.0)
             .for_each(|(d, f)| {
                 run(*d, f);
             });
+        let duration = start.elapsed();
+        println!();
+        println!("{COLOR}{ITALIC}All tasks took {duration:?}{RESET_FORMATTING}");
         return;
     };