feat: completed day 8

ankjevel · ankjevel · commit abbe6575d61a · 2020-12-08T12:49:35.000+01:00
diff --git a/README.md b/README.md
@@ -9,8 +9,8 @@
 - [Day 4](https://github.com/ankjevel/adventofcode/tree/2020/day_04) 🌟 🌟
 - [Day 5](https://github.com/ankjevel/adventofcode/tree/2020/day_05) 🌟 🌟
 - [Day 6](https://github.com/ankjevel/adventofcode/tree/2020/day_06) 🌟 🌟
-- [Day 7](#)
-- [Day 8](#)
+- [Day 7](https://github.com/ankjevel/adventofcode/tree/2020/day_07) 🌟 🌟
+- [Day 8](https://github.com/ankjevel/adventofcode/tree/2020/day_08) 🌟 🌟
 - [Day 9](#)
 - [Day 10](#)
 - [Day 11](#)
diff --git a/day_08/src/part_01.rs b/day_08/src/part_01.rs
@@ -36,20 +36,16 @@ impl Program {
             if *visited {
                 break;
             }
+
             let argument = &instruction.argument;
-            let next = next(
-                self.index,
-                if instruction.operation == JMP {
-                    argument
-                } else {
-                    &1
-                },
-            );
-            if instruction.operation == ACC {
+            let operation = instruction.operation;
+
+            if operation == ACC {
                 self.accumulator += argument
             }
+
             *visited = true;
-            self.index = next;
+            self.index = next(self.index, if operation == JMP { argument } else { &1 });
         }
 
         self.accumulator
diff --git a/day_08/src/part_02.rs b/day_08/src/part_02.rs
@@ -1,9 +1,112 @@
 use std::io::Result;
 
-use crate::Input;
+use crate::{instruction::Instruction, instruction::Operation::*, Input};
 
-pub fn main(_input: &Input) -> Result<()> {
-    Ok(())
+#[derive(Default, Debug, Eq, PartialEq, Clone)]
+struct Program {
+    instructions: Vec<(bool, Instruction)>,
+    original: Vec<Instruction>,
+    accumulator: i64,
+    index: usize,
+    change: usize,
+}
+
+impl Program {
+    fn new(input: &Input) -> Self {
+        Self {
+            original: input.to_owned(),
+            ..Program::default()
+        }
+    }
+
+    fn fix(&mut self) {
+        let mut to_change = self.change.to_owned();
+        let len = self.original.len();
+
+        self.accumulator = 0;
+        self.index = 0;
+
+        self.instructions = self
+            .original
+            .iter()
+            .enumerate()
+            .map(|(index, instruction)| {
+                if to_change != index {
+                    return (false, instruction.to_owned());
+                }
+
+                let operation = instruction.operation;
+                let argument = instruction.argument;
+
+                match operation {
+                    ACC => {
+                        to_change += 1;
+                        (false, instruction.to_owned())
+                    }
+                    NOP => (
+                        false,
+                        Instruction {
+                            operation: JMP,
+                            argument,
+                        },
+                    ),
+                    JMP => (
+                        false,
+                        Instruction {
+                            operation: NOP,
+                            argument,
+                        },
+                    ),
+                }
+            })
+            .collect::<Vec<_>>();
+
+        self.change = to_change + 1 % len;
+    }
+
+    fn run(mut self) -> i64 {
+        let len = self.original.len() as i64;
+        let next = |curr: usize, next: &i64| -> usize {
+            let next_index = curr as i64 + next;
+            (if next_index > len {
+                len - next_index
+            } else {
+                next_index
+            } % len) as usize
+        };
+
+        'main: loop {
+            self.fix();
+
+            'test: loop {
+                let (visited, instruction) = self.instructions.get_mut(self.index).unwrap();
+                if *visited {
+                    break 'test;
+                }
+
+                let argument = &instruction.argument;
+                let operation = instruction.operation;
+                let next = next(self.index, if operation == JMP { argument } else { &1 });
+
+                if operation == ACC {
+                    self.accumulator += argument;
+                }
+
+                if self.index != 0 && next == 0 {
+                    break 'main;
+                }
+
+                *visited = true;
+                self.index = next;
+            }
+        }
+
+        self.accumulator
+    }
+}
+
+pub fn main(input: &Input) -> Result<i64> {
+    Ok(Program::new(input).run())
 }
 
 #[cfg(test)]
@@ -26,7 +129,7 @@ mod tests {
 
     #[test]
     fn it_gets_the_example_correct() -> Result<()> {
-        assert_eq!(main(&parse_input(&EXAMPLE_DATA))?, ());
+        assert_eq!(main(&parse_input(&EXAMPLE_DATA))?, 8);
         Ok(())
     }
 }
