solution: day 23

data/examples/20-2.txt

@@ -0,0 +1,5 @@
+broadcaster -> a
+%a -> inv, con
+&inv -> b
+%b -> con
+&con -> output

data/examples/21.txt

@@ -0,0 +1,11 @@
+...........
+.....###.#.
+.###.##..#.
+..#.#...#..
+....#.#....
+.##..S####.
+.##..#...#.
+.......##..
+.##.#.####.
+.##..##.##.
+...........

data/examples/22.txt

@@ -0,0 +1,7 @@
+1,0,1~1,2,1
+0,0,2~2,0,2
+0,2,3~2,2,3
+0,0,4~0,2,4
+2,0,5~2,2,5
+0,1,6~2,1,6
+1,1,9~1,1,8

data/examples/23.txt

@@ -0,0 +1,23 @@
+#.#####################
+#.......#########...###
+#######.#########.#.###
+###.....#.>.>.###.#.###
+###v#####.#v#.###.#.###
+###.>...#.#.#.....#...#
+###v###.#.#.#########.#
+###...#.#.#.......#...#
+#####.#.#.#######.#.###
+#.....#.#.#.......#...#
+#.#####.#.#.#########v#
+#.#...#...#...###...>.#
+#.#.#v#######v###.###v#
+#...#.>.#...>.>.#.###.#
+#####v#.#.###v#.#.###.#
+#.....#...#...#.#.#...#
+#.#########.###.#.#.###
+#...###...#...#...#.###
+###.###.#.###v#####v###
+#...#...#.#.>.>.#.>.###
+#.###.###.#.###.#.#v###
+#.....###...###...#...#
+#####################.#

src/bin/20.rs

@@ -1,14 +1,16 @@
 use std::{
     collections::{HashMap, VecDeque},
-    mem::swap,
     str::FromStr,
 };
 
+use aoc::lcm;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum Module {
     Broadcaster,
     FlipFlop(bool),
     Conjuction,
+    Output,
 }
 
 #[derive(Debug)]
@@ -20,7 +22,8 @@ impl FromStr for Module {
         Ok(match s {
             "%" => Module::FlipFlop(false),
             "&" => Module::Conjuction,
-            _ => Module::Broadcaster,
+            "b" => Module::Broadcaster,
+            _ => return Err(ParseModuleError),
         })
     }
 }
@@ -37,13 +40,18 @@ fn parse_input(input: &str) -> Vec<Node> {
     let mut nodes = Vec::new();
     let mut mapper: HashMap<String, usize> = HashMap::new();
 
+    let output = Node {
+        index: 0,
+        module: Module::Output,
+        inputs: Vec::new(),
+        outputs: Vec::new(),
+    };
+    nodes.push(output);
+
     for line in input.lines() {
         let (from, _) = line.split_once(" -> ").unwrap();
-        let (module, mut name) = from.split_at(1);
+        let (module, name) = from.split_at(1);
         let module: Module = module.parse().unwrap();
-        if module == Module::Broadcaster {
-            name = from;
-        }
 
         *mapper.entry(name.to_string()).or_default() = nodes.len();
 
@@ -59,15 +67,11 @@ fn parse_input(input: &str) -> Vec<Node> {
 
     for line in input.lines() {
         let (from, to) = line.split_once(" -> ").unwrap();
-        let (module, mut name) = from.split_at(1);
-        let module: Module = module.parse().unwrap();
-        if module == Module::Broadcaster {
-            name = from;
-        }
+        let (_, name) = from.split_at(1);
 
         let index = mapper[name];
         for destination in to.split(", ") {
-            let to_index = mapper[destination];
+            let to_index = *mapper.get(destination).unwrap_or(&0);
             nodes[index].outputs.push(to_index);
             nodes[to_index].inputs.push(index);
         }
@@ -76,99 +80,101 @@ fn parse_input(input: &str) -> Vec<Node> {
     nodes
 }
 
-pub fn part_one(input: &str) -> Option<usize> {
+pub fn cycle(input: &str, button_presses: Option<usize>) -> usize {
     let mut nodes = parse_input(input);
 
-    let mut graph = vec![vec![None; nodes.len()]; nodes.len()];
+    let mut graph = vec![vec![false; nodes.len()]; nodes.len()];
 
     let mut highs = 0;
     let mut lows = 0;
 
     let broadcaster = nodes
         .iter()
-        .find(|x| x.module == Module::Broadcaster)?
+        .find(|x| x.module == Module::Broadcaster)
+        .unwrap()
         .index;
 
-    for _ in 0..1000 {
-        let mut stack = VecDeque::from([broadcaster]);
-        while !stack.is_empty() {
-            let mut new_stack = VecDeque::new();
-            let mut new_graph = graph.clone();
+    let mut hm = HashMap::new();
+    let critical_node = nodes[0].inputs.first().copied();
+    let critical_inputs = critical_node.map(|x| nodes[x].inputs.len());
 
-            while let Some(index) = stack.pop_front() {
-                let node = &nodes[index];
-                let mut new_module = None;
+    for i in 1..=button_presses.unwrap_or(usize::MAX) {
+        if let Some(c) = critical_inputs {
+            if button_presses.is_none() && hm.values().len() == c {
+                return hm.values().copied().reduce(lcm).unwrap_or(0);
+            }
+        }
 
-                match node.module {
-                    Module::Broadcaster => {
-                        for dest_index in node.outputs.iter() {
-                            new_graph[index][*dest_index] = Some(false);
-                            new_stack.push_back(*dest_index);
-                            lows += 1;
-                        }
-                    }
-                    Module::FlipFlop(high) => {
-                        let mut swapper = None;
-                        for in_index in nodes[index].inputs.iter() {
-                            let value = &mut graph[*in_index][index];
-                            if value.is_some() {
-                                debug_assert!(swapper.is_none());
-                                swap(&mut swapper, value);
-                            }
-                        }
+        let mut stack = VecDeque::from([(broadcaster, false)]);
 
-                        if !swapper.unwrap() {
-                            let signal = !high;
+        while let Some((index, signal)) = stack.pop_front() {
+            if signal {
+                highs += 1;
+            } else {
+                lows += 1;
+            }
 
-                            for dest_index in nodes[index].outputs.iter() {
-                                new_graph[index][*dest_index] = Some(signal);
-                                new_stack.push_back(*dest_index);
-                                if signal {
-                                    highs += 1;
-                                } else {
-                                    lows += 1;
-                                }
-                            }
+            let node = &nodes[index];
+            let mut new_module = None;
 
-                            new_module = Some(Module::FlipFlop(signal));
-                        }
-                    }
-                    Module::Conjuction => {
-                        let mut all = true;
-
-                        for in_index in nodes[index].inputs.iter() {
-                            let value = graph[*in_index][index];
-                            all &= value.unwrap_or(false);
-                        }
-
-                        for dest_index in nodes[index].outputs.iter() {
-                            new_graph[index][*dest_index] = Some(!all);
-                            new_stack.push_back(*dest_index);
-                            if !all {
-                                highs += 1;
-                            } else {
-                                lows += 1;
-                            }
-                        }
+            match node.module {
+                Module::Output => (),
+                Module::Broadcaster => {
+                    for dest_index in node.outputs.iter().copied() {
+                        stack.push_back((dest_index, false));
                     }
                 }
+                Module::FlipFlop(high) => {
+                    if !signal {
+                        let signal = !high;
 
-                let node = &mut nodes[index];
-                if let Some(module) = new_module {
-                    node.module = module;
+                        for dest_index in nodes[index].outputs.iter().copied() {
+                            graph[index][dest_index] = signal;
+                            stack.push_back((dest_index, signal));
+                        }
+
+                        new_module = Some(Module::FlipFlop(signal));
+                    }
+                }
+                Module::Conjuction => {
+                    let mut all = true;
+
+                    for in_index in nodes[index].inputs.iter().copied() {
+                        all &= graph[in_index][index];
+                    }
+
+                    for dest_index in nodes[index].outputs.iter().copied() {
+                        graph[index][dest_index] = !all;
+                        stack.push_back((dest_index, !all));
+                    }
+
+                    if let Some(c) = critical_node {
+                        if index == c {
+                            for in_index in nodes[index].inputs.iter().copied() {
+                                if graph[in_index][index] {
+                                    hm.entry(in_index).or_insert(i);
+                                }
+                            }
+                        }
+                    }
                 }
             }
 
-            stack = new_stack;
-            graph = new_graph;
+            let node = &mut nodes[index];
+            if let Some(module) = new_module {
+                node.module = module;
+            }
         }
     }
 
-    Some(highs * lows)
+    highs * lows
+}
+pub fn part_one(input: &str) -> Option<usize> {
+    Some(cycle(input, Some(1000)))
 }
 
-pub fn part_two(input: &str) -> Option<u32> {
-    None
+pub fn part_two(input: &str) -> Option<usize> {
+    Some(cycle(input, None))
 }
 
 aoc::solution!(20);
@@ -177,11 +183,24 @@ aoc::solution!(20);
 mod tests {
     use super::*;
     #[test]
-    fn test_part_one() {
-        assert_eq!(part_one(&aoc::template::read_file("examples", 20)), None);
+    fn test_part_one_first() {
+        assert_eq!(
+            part_one(&aoc::template::read_file_part("examples", 20, 1)),
+            Some(32000000)
+        );
+    }
+    #[test]
+    fn test_part_one_second() {
+        assert_eq!(
+            part_one(&aoc::template::read_file_part("examples", 20, 2)),
+            Some(11687500)
+        );
     }
     #[test]
     fn test_part_two() {
-        assert_eq!(part_two(&aoc::template::read_file("examples", 20)), None);
+        assert_eq!(
+            part_two(&aoc::template::read_file_part("examples", 20, 2)),
+            Some(1)
+        );
     }
 }

src/bin/21.rs

@@ -0,0 +1,106 @@
+use std::{collections::HashSet, usize};
+
+fn parse_input(input: &str) -> (Vec<Vec<u8>>, (isize, isize)) {
+    let mut grid: Vec<_> = input.lines().map(|x| x.as_bytes().to_vec()).collect();
+
+    let start = grid
+        .iter()
+        .enumerate()
+        .flat_map(|(y, item)| item.iter().enumerate().map(move |(x, item)| (x, y, *item)))
+        .find_map(|(x, y, s)| if s == b'S' { Some((y, x)) } else { None })
+        .unwrap();
+
+    grid[start.0][start.1] = b'.';
+
+    (grid, (start.0 as isize, start.1 as isize))
+}
+
+fn walk_return_at(
+    grid: &[Vec<u8>],
+    start: (isize, isize),
+    mut returns: Vec<usize>,
+    can_cycle: bool,
+) -> Vec<usize> {
+    returns.sort_by(|a, b| b.cmp(a));
+
+    let h = grid.len() as isize;
+    let w = grid[0].len() as isize;
+
+    let invalid_indexing = |y, x| y < 0 || y >= h || x < 0 || x >= w;
+
+    let mut results = Vec::new();
+    let length = returns[0];
+    let mut next = returns.pop().unwrap();
+
+    let mut visited = HashSet::new();
+    visited.insert(start);
+
+    for i in 1..=length {
+        let mut new_visited = HashSet::new();
+
+        for (y, x) in visited.iter() {
+            for (dy, dx) in [(1, 0), (0, 1), (-1, 0), (0, -1)] {
+                let (ny, nx) = (y + dy, x + dx);
+
+                if !can_cycle && invalid_indexing(ny, nx) {
+                    continue;
+                }
+
+                let (cy, cx) = (ny.rem_euclid(h) as usize, nx.rem_euclid(w) as usize);
+
+                if grid[cy][cx] == b'.' {
+                    new_visited.insert((ny, nx));
+                }
+            }
+        }
+
+        visited = new_visited;
+
+        if i == next {
+            results.push(visited.len());
+            if !returns.is_empty() {
+                next = returns.pop().unwrap();
+            }
+        }
+    }
+
+    results
+}
+
+pub fn part_one(input: &str) -> Option<usize> {
+    let (grid, start) = parse_input(input);
+    let result = walk_return_at(&grid, start, vec![64], false);
+
+    Some(result[0])
+}
+
+pub fn part_two(input: &str) -> Option<usize> {
+    let (grid, start) = parse_input(input);
+
+    let h = grid.len();
+    let s = start.0 as usize;
+
+    let result = walk_return_at(&grid, start, vec![s, s + h, s + 2 * h], true);
+
+    let a = (result[2] - 2 * result[1] + result[0]) / 2;
+    let b = (result[1] - result[0]) - a;
+    let c = result[0];
+
+    let x = 26501365 / h;
+
+    Some(a * x * x + b * x + c)
+}
+
+aoc::solution!(21);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_part_one() {
+        assert_eq!(
+            part_one(&aoc::template::read_file("examples", 21)),
+            Some(42)
+        );
+    }
+}

src/bin/22.rs

@@ -0,0 +1,143 @@
+use std::{collections::HashMap, str::FromStr};
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+struct Brick {
+    from: (usize, usize, usize),
+    to: (usize, usize, usize),
+}
+
+#[derive(Debug)]
+struct ParseBrickError;
+
+impl FromStr for Brick {
+    type Err = ParseBrickError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (first, second) = s.split_once('~').ok_or(ParseBrickError)?;
+
+        let sorted: Vec<_> = first
+            .split(',')
+            .filter_map(|y| y.parse().ok())
+            .zip(second.split(',').filter_map(|y| y.parse().ok()))
+            .map(|(x, y)| if x < y { (x, y) } else { (y, x) })
+            .collect();
+        let from = (sorted[0].0, sorted[1].0, sorted[2].0);
+        let to = (sorted[0].1, sorted[1].1, sorted[2].1);
+
+        Ok(Self { from, to })
+    }
+}
+
+impl Brick {
+    fn height(&self) -> usize {
+        self.to.2 - self.from.2 + 1
+    }
+
+    fn points(&self) -> impl Iterator<Item = (usize, usize, usize)> + '_ {
+        (self.from.0..=self.to.0).flat_map(move |x| {
+            (self.from.1..=self.to.1)
+                .flat_map(move |y| (self.from.2..=self.to.2).map(move |z| (x, y, z)))
+        })
+    }
+}
+
+impl PartialOrd for Brick {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Brick {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.from
+            .2
+            .cmp(&other.from.2)
+            .then((self.from.0, self.from.1).cmp(&(other.from.0, other.from.1)))
+    }
+}
+
+#[derive(Debug, Clone)]
+struct Tower {
+    bricks: Vec<Brick>,
+}
+
+impl Tower {
+    fn new(mut bricks: Vec<Brick>) -> Self {
+        bricks.sort();
+        let mut ret = Self { bricks };
+        ret.compress(None);
+        ret
+    }
+
+    fn compress(&mut self, skip: Option<usize>) -> usize {
+        let mut heights: HashMap<(usize, usize), usize> = HashMap::new();
+        let mut moved = 0;
+
+        for brick in self
+            .bricks
+            .iter_mut()
+            .enumerate()
+            .filter(|(i, _)| *i != skip.unwrap_or(usize::MAX))
+            .map(|(_, x)| x)
+        {
+            let height = brick.height();
+            let new_height = brick
+                .points()
+                .map(|(x, y, _)| *heights.entry((x, y)).or_default())
+                .max()
+                .unwrap();
+
+            for (x, y, _) in brick.points() {
+                *heights.get_mut(&(x, y)).unwrap() = new_height + height;
+            }
+
+            if new_height + 1 == brick.from.2 {
+                continue;
+            }
+
+            if skip.is_none() {
+                brick.from.2 = new_height + 1;
+                brick.to.2 = new_height + height;
+            }
+
+            moved += 1;
+        }
+
+        moved
+    }
+}
+
+pub fn part_one(input: &str) -> Option<usize> {
+    let mut tower = Tower::new(input.lines().filter_map(|x| x.parse().ok()).collect());
+
+    Some(
+        (0..tower.bricks.len())
+            .map(|i| tower.compress(Some(i)))
+            .filter(|m| *m == 0)
+            .count(),
+    )
+}
+
+pub fn part_two(input: &str) -> Option<usize> {
+    let mut tower = Tower::new(input.lines().filter_map(|x| x.parse().ok()).collect());
+
+    Some(
+        (0..tower.bricks.len())
+            .map(|i| tower.compress(Some(i)))
+            .sum(),
+    )
+}
+
+aoc::solution!(22);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_part_one() {
+        assert_eq!(part_one(&aoc::template::read_file("examples", 22)), Some(5));
+    }
+    #[test]
+    fn test_part_two() {
+        assert_eq!(part_two(&aoc::template::read_file("examples", 22)), Some(7));
+    }
+}

src/bin/23.rs

@@ -0,0 +1,161 @@
+use std::{
+    collections::{HashMap, HashSet},
+    iter::once,
+};
+
+const DIRS: [(isize, isize); 4] = [(1, 0), (0, 1), (-1, 0), (0, -1)];
+
+#[derive(Debug, Default)]
+struct Node {
+    neighbours: Vec<(usize, usize)>,
+}
+
+fn build_graph(input: &str, two_way: bool) -> (Vec<Node>, usize) {
+    let mut grid: Vec<Vec<_>> = input.lines().map(|x| x.as_bytes().to_vec()).collect();
+
+    let l = grid[0].len();
+
+    let border: Vec<_> = once(b'#').cycle().take(l).collect();
+    grid.insert(0, border.clone());
+    grid.push(border);
+
+    let start = (1, 1);
+    let end = (grid.len() - 2, grid[0].len() - 2);
+
+    let mut nodes = Vec::new();
+
+    let mut mapper = HashMap::new();
+    mapper.insert(start, 0);
+
+    let mut visited: HashSet<(usize, usize)> = HashSet::new();
+
+    let mut stack = Vec::new();
+    // (from_node, at, len)
+    stack.push((start, start, 0));
+
+    let forced = |x| match x {
+        b'>' => (0, 1),
+        b'v' => (1, 0),
+        _ => (0, 0),
+    };
+
+    while let Some((from, (y, x), len)) = stack.pop() {
+        let is_node = DIRS
+            .iter()
+            .filter(|(dy, dx)| {
+                grid[((y as isize) + dy) as usize][((x as isize) + dx) as usize] != b'#'
+            })
+            .count()
+            > 2
+            || (y, x) == start
+            || (y, x) == end;
+
+        if is_node {
+            if !visited.contains(&(y, x)) {
+                mapper.insert((y, x), nodes.len());
+                nodes.push(Node::default());
+            }
+
+            if from != (y, x) {
+                nodes[mapper[&from]].neighbours.push((mapper[&(y, x)], len));
+                if two_way {
+                    nodes[mapper[&(y, x)]].neighbours.push((mapper[&from], len));
+                }
+            }
+        }
+
+        if !visited.insert((y, x)) {
+            continue;
+        }
+        for (ny, nx, _, _) in DIRS
+            .iter()
+            .map(|(dy, dx)| {
+                (
+                    ((y as isize) + dy) as usize,
+                    ((x as isize) + dx) as usize,
+                    dy,
+                    dx,
+                )
+            })
+            .filter(|(ny, nx, _, _)| grid[*ny][*nx] != b'#')
+            .filter(|(ny, nx, dy, dx)| {
+                let (fy, fx) = forced(grid[*ny][*nx]);
+                (fy + **dy, fx + **dx) != (0, 0)
+            })
+        {
+            let new_len = if is_node { 1 } else { len + 1 };
+            let new_from = if is_node { (y, x) } else { from };
+            stack.push((new_from, (ny, nx), new_len));
+        }
+    }
+
+    (nodes, mapper[&end])
+}
+
+fn longest_path(
+    nodes: &[Node],
+    mut visited: usize,
+    location: usize,
+    target: usize,
+    length: usize,
+) -> Option<usize> {
+    if location == target {
+        return Some(length);
+    }
+
+    // binary mask for visited since < 64 nodes in input
+    // nth bit tells if location n was visited already
+    visited |= 1 << location;
+
+    let mut max_len = 0;
+
+    for (n, l) in nodes[location]
+        .neighbours
+        .iter()
+        .copied()
+        .filter(|(n, _)| (visited & 1 << n) == 0)
+    {
+        if let Some(new_len) = longest_path(nodes, visited, n, target, length + l) {
+            if max_len < new_len {
+                max_len = new_len;
+            }
+        }
+    }
+
+    if max_len > 0 {
+        Some(max_len)
+    } else {
+        None
+    }
+}
+
+pub fn part_one(input: &str) -> Option<usize> {
+    let (nodes, target) = build_graph(input, false);
+    longest_path(&nodes, 0, 0, target, 0)
+}
+
+pub fn part_two(input: &str) -> Option<usize> {
+    let (nodes, target) = build_graph(input, true);
+    longest_path(&nodes, 0, 0, target, 0)
+}
+
+aoc::solution!(23);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_part_one() {
+        assert_eq!(
+            part_one(&aoc::template::read_file("examples", 23)),
+            Some(94)
+        );
+    }
+    #[test]
+    fn test_part_two() {
+        assert_eq!(
+            part_two(&aoc::template::read_file("examples", 23)),
+            Some(154)
+        );
+    }
+}