chore: had to update example on day 9 to handle channels

ankjevel · ankjevel · commit fa3c9a53eae8 · 2020-12-05T12:06:18.000+01:00
diff --git a/day_09/src/lib.rs b/day_09/src/lib.rs
@@ -0,0 +1,3 @@
+extern crate day_05;
+
+pub mod program;
diff --git a/day_09/src/main.rs b/day_09/src/main.rs
@@ -1,43 +1,64 @@
-extern crate day_05;
-
-mod program;
-
+use ::day_09::program::exec;
 use day_05::parse_input;
 
-use program::exec;
-
 fn main() {
     let input = parse_input(include_str!("../../input/day_09"));
-    println!("part_01, {:?}", exec(&input[0], Some(vec![1])));
-    println!("part_02, {:?}", exec(&input[0], Some(vec![2])));
+    println!("part_01, {:?}", exec(input[0].clone(), Some(vec![1])));
+    println!("part_02, {:?}", exec(input[0].clone(), Some(vec![2])));
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use ::day_09::program::{exec, Program};
+    use day_05::parse_input;
+    use std::{sync::mpsc::channel, thread::spawn};
 
     const EXAMPLES_ON_PART_01: &'static str = "
         1102,34915192,34915192,7,4,7,99,0
         104,1125899906842624,99
     ";
 
     #[test]
-    #[ignore]
     fn it_gets_the_examples_right_on_part_01() {
         let input = parse_input(&EXAMPLES_ON_PART_01);
 
-        assert_eq!(exec(&input[1], None), 1219070632396864);
-        assert_eq!(exec(&input[2], None), 1125899906842624);
+        assert_eq!(exec(input[0].clone(), None), 1219070632396864);
+        assert_eq!(exec(input[1].clone(), None), 1125899906842624);
     }
 
     #[test]
     fn quine() {
+        let (b_sender, a_receiver) = channel();
+        let (_, b_receiver) = channel();
+
+        let output_thread = spawn(move || {
+            let mut output = vec![];
+            loop {
+                let new_output = match a_receiver.recv() {
+                    Ok(val) => val,
+                    _ => break,
+                };
+                &output.push(new_output);
+            }
+            output.to_owned()
+        });
+
         let input = vec![
             109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99,
         ];
-        let mut program = program::Program::new(&input);
-        program.input = vec![];
-        assert_eq!(program.run(), 99);
-        assert_eq!(program.output, input.clone());
+
+        let thread_input = input.clone();
+        let result = spawn(move || {
+            let mut program = Program::new(&thread_input);
+            program.new_input(b_receiver);
+            program.new_output(b_sender);
+            program.run()
+        })
+        .join()
+        .unwrap();
+
+        assert_eq!(result, 99);
+
+        assert_eq!(output_thread.join().unwrap(), input.clone());
     }
 }
diff --git a/day_09/src/program.rs b/day_09/src/program.rs
@@ -1,4 +1,9 @@
-use std::{iter::Iterator, option::Option};
+use std::{
+    iter::Iterator,
+    option::Option,
+    sync::mpsc::{channel, Receiver, Sender},
+    thread::spawn,
+};
 
 #[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
 enum Mode {
@@ -12,29 +17,34 @@ pub struct Program {
     pointer: usize,
     relative_base: usize,
     halted: bool,
-    pub input: Vec<i64>,
-    pub output: Vec<i64>,
+    input: Receiver<i64>,
+    output: Sender<i64>,
+    output_value: i64,
     pub memory: Vec<i64>,
 }
 
 impl Program {
     pub fn new(memory: &Vec<i64>) -> Program {
+        let (output, input) = channel();
+
         Program {
             original_memory: memory.clone(),
             pointer: 0,
             relative_base: 0,
-            input: vec![0],
+            input,
             halted: false,
             memory: memory.clone(),
-            output: vec![],
+            output,
+            output_value: 0,
         }
     }
 
-    fn get_next_input(&mut self) -> Option<i64> {
-        match self.input.iter_mut().next() {
-            Some(input) => Some(*input),
-            _ => None,
-        }
+    pub fn new_input(&mut self, receiver: Receiver<i64>) {
+        self.input = receiver;
+    }
+
+    pub fn new_output(&mut self, sender: Sender<i64>) {
+        self.output = sender;
     }
 
     fn get_index(&mut self, step: usize, mode: Mode) -> usize {
@@ -108,15 +118,12 @@ impl Program {
 
     fn opcode_3_4(&mut self, opcode: i64, mode: Mode) -> i64 {
         if opcode == 3 {
-            match self.get_next_input() {
-                Some(input) => {
-                    *self.get_mut_memory_ref(1, mode) = input;
-                }
-                _ => {}
-            }
+            let input = self.input.recv().unwrap_or(0);
+            *self.get_mut_memory_ref(1, mode) = input;
         } else {
             let output = self.get_memory(1, mode);
-            self.output.push(output);
+            self.output.send(output.to_owned()).unwrap();
+            self.output_value = output;
         };
         2
     }
@@ -160,16 +167,16 @@ impl Program {
 
     pub fn run(&mut self) -> i64 {
         self.pointer = 0;
+        self.output_value = 0;
         self.halted = false;
         self.memory = self.original_memory.clone();
         self.relative_base = 0;
-        self.output.clear();
 
         while !self.halted {
-            self.eval()
+            self.eval();
         }
 
-        *self.output.clone().iter().last().unwrap_or(&0i64)
+        self.output_value.to_owned()
     }
 
     fn eval(&mut self) {
@@ -183,7 +190,6 @@ impl Program {
         let mode_second = self.mode(&instuction.next());
         let mode_third = self.mode(&instuction.next());
 
-
         if opcode == 9 && opcode_padding == 9 {
             self.halted = true;
             return;
@@ -202,13 +208,25 @@ impl Program {
     }
 }
 
-pub fn exec(memory: &Vec<i64>, input: Option<Vec<i64>>) -> i64 {
-    let input_unwrapped = match input {
-        Some(input) => input.to_owned(),
-        None => vec![0],
+pub fn exec(memory: Vec<i64>, output: Option<Vec<i64>>) -> i64 {
+    let (program_sender, _exec_reciever) = channel();
+    let (exec_sender, program_receiver) = channel();
+
+    match output {
+        Some(vec) => {
+            vec.into_iter().for_each(|val| {
+                exec_sender.send(val).unwrap();
+            });
+        }
+        None => {}
     };
 
-    let mut program = Program::new(memory);
-    program.input = input_unwrapped;
-    program.run()
+    let handle = spawn(move || {
+        let mut program = Program::new(&memory);
+        program.new_input(program_receiver);
+        program.new_output(program_sender);
+        program.run()
+    });
+
+    handle.join().unwrap()
 }
diff --git a/day_11/Cargo.toml b/day_11/Cargo.toml
@@ -7,3 +7,4 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+day_09 = { path = "../day_09" }
diff --git a/day_11/src/direction.rs b/day_11/src/direction.rs
@@ -0,0 +1,28 @@
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub enum Dir {
+    Up,
+    Right,
+    Down,
+    Left,
+}
+
+use Dir::*;
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub struct Direction(pub Dir);
+
+impl Direction {
+    pub fn new() -> Direction {
+        Direction(Up)
+    }
+
+    pub fn turn(&mut self, turn: u8) {
+        self.0 = match (self.0, turn) {
+            (Up, 0) | (Down, 1) => Left,
+            (Right, 0) | (Left, 1) => Up,
+            (Down, 0) | (Up, 1) => Right,
+            (Left, 0) | (Right, 1) => Down,
+            _ => panic!("turn not covered"),
+        }
+    }
+}
diff --git a/day_11/src/intcode.rs b/day_11/src/intcode.rs
diff --git a/day_11/src/lib.rs b/day_11/src/lib.rs
@@ -1,3 +1,9 @@
+extern crate day_09;
+
+pub mod direction;
+pub mod painting_robot;
+pub mod point;
+
 pub fn parse_input(input: &str) -> Vec<i64> {
     input
         .lines()
@@ -8,4 +14,4 @@ pub fn parse_input(input: &str) -> Vec<i64> {
         .split(',')
         .map(|part| part.parse::<i64>().unwrap())
         .collect::<Vec<i64>>()
-}
+}
diff --git a/day_11/src/main.rs b/day_11/src/main.rs
@@ -1,11 +1,26 @@
-use ::day_11::{parse_input};
+use ::day_11::{painting_robot::Robot, parse_input};
+use day_09::program::Program;
+use std::{sync::mpsc::channel, thread::spawn};
 
 fn main() {
-    let input = parse_input(&include_str!("../../input/day_11"));
-    println!("{:?}", input);
+    let (b_sender, a_receiver) = channel();
+    let (a_sender, b_receiver) = channel();
+
+    let mut program = Program::new(&parse_input(&include_str!("../../input/day_11")));
+    let mut robot = Robot::new(a_receiver, a_sender);
+
+    spawn(move || {
+        program.new_input(b_receiver);
+        program.new_output(b_sender);
+        program.run();
+    });
+
+    let part_01_output = spawn(move || robot.run()).join().unwrap();
+    println!("part_01, {}", part_01_output);
+    // let mut robot = Robot::new(&instructions);
+    // println!("part_01: {:?}", robot.run());
 }
 
 #[cfg(test)]
 #[allow(dead_code)]
-mod tests {
-}
+mod tests {}
diff --git a/day_11/src/painting_robot.rs b/day_11/src/painting_robot.rs
@@ -0,0 +1,80 @@
+use crate::direction::{Dir::*, Direction};
+use crate::point::Point;
+use std::{
+    collections::HashSet,
+    sync::mpsc::{Receiver, Sender},
+};
+
+pub struct Robot {
+    position: Point,
+    direction: Direction,
+    input: Receiver<i64>,
+    output: Sender<i64>,
+    visited: HashSet<Point>,
+    whites: HashSet<Point>,
+}
+
+impl Robot {
+    pub fn new(receiver: Receiver<i64>, sender: Sender<i64>) -> Robot {
+        let position = Point { x: 0, y: 0 };
+        let mut visited = HashSet::new();
+        let mut whites = HashSet::new();
+
+        visited.insert(position.clone());
+        whites.insert(position.clone());
+
+        Robot {
+            input: receiver,
+            output: sender,
+            direction: Direction::new(),
+            position,
+            visited,
+            whites,
+        }
+    }
+
+    fn move_position(&mut self) {
+        let x = self.position.x;
+        let y = self.position.y;
+
+        self.position = match self.direction.0 {
+            Up => Point { x, y: y + 1 },
+            Right => Point { x: x + 1, y },
+            Down => Point { x, y: y - 1 },
+            Left => Point { x: x - 1, y },
+        }
+    }
+
+    pub fn run(&mut self) -> usize {
+        loop {
+            let over_white_panel = self.whites.contains(&self.position);
+            self.output
+                .send(if over_white_panel { 1 } else { 0 })
+                .unwrap();
+
+            let next_color = match self.input.recv() {
+                Ok(0) => 0u8,
+                Ok(1) => 1u8,
+                _ => break,
+            };
+
+            if next_color == 0 {
+                self.whites.remove(&self.position);
+            } else {
+                self.whites.insert(self.position.clone());
+            }
+
+            let next_position = match self.input.recv() {
+                Ok(0) => 0u8,
+                Ok(1) => 1u8,
+                _ => break,
+            };
+
+            self.direction.turn(next_position);
+            self.move_position();
+            self.visited.insert(self.position.clone());
+        }
+
+        self.visited.len()
+    }
+}
diff --git a/day_11/src/point.rs b/day_11/src/point.rs
@@ -0,0 +1,7 @@
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub struct Point {
+    pub x: i64,
+    pub y: i64,
+}
+
+impl Point {}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+extern crate day_05;`
	`2`	`+`
	`3`	`+pub mod program;`
Original file line number	Diff line number	Diff line change
`@@ -7,3 +7,4 @@ edition = "2018"`
`7`	`7`	`# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html`
`8`	`8`
`9`	`9`	`[dependencies]`
	`10`	`+day_09 = { path = "../day_09" }`