Actually test part two, why not

2022/inputs/10.txt

@@ -0,0 +1,140 @@
+noop
+addx 5
+noop
+noop
+noop
+addx 1
+addx 2
+addx 5
+addx 2
+addx 5
+noop
+noop
+noop
+noop
+noop
+addx -12
+addx 18
+addx -1
+noop
+addx 3
+addx 5
+addx -5
+addx 7
+noop
+addx -36
+addx 18
+addx -16
+noop
+noop
+noop
+addx 5
+addx 2
+addx 5
+addx 2
+addx 13
+addx -6
+addx -4
+addx 5
+addx 2
+addx 4
+addx -3
+addx 2
+noop
+addx 3
+addx 2
+addx 5
+addx -40
+addx 25
+addx -22
+addx 25
+addx -21
+addx 5
+addx 3
+noop
+addx 2
+addx 19
+addx -10
+addx -4
+noop
+addx -4
+addx 7
+noop
+addx 3
+addx 2
+addx 5
+addx 2
+addx -26
+addx 27
+addx -36
+noop
+noop
+noop
+noop
+addx 4
+addx 6
+noop
+addx 12
+addx -11
+addx 2
+noop
+noop
+noop
+addx 5
+addx 5
+addx 2
+noop
+noop
+addx 1
+addx 2
+addx 5
+addx 2
+addx 1
+noop
+noop
+addx -38
+noop
+addx 9
+addx -4
+noop
+noop
+addx 7
+addx 10
+addx -9
+addx 2
+noop
+addx -9
+addx 14
+addx 5
+addx 2
+addx -24
+addx 25
+addx 2
+addx 5
+addx 2
+addx -30
+addx 31
+addx -38
+addx 7
+noop
+noop
+noop
+addx 1
+addx 21
+addx -16
+addx 8
+addx -4
+addx 2
+addx 3
+noop
+noop
+addx 5
+addx -2
+addx 5
+addx 3
+addx -1
+addx -1
+addx 4
+addx 5
+addx -38
+noop

2022/src/day10.rs

@@ -1,9 +1,130 @@
 use anyhow::Result;
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::character::complete::newline;
+use nom::combinator::iterator;
+use nom::combinator::map;
+use nom::sequence::preceded;
+use nom::sequence::terminated;
+use nom::IResult;
 
-pub fn part1(_input: &[u8]) -> Result<String> {
-    anyhow::bail!("not implemented")
+#[derive(Copy, Clone)]
+enum Instruction {
+    AddX(i32),
+    Noop,
 }
 
-pub fn part2(_input: &[u8]) -> Result<String> {
-    anyhow::bail!("not implemented")
+impl Instruction {
+    #[inline]
+    pub fn cycles(self) -> i32 {
+        match self {
+            Instruction::AddX(_) => 2,
+            Instruction::Noop => 1,
+        }
+    }
+
+    #[inline]
+    pub fn execute(self, x: &mut i32, cycle: &mut i32) {
+        *cycle += self.cycles();
+
+        if let Instruction::AddX(v) = self {
+            *x += v;
+        }
+    }
+}
+
+fn parse_instruction(input: &[u8]) -> IResult<&[u8], Instruction> {
+    terminated(
+        alt((
+            map(tag("noop"), |_| Instruction::Noop),
+            map(preceded(tag("addx "), nom::character::complete::i32), |v| {
+                Instruction::AddX(v)
+            }),
+        )),
+        newline,
+    )(input)
+}
+
+pub fn part1(input: &[u8]) -> Result<String> {
+    let mut x = 1;
+    // Count from one like a scrub
+    let mut cycle = 1;
+
+    let mut input_it = iterator(input, parse_instruction);
+
+    let mut total = 0;
+
+    for instruction in &mut input_it {
+        let old_cycle = cycle;
+        let old_x = x;
+
+        instruction.execute(&mut x, &mut cycle);
+
+        if old_cycle % 40 < 20 && cycle % 40 >= 20 {
+            let to_report = if cycle % 40 == 20 { x } else { old_x };
+
+            let checkpoint = cycle / 20 * 20;
+            total += to_report * checkpoint;
+        }
+
+        if cycle >= 220 {
+            return Ok(total.to_string());
+        }
+    }
+
+    anyhow::bail!("out of instructions")
+}
+
+pub fn part2(input: &[u8]) -> Result<String> {
+    let mut x = 1;
+    let mut input_it = iterator(input, parse_instruction);
+    let mut input_it = (&mut input_it).peekable();
+
+    let mut output = String::with_capacity(6 * (40 + 1));
+
+    let mut cpu_cycle = 0;
+
+    for crt_cycle in 1..=240 {
+        if let Some(instruction) = input_it.next_if(|i| cpu_cycle + i.cycles() < crt_cycle) {
+            instruction.execute(&mut x, &mut cpu_cycle);
+        }
+
+        let beam_pos = (crt_cycle + 39) % 40;
+
+        if (beam_pos - x).abs() <= 1 {
+            output.push('#');
+        } else {
+            output.push(' ');
+        }
+
+        if crt_cycle % 40 == 0 {
+            output.push('\n');
+        }
+    }
+
+    Ok(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SAMPLE: &[u8] = include_bytes!("samples/10.txt");
+
+    #[test]
+    fn sample_part1() {
+        assert_eq!(part1(SAMPLE).unwrap(), "13140");
+    }
+
+    #[test]
+    fn sample_part2() {
+        let answer = "##  ##  ##  ##  ##  ##  ##  ##  ##  ##  
+###   ###   ###   ###   ###   ###   ### 
+####    ####    ####    ####    ####    
+#####     #####     #####     #####     
+######      ######      ######      ####
+#######       #######       #######     \n";
+
+        assert_eq!(part2(SAMPLE).unwrap(), answer);
+    }
 }

2022/src/samples/10.txt

@@ -0,0 +1,146 @@
+addx 15
+addx -11
+addx 6
+addx -3
+addx 5
+addx -1
+addx -8
+addx 13
+addx 4
+noop
+addx -1
+addx 5
+addx -1
+addx 5
+addx -1
+addx 5
+addx -1
+addx 5
+addx -1
+addx -35
+addx 1
+addx 24
+addx -19
+addx 1
+addx 16
+addx -11
+noop
+noop
+addx 21
+addx -15
+noop
+noop
+addx -3
+addx 9
+addx 1
+addx -3
+addx 8
+addx 1
+addx 5
+noop
+noop
+noop
+noop
+noop
+addx -36
+noop
+addx 1
+addx 7
+noop
+noop
+noop
+addx 2
+addx 6
+noop
+noop
+noop
+noop
+noop
+addx 1
+noop
+noop
+addx 7
+addx 1
+noop
+addx -13
+addx 13
+addx 7
+noop
+addx 1
+addx -33
+noop
+noop
+noop
+addx 2
+noop
+noop
+noop
+addx 8
+noop
+addx -1
+addx 2
+addx 1
+noop
+addx 17
+addx -9
+addx 1
+addx 1
+addx -3
+addx 11
+noop
+noop
+addx 1
+noop
+addx 1
+noop
+noop
+addx -13
+addx -19
+addx 1
+addx 3
+addx 26
+addx -30
+addx 12
+addx -1
+addx 3
+addx 1
+noop
+noop
+noop
+addx -9
+addx 18
+addx 1
+addx 2
+noop
+noop
+addx 9
+noop
+noop
+noop
+addx -1
+addx 2
+addx -37
+addx 1
+addx 3
+noop
+addx 15
+addx -21
+addx 22
+addx -6
+addx 1
+noop
+addx 2
+addx 1
+noop
+addx -10
+noop
+noop
+addx 20
+addx 1
+addx 2
+addx 2
+addx -6
+addx -11
+noop
+noop
+noop