feat: added part 2 or day 7... so hacky

ankjevel · ankjevel · commit 352b4ec78f3d · 2020-12-05T12:06:17.000+01:00
diff --git a/day_05/src/bin/main.rs b/day_05/src/bin/main.rs
@@ -1,74 +1,17 @@
-use ::day_05::{parse_input, program::Program};
+use ::day_05::{parse_input, program::exec_without_channels};
 use std::io::Result;
 
-#[allow(dead_code)]
 fn main() -> Result<()> {
     let input = parse_input(include_str!("../../../input/day_05"));
-    let mut program = Program::new(&input[0]);
 
-    program.new_input(&vec![1]);
-    program.run();
-    println!("part_01: {:?}", program.output);
-
-    program.new_input(&vec![5]);
-    program.run();
-    println!("part_02: {:?}", program.output);
+    println!(
+        "part_01: {:?}",
+        exec_without_channels(input[0].clone(), None)
+    );
+    println!(
+        "part_02: {:?}",
+        exec_without_channels(input[0].clone(), Some(vec![5]))
+    );
 
     Ok(())
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const EXAMPLE_DATA_FROM_DAY_02: &'static str = "
-        1,0,0,0,99
-        2,3,0,3,99
-        2,4,4,5,99,0
-        1,1,1,4,99,5,6,0,99
-    ";
-
-    const EXAMPLE_DATA_01: &'static str = "
-        1101,100,-1,4,0
-        1002,4,3,4,33
-    ";
-
-    #[test]
-    fn it_still_works_with_example_data_from_day_02() {
-        let input = parse_input(EXAMPLE_DATA_FROM_DAY_02);
-
-        let results = input
-            .iter()
-            .map(|row| {
-                let mut program = Program::new(&row);
-                program.run();
-
-                program.memory
-            })
-            .collect::<Vec<Vec<i32>>>();
-
-        assert_eq!(results[0], [2, 0, 0, 0, 99]);
-        assert_eq!(results[1], [2, 3, 0, 6, 99]);
-        assert_eq!(results[2], [2, 4, 4, 5, 99, 9801]);
-        assert_eq!(results[3], [30, 1, 1, 4, 2, 5, 6, 0, 99]);
-    }
-
-    #[test]
-    fn examples_for_part_1() {
-        let input = parse_input(EXAMPLE_DATA_01);
-
-        let results = input
-            .iter()
-            .map(|row| {
-                let mut program = Program::new(&row);
-                program.run();
-                program
-            })
-            .collect::<Vec<Program>>();
-
-        assert_eq!(results[0].memory, [1101, 100, -1, 4, 99]);
-        assert_eq!(results[1].memory, [1002, 4, 3, 4, 99]);
-        assert_eq!(results[0].output, []);
-        assert_eq!(results[1].output, []);
-    }
-}
diff --git a/day_05/src/program.rs b/day_05/src/program.rs
@@ -1,33 +1,41 @@
-use std::iter::Iterator;
-use std::option::Option;
-// use std::collections::VecDeque;
+use std::{
+    iter::Iterator,
+    option::Option,
+    sync::mpsc::{channel, Receiver, Sender},
+    thread::{spawn, JoinHandle},
+};
 
 pub struct Program {
     original_memory: Vec<i32>,
     pointer: usize,
-    input_pointer: usize,
-    input: Vec<i32>,
+    input: Receiver<i32>,
     halted: bool,
+    output: Sender<i32>,
+    output_value: i32,
     pub memory: Vec<i32>,
-    pub output: Vec<i32>,
 }
 
 impl Program {
     pub fn new(memory: &Vec<i32>) -> Program {
+        let (output, input) = channel();
+
         Program {
             original_memory: memory.clone(),
             pointer: 0,
-            input: vec![0],
-            input_pointer: 0,
+            output_value: 0,
+            input,
             halted: false,
             memory: memory.clone(),
-            output: Vec::new(),
+            output,
         }
     }
 
-    pub fn new_input(&mut self, input: &Vec<i32>) {
-        self.input_pointer = 0;
-        self.input = input.clone();
+    pub fn new_input(&mut self, input: Receiver<i32>) {
+        self.input = input;
+    }
+
+    pub fn new_output(&mut self, output: Sender<i32>) {
+        self.output = output;
     }
 
     pub fn is_halted(&self) -> bool {
@@ -60,12 +68,12 @@ impl Program {
     fn mode_3_4(&mut self, opcode: i32) -> usize {
         let index = self.get_index(1, true);
         if opcode == 3 {
-            let input = self.input.get(self.input_pointer).unwrap_or(&0);
-            self.input_pointer += 1;
-            self.memory[index] = *input;
+            let input = self.input.recv().unwrap_or(0);
+            self.memory[index] = input.to_owned();
         } else {
             let output = self.memory[index].clone();
-            self.output.push(output);
+            self.output.send(output.to_owned()).unwrap_or(());
+            self.output_value = output.to_owned();
         };
 
         2
@@ -120,15 +128,15 @@ impl Program {
 
     pub fn run(&mut self) -> i32 {
         self.pointer = 0;
-        self.output = Vec::new();
-        self.memory = self.original_memory.clone();
+        self.output_value = 0;
         self.halted = false;
+        self.memory = self.original_memory.clone();
 
         while !self.halted {
             self.eval()
         }
 
-        *self.output.last().unwrap_or(&0i32)
+        self.output_value.to_owned()
     }
 
     fn eval(&mut self) {
@@ -151,7 +159,42 @@ impl Program {
             3 | 4 => self.mode_3_4(opcode),
             5 | 6 => self.mode_5_6(opcode, positional_first, positional_second),
             7 | 8 => self.mode_7_8(opcode, positional_first, positional_second),
-            _ => panic!("opcode: {}", opcode),
+            9 => {
+                self.halted = true;
+                0
+            }
+            _ => panic!("[{}], opcode: {}", self.pointer, opcode),
         };
     }
 }
+
+pub fn exec(memory: Vec<i32>, input: Receiver<i32>, output: Sender<i32>) -> JoinHandle<i32> {
+    spawn(move || {
+        let mut program = Program::new(&memory);
+        program.new_input(input);
+        program.new_output(output);
+        program.run()
+    })
+}
+
+pub fn exec_without_channels(memory: Vec<i32>, input: Option<Vec<i32>>) -> i32 {
+    let (c_out, c_in) = channel();
+    match input {
+        Some(input) => {
+            for seq in input.clone() {
+                c_out.send(seq).unwrap();
+            }
+        }
+        None => {
+            c_out.send(0).unwrap();
+        }
+    };
+    spawn(move || {
+        let mut program = Program::new(&memory);
+        program.new_input(c_in);
+        program.new_output(c_out);
+        program.run()
+    })
+    .join()
+    .unwrap()
+}
diff --git a/day_07/src/main.rs b/day_07/src/main.rs
@@ -1,34 +1,65 @@
 extern crate day_05;
 extern crate permute;
 
-use day_05::{parse_input, program::Program};
+use day_05::{
+    parse_input,
+    program::{exec, exec_without_channels},
+};
 use permute::permute;
+use std::{iter::Iterator, sync::mpsc::channel};
 
 fn part_01(sequence: &Vec<i32>, memory: &Vec<i32>) -> i32 {
-    let mut program = Program::new(&memory);
     let mut input = vec![0];
     for signal in sequence {
         input.insert(0, signal.to_owned());
-        program.new_input(&input);
-        input.insert(0, program.run());
+        input.insert(
+            0,
+            exec_without_channels(memory.clone(), Some(input.clone())),
+        )
     }
     input[0]
 }
 
+fn part_02(sequence: &Vec<i32>, memory: &Vec<i32>) -> i32 {
+    let mut seq = sequence.to_owned();
+    let mut iter = seq.iter_mut();
+
+    let (e_out, a_in) = channel();
+    let (a_out, b_in) = channel();
+    let (b_out, c_in) = channel();
+    let (c_out, d_in) = channel();
+    let (d_out, e_in) = channel();
+
+    e_out.send(*iter.next().unwrap()).unwrap();
+    a_out.send(*iter.next().unwrap()).unwrap();
+    b_out.send(*iter.next().unwrap()).unwrap();
+    c_out.send(*iter.next().unwrap()).unwrap();
+    d_out.send(*iter.next().unwrap()).unwrap();
+    e_out.send(0).unwrap();
+
+    exec(memory.clone(), a_in, a_out);
+    exec(memory.clone(), b_in, b_out);
+    exec(memory.clone(), c_in, c_out);
+    exec(memory.clone(), d_in, d_out);
+    exec(memory.clone(), e_in, e_out).join().unwrap()
+}
+
 fn main() {
     let input = parse_input(include_str!("../../input/day_07"));
     let answer_part_01 = permute((0..=4).collect())
         .into_iter()
         .map(|sequence| part_01(&sequence, &input[0]))
         .max()
-        .unwrap();
+        .unwrap_or(0);
 
-    permute((5..=9).collect())
+    let answer_part_02 = permute((5..=9).collect())
         .into_iter()
-        .for_each(|_sequence| {});
+        .map(|sequence| part_02(&sequence, &input[0]))
+        .max()
+        .unwrap_or(0);
 
-    // println!("part_02: {:?}", answer_part_02);
     println!("part_01: {:?}", answer_part_01);
+    println!("part_02: {:?}", answer_part_02);
 }
 
 #[cfg(test)]
@@ -41,11 +72,6 @@ mod tests {
         3,31,3,32,1002,32,10,32,1001,31,-2,31,1007,31,0,33,1002,33,7,33,1,33,31,31,1,32,31,31,4,31,99,0,0,0
     ";
 
-    const EXAMPLES_FOR_PART_02: &'static str = "
-        3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5
-        3,31,3,32,1002,32,10,32,1001,31,-2,31,1007,31,0,33,1002,33,7,33,1,33,31,31,1,32,31,31,4,31,99,0,0,0
-    ";
-
     #[test]
     fn it_gets_the_examples_right_on_part_01() {
         let input = parse_input(&EXAMPLES_FOR_PART_01);
