Day 17

Author: prevostc

README.md

@@ -19,16 +19,17 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 6](./src/bin/06.rs) | `48.5µs` | `4.2ms` |
 | [Day 7](./src/bin/07.rs) | `316.2µs` | `319.6µs` |
 | [Day 8](./src/bin/08.rs) | `7.4µs` | `15.5µs` |
-| [Day 9](./src/bin/09.rs) | `152.3µs` | `141.1µs` |
+| [Day 9](./src/bin/09.rs) | `154.1µs` | `147.3µs` |
 | [Day 10](./src/bin/10.rs) | `31.1µs` | `28.6µs` |
 | [Day 11](./src/bin/11.rs) | `71.0µs` | `766.0µs` |
 | [Day 12](./src/bin/12.rs) | `434.7µs` | `674.6µs` |
 | [Day 13](./src/bin/13.rs) | `90.9µs` | `91.8µs` |
 | [Day 14](./src/bin/14.rs) | `30.8µs` | `3.5ms` |
 | [Day 15](./src/bin/15.rs) | `119.7µs` | `591.0µs` |
 | [Day 16](./src/bin/16.rs) | `158.9µs` | `202.6µs` |
+| [Day 17](./src/bin/17.rs) | `1.7µs` | `361.3µs` |
 
-**Total: 13.08ms**
+**Total: 13.45ms**
 <!--- benchmarking table --->
 
 ---

data/examples/17-1.txt

@@ -0,0 +1,5 @@
+Register A: 729
+Register B: 0
+Register C: 0
+
+Program: 0,1,5,4,3,0

data/examples/17-2.txt

@@ -0,0 +1,5 @@
+Register A: 2024
+Register B: 0
+Register C: 0
+
+Program: 0,3,5,4,3,0

src/bin/17.rs

@@ -0,0 +1,266 @@
+advent_of_code::solution!(17);
+
+#[derive(Debug, Clone)]
+struct Machine {
+    reg_a: u64,
+    reg_b: u64,
+    reg_c: u64,
+
+    ip: usize, // idx into tape
+    tape: Vec<u64>,
+    output: Vec<u64>,
+}
+
+impl Machine {
+    fn parse(input: &str) -> Self {
+        let lines = input.lines().collect::<Vec<_>>();
+
+        Self {
+            reg_a: lines[0].split_whitespace().nth(2).unwrap().parse().unwrap(),
+            reg_b: lines[1].split_whitespace().nth(2).unwrap().parse().unwrap(),
+            reg_c: lines[2].split_whitespace().nth(2).unwrap().parse().unwrap(),
+            ip: 0,
+            tape: lines[4]
+                .split_whitespace()
+                .nth(1)
+                .unwrap()
+                .split(',')
+                .map(|s| s.parse().unwrap())
+                .collect(),
+            output: vec![],
+        }
+    }
+
+    #[inline]
+    fn combo(&self, op: u64) -> u64 {
+        match op {
+            0..=3 => op,
+            4 => self.reg_a,
+            5 => self.reg_b,
+            6 => self.reg_c,
+            _ => unreachable!(),
+        }
+    }
+
+    #[inline]
+    fn literal(&self, op: u64) -> u64 {
+        return op;
+    }
+
+    #[inline]
+    fn _div(&self, op: u64) -> u64 {
+        let l = self.reg_a;
+        let r = 2_u64.pow(self.combo(op) as u32);
+        l.div_euclid(r)
+    }
+
+    #[inline]
+    fn adv(&mut self, op: u64) {
+        self.reg_a = self._div(op);
+    }
+
+    #[inline]
+    fn bdv(&mut self, op: u64) {
+        self.reg_b = self._div(op);
+    }
+
+    #[inline]
+    fn cdv(&mut self, op: u64) {
+        self.reg_c = self._div(op);
+    }
+
+    #[inline]
+    fn bxl(&mut self, op: u64) {
+        self.reg_b = self.reg_b ^ self.literal(op);
+    }
+
+    #[inline]
+    fn bst(&mut self, op: u64) {
+        self.reg_b = self.combo(op) % 8;
+    }
+
+    #[inline]
+    fn jnz(&mut self, op: u64) {
+        if self.reg_a != 0 {
+            self.ip = self.literal(op) as usize;
+        }
+    }
+
+    #[inline]
+    fn bxc(&mut self, _op: u64) {
+        self.reg_b = self.reg_b ^ self.reg_c;
+    }
+
+    #[inline]
+    fn out(&mut self, op: u64) {
+        let v = self.combo(op) % 8;
+        self.output.push(v);
+    }
+
+    pub fn step(&mut self) -> bool {
+        if self.ip + 1 >= self.tape.len() {
+            return false;
+        }
+
+        let (inst, op) = (self.tape[self.ip], self.tape[self.ip + 1]);
+        self.ip += 2;
+
+        match inst {
+            0 => self.adv(op),
+            1 => self.bxl(op),
+            2 => self.bst(op),
+            3 => self.jnz(op),
+            4 => self.bxc(op),
+            5 => self.out(op),
+            6 => self.bdv(op),
+            7 => self.cdv(op),
+            _ => unreachable!(),
+        }
+
+        return true;
+    }
+}
+
+pub fn part_one(input: &str) -> Option<String> {
+    let mut machine = Machine::parse(input);
+
+    while machine.step() {}
+
+    Some(
+        machine
+            .output
+            .iter()
+            .map(|c| c.to_string())
+            .collect::<Vec<_>>()
+            .join(","),
+    )
+}
+
+pub fn part_two(input: &str) -> Option<u64> {
+    let machine = Machine::parse(input);
+    let len = machine.tape.len();
+
+    let mut reg_a = 0;
+    for take_len in 1..=len {
+        let mut new_a = reg_a << 3;
+        loop {
+            let mut m = machine.clone();
+            m.reg_a = new_a;
+
+            while m.step() {}
+
+            if m.output.eq(&machine.tape[len - take_len..]) {
+                reg_a = new_a;
+                break;
+            }
+
+            new_a += 1;
+        }
+    }
+
+    Some(reg_a)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // #[test]
+    // fn test_ex_1() {
+    //     let mut machine = Machine {
+    //         reg_a: 0,
+    //         reg_b: 0,
+    //         reg_c: 9,
+    //         ip: 0,
+    //         tape: vec![2, 6],
+    //         output: vec![],
+    //     };
+    //     machine.step();
+    //     assert_eq!(machine.reg_b, 1);
+    // }
+
+    // #[test]
+    // fn test_ex_2() {
+    //     let mut machine = Machine {
+    //         reg_a: 10,
+    //         reg_b: 0,
+    //         reg_c: 0,
+    //         ip: 0,
+    //         tape: vec![5, 0, 5, 1, 5, 4],
+    //         output: vec![],
+    //     };
+    //     while machine.step() {}
+    //     assert_eq!(machine.output, vec![0, 1, 2]);
+    // }
+
+    // #[test]
+    // fn test_ex_3() {
+    //     let mut machine = Machine {
+    //         reg_a: 2024,
+    //         reg_b: 0,
+    //         reg_c: 0,
+    //         ip: 0,
+    //         tape: vec![0, 1, 5, 4, 3, 0],
+    //         output: vec![],
+    //     };
+    //     while machine.step() {}
+    //     assert_eq!(machine.output, vec![4, 2, 5, 6, 7, 7, 7, 7, 3, 1, 0]);
+    //     assert_eq!(machine.reg_a, 0);
+    // }
+
+    // #[test]
+    // fn test_ex_4() {
+    //     let mut machine = Machine {
+    //         reg_a: 0,
+    //         reg_b: 29,
+    //         reg_c: 0,
+    //         ip: 0,
+    //         tape: vec![1, 7],
+    //         output: vec![],
+    //     };
+    //     machine.step();
+    //     assert_eq!(machine.reg_b, 26);
+    // }
+
+    // #[test]
+    // fn test_ex_5() {
+    //     let mut machine = Machine {
+    //         reg_a: 0,
+    //         reg_b: 2024,
+    //         reg_c: 43690,
+    //         ip: 0,
+    //         tape: vec![4, 0],
+    //         output: vec![],
+    //     };
+    //     machine.step();
+    //     assert_eq!(machine.reg_b, 44354);
+    // }
+
+    // #[test]
+    // fn test_ex_6() {
+    //     let mut machine = Machine {
+    //         reg_a: 117440,
+    //         reg_b: 0,
+    //         reg_c: 0,
+    //         ip: 0,
+    //         tape: vec![0, 3, 5, 4, 3, 0],
+    //         output: vec![],
+    //     };
+    //     while machine.step() {}
+    //     assert_eq!(machine.output, vec![0, 3, 5, 4, 3, 0]);
+    // }
+
+    // #[test]
+    // fn test_part_one() {
+    //     let result = part_one(&advent_of_code::template::read_file_part("examples", DAY, 1));
+    //     assert_eq!(result, Some("4,6,3,5,6,3,5,2,1,0".to_string()));
+    // }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file_part(
+            "examples", DAY, 2,
+        ));
+        assert_eq!(result, Some(117440));
+    }
+}