feat: trying to solve part 1

ankjevel · ankjevel · commit 124972eb5237 · 2020-12-05T12:06:18.000+01:00
diff --git a/day_15/Cargo.toml b/day_15/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "day_15"
+version = "0.1.0"
+authors = ["Dennis Pettersson <mail@dennispettersson.se>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+day_09 = { path = "../day_09" }
+termion = "1.5.4"
+float-cmp = "0.6.0"
+rand = "0.7.2"
diff --git a/day_15/src/enums.rs b/day_15/src/enums.rs
@@ -0,0 +1,67 @@
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub enum Direction {
+    Up = 1,
+    Down = 2,
+    Left = 3,
+    Right = 4,
+}
+
+use Direction::{Down, Left, Right, Up};
+
+impl Direction {
+    pub fn new(input: i64) -> Direction {
+        println!("input: {:>}", input);
+        match input {
+            1 => Up,
+            2 => Down,
+            3 => Left,
+            _ => Right,
+        }
+    }
+
+    pub fn dir(input: Direction) -> i64 {
+        match input {
+            Up => 1,
+            Down => 2,
+            Left => 3,
+            Right => 4,
+        }
+    }
+
+    pub fn turn(self) -> Direction {
+        match self {
+            Up => Right,
+            Right => Down,
+            Down => Left,
+            Left => Up,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub enum Status {
+    Wall = 0,
+    Moved = 1,
+    MovedAndOnOxygen = 2,
+}
+
+use Status::{Moved, MovedAndOnOxygen, Wall};
+
+impl Status {
+    pub fn new(input: i64) -> Status {
+        match input {
+            0 => Wall,
+            1 => Moved,
+            2 => MovedAndOnOxygen,
+            _ => panic!("{} not known", input),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub enum Tile {
+    Current,
+    Unknown,
+    Wall,
+    Visited,
+}
diff --git a/day_15/src/lib.rs b/day_15/src/lib.rs
@@ -0,0 +1,24 @@
+#[macro_use]
+extern crate float_cmp;
+
+extern crate day_09;
+extern crate rand;
+extern crate termion;
+
+pub type Point = (i64, i64);
+
+pub mod enums;
+pub mod paths;
+pub mod repair_droid;
+
+pub fn parse_input(input: &str) -> Vec<i64> {
+    input
+        .lines()
+        .map(|string| string.trim())
+        .filter(|string| !string.is_empty())
+        .next()
+        .unwrap()
+        .split(',')
+        .map(|part| part.parse::<i64>().unwrap())
+        .collect::<Vec<i64>>()
+}
diff --git a/day_15/src/main.rs b/day_15/src/main.rs
@@ -0,0 +1,24 @@
+use ::day_15::{parse_input, repair_droid::RepairDroid};
+use day_09::program::Program;
+use std::{sync::mpsc::channel, thread::spawn};
+
+fn main() {
+    let input = parse_input(&include_str!("../../input/day_15"));
+
+    println!("{:?}", part_01(&input));
+}
+
+fn part_01(input: &Vec<i64>) {
+    let (b_sender, a_receiver) = channel();
+    let (a_sender, b_receiver) = channel();
+
+    let mut program = Program::new(&input);
+
+    program.new_input(b_receiver);
+    program.new_output(b_sender);
+
+    spawn(move || program.run());
+    spawn(move || RepairDroid::new(a_receiver, a_sender).run())
+        .join()
+        .unwrap()
+}
diff --git a/day_15/src/paths.rs b/day_15/src/paths.rs
@@ -0,0 +1,125 @@
+use crate::enums::Tile;
+use crate::Point;
+use std::collections::{BinaryHeap, HashMap};
+
+fn distance(p1: &Point, p2: &Point) -> f64 {
+    ((p2.0 as f64 - p1.0 as f64).powf(2f64) + (p2.1 as f64 - p1.1 as f64).powf(2f64)).sqrt()
+}
+
+#[allow(dead_code)]
+fn is_between(a: &Point, c: &Point, b: &Point) -> bool {
+    approx_eq!(
+        f64,
+        distance(&a, &c) + distance(&c, &b),
+        distance(&a, &b),
+        ulps = 2
+    )
+}
+
+type Map = HashMap<Point, Tile>;
+
+pub fn best_match(input: &Map, position: &Point, visited: &Vec<Point>) -> Option<Vec<Point>> {
+    let available = input
+        .clone()
+        .iter()
+        .filter(|(pos, tile)| {
+            (tile == &&Tile::Unknown || tile == &&Tile::Visited) && !visited.contains(pos)
+        })
+        .map(|(pos, _tile)| pos.to_owned())
+        .collect::<Vec<Point>>();
+
+    if available.len() <= 0 {
+        return None;
+    }
+
+    let mut steps = vec![];
+
+    for current in available.clone() {
+        let path = match find_path(&input, position.to_owned(), current.to_owned()) {
+            Some(path) => path.to_owned(),
+            None => continue,
+        };
+        if path.len() > steps.len() {
+            steps = path.to_owned();
+        }
+    }
+
+    if steps.len() == 0 {
+        None
+    } else {
+        Some(steps.to_owned())
+    }
+}
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]
+struct State {
+    cost: isize,
+    point: Point,
+}
+
+pub fn find_path(map: &Map, start: Point, goal: Point) -> Option<Vec<Point>> {
+    let adjacent = |point: &Point| -> Vec<Point> {
+        let mut vec = Vec::new();
+
+        for (x, y) in vec![(0, 1), (1, 0), (-1, 0), (0, -1)] {
+            let new_pos = (point.0 + x, point.1 + y);
+            if let Some(tile) = map.get(&new_pos) {
+                if tile != &Tile::Wall {
+                    vec.push(new_pos.to_owned());
+                }
+            };
+        }
+
+        vec
+    };
+
+    let can_move = |point: &Point| -> bool {
+        match map.get(&point) {
+            Some(tile) => tile != &Tile::Wall,
+            None => false,
+        }
+    };
+
+    let mut frontier = BinaryHeap::new();
+    frontier.push(State {
+        cost: 0,
+        point: start,
+    });
+
+    let mut came_from = HashMap::new();
+    came_from.insert(start, None);
+
+    while frontier.len() != 0 {
+        let current = frontier.pop();
+        if current.unwrap().point == goal {
+            break;
+        }
+        for next_point in adjacent(&current.unwrap().point) {
+            if !came_from.contains_key(&next_point) && can_move(&next_point) {
+                frontier.push(State {
+                    point: next_point,
+                    cost: distance(&goal, &next_point) as isize,
+                });
+                came_from.insert(next_point, current.map(|a| a.point));
+            }
+        }
+    }
+
+    let mut current = goal;
+    let mut path = vec![current];
+
+    while current != start {
+        if let Some(c) = came_from.get(&current) {
+            if let Some(c) = *c {
+                current = c;
+                path.push(current);
+            } else {
+                return None;
+            }
+        } else {
+            return None;
+        }
+    }
+
+    Some(path)
+}
diff --git a/day_15/src/repair_droid.rs b/day_15/src/repair_droid.rs
