Implement 2023 day 8 part 2

2023/Cargo.toml

@@ -10,6 +10,7 @@ aho-corasick = "1.1.2"
 anyhow = "1.0.75"
 clap = { version = "4.4.8", features = ["derive"] }
 nom = "7.1.3"
+num-integer = "0.1.45"
 
 [dev-dependencies]
 criterion = "0.5.1"

2023/benches/days.rs

@@ -9,7 +9,7 @@ use criterion::Criterion;
 use aoc_2023::get_implementation;
 
 /// Number of days we have an implementation to benchmark
-const DAYS_IMPLEMENTED: u8 = 7;
+const DAYS_IMPLEMENTED: u8 = 25;
 
 fn read_input(day: u8) -> std::io::Result<Vec<u8>> {
     let input_path = format!("inputs/{day:02}.txt");

2023/src/day08.rs

@@ -1,7 +1,151 @@
-pub fn part1(_input: &[u8]) -> anyhow::Result<String> {
+use anyhow::Context;
-    anyhow::bail!("Not implemented")
+use nom::bytes::complete::tag;
+use nom::bytes::complete::take;
+use nom::bytes::complete::take_until;
+use nom::combinator::map;
+use nom::multi::fold_many1;
+use nom::sequence::preceded;
+use nom::sequence::separated_pair;
+use nom::sequence::terminated;
+use nom::sequence::tuple;
+use nom::IResult;
+use num_integer::Integer;
+
+use crate::common::parse_input;
+
+const NUM_PLACES: usize = 26 * 26 * 26;
+
+struct Map<'a> {
+    instructions: &'a [u8],
+    transitions: Box<[(u16, u16); NUM_PLACES]>,
 }
 
-pub fn part2(_input: &[u8]) -> anyhow::Result<String> {
+impl<'a> Map<'a> {
-    anyhow::bail!("Not implemented")
+    #[inline]
+    fn transition(&self, pos: u16, step: u8) -> u16 {
+        if step == b'L' {
+            self.transitions[pos as usize].0
+        } else {
+            self.transitions[pos as usize].1
+        }
+    }
+}
+
+fn place_to_index(place: &[u8]) -> u16 {
+    place
+        .iter()
+        .fold(0u16, |index, &c| index * 26 + u16::from(c - b'A'))
+}
+
+fn parse_map(i: &[u8]) -> IResult<&[u8], Map<'_>> {
+    map(
+        separated_pair(
+            take_until("\n"),
+            tag("\n\n"),
+            fold_many1(
+                tuple((
+                    terminated(take(3usize), tag(" = (")),
+                    terminated(take(3usize), tag(", ")),
+                    terminated(take(3usize), tag(")\n")),
+                )),
+                || Box::new([(0, 0); NUM_PLACES]),
+                |mut transitions, (pos, left, right)| {
+                    let pos = place_to_index(pos);
+                    let left = place_to_index(left);
+                    let right = place_to_index(right);
+                    transitions[pos as usize] = (left, right);
+                    transitions
+                },
+            ),
+        ),
+        |(instructions, transitions)| Map {
+            instructions,
+            transitions,
+        },
+    )(i)
+}
+
+fn parse_starts(i: &[u8]) -> IResult<&[u8], Vec<u16>> {
+    preceded(
+        tuple((take_until("\n"), tag("\n\n"))),
+        fold_many1(
+            terminated(
+                map(take(3usize), place_to_index),
+                tuple((take_until("\n"), tag("\n"))),
+            ),
+            Vec::new,
+            |mut starts, place| {
+                if place % 26 == 0 {
+                    starts.push(place)
+                }
+                starts
+            },
+        ),
+    )(i)
+}
+
+pub fn part1(input: &[u8]) -> anyhow::Result<String> {
+    let map = parse_input(input, parse_map)?;
+    let end = place_to_index(b"ZZZ");
+    let mut pos = 0;
+
+    for (count, &step) in map.instructions.iter().cycle().enumerate() {
+        if pos == end {
+            return Ok(count.to_string());
+        }
+
+        pos = map.transition(pos, step);
+    }
+
+    anyhow::bail!("Unreachable, loop is infinite");
+}
+
+// This code is wrong. There is no reason that the start of the cycle is indeed the equal to the
+// length of the cycle. But it happens to be the case, so we roll with it. Otherwise you could go
+// with the full Chinese remainder theorem and knock yourself out that way.
+//
+// I didn't wanna.
+fn find_cycle(map: &Map<'_>, start: u16) -> usize {
+    let mut pos = start;
+    for (count, &step) in map.instructions.iter().cycle().enumerate() {
+        if pos % 26 == 25 {
+            return count;
+        }
+        pos = map.transition(pos, step);
+    }
+
+    unreachable!("Loop is actually infinite")
+}
+
+pub fn part2(input: &[u8]) -> anyhow::Result<String> {
+    let map = parse_input(input, parse_map)?;
+    let pos = parse_input(input, parse_starts)?;
+
+    pos.iter()
+        .map(|&p| find_cycle(&map, p))
+        .reduce(|a, b| a.lcm(&b))
+        .map(|s| s.to_string())
+        .context("No starting points somehow")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SAMPLE: &[u8] = include_bytes!("samples/08.1.txt");
+    const SAMPLE2: &[u8] = include_bytes!("samples/08.2.txt");
+    // N.B. sample modified because I don't want to change my parser logic to deal with ascii digits
+    // in addition to capitals. 1 has been replaced with D, 2 has been replaced with E.
+    const SAMPLE3: &[u8] = include_bytes!("samples/08.3.txt");
+
+    #[test]
+    fn sample_part1() {
+        assert_eq!("2", part1(SAMPLE).unwrap());
+        assert_eq!("6", part1(SAMPLE2).unwrap());
+    }
+
+    #[test]
+    fn sample_part2() {
+        assert_eq!("6", part2(SAMPLE3).unwrap());
+    }
 }

2023/src/samples/08.1.txt

@@ -0,0 +1,9 @@
+RL
+
+AAA = (BBB, CCC)
+BBB = (DDD, EEE)
+CCC = (ZZZ, GGG)
+DDD = (DDD, DDD)
+EEE = (EEE, EEE)
+GGG = (GGG, GGG)
+ZZZ = (ZZZ, ZZZ)

2023/src/samples/08.2.txt

@@ -0,0 +1,5 @@
+LLR
+
+AAA = (BBB, BBB)
+BBB = (AAA, ZZZ)
+ZZZ = (ZZZ, ZZZ)

2023/src/samples/08.3.txt

@@ -0,0 +1,10 @@
+LR
+
+DDA = (DDB, XXX)
+DDB = (XXX, DDZ)
+DDZ = (DDB, XXX)
+EEA = (EEB, XXX)
+EEB = (EEC, EEC)
+EEC = (EEZ, EEZ)
+EEZ = (EEB, EEB)
+XXX = (XXX, XXX)