feat: still not done with day 15...

ankjevel · ankjevel · commit 918ba5aceb1b · 2020-12-05T12:06:18.000+01:00
diff --git a/day_15/src/enums.rs b/day_15/src/enums.rs
@@ -10,7 +10,6 @@ use Direction::{Down, Left, Right, Up};
 
 impl Direction {
     pub fn new(input: i64) -> Direction {
-        println!("input: {:>}", input);
         match input {
             1 => Up,
             2 => Down,
diff --git a/day_15/src/main.rs b/day_15/src/main.rs
@@ -8,7 +8,7 @@ fn main() {
     println!("{:?}", part_01(&input));
 }
 
-fn part_01(input: &Vec<i64>) {
+fn part_01(input: &Vec<i64>) -> usize {
     let (b_sender, a_receiver) = channel();
     let (a_sender, b_receiver) = channel();
 
diff --git a/day_15/src/paths.rs b/day_15/src/paths.rs
@@ -16,21 +16,60 @@ fn is_between(a: &Point, c: &Point, b: &Point) -> bool {
     )
 }
 
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug, Ord, PartialOrd)]
+struct State {
+    cost: isize,
+    point: Point,
+}
+
 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 within_range = || -> Option<Vec<Point>> {
+        let get_closest = |range: usize| -> Option<Vec<Point>> {
+            let input = input
+                .clone()
+                .iter()
+                .filter(|(pos, tile)| {
+                    (tile == &&Tile::Unknown || tile == &&Tile::Visited) && !visited.contains(pos)
+                })
+                .filter(|(pos, _title)| {
+                    let x = ((position.0 as f64) - (pos.0 as f64)).abs() as usize;
+                    let y = ((position.1 as f64) - (pos.1 as f64)).abs() as usize;
+
+                    x <= range && y <= range
+                })
+                .map(|(pos, _tile)| pos.to_owned())
+                .collect::<Vec<Point>>();
+
+            if input.len() <= 0 {
+                None
+            } else {
+                Some(input.to_owned())
+            }
+        };
+
+        let mut range = 0;
+        let mut result = None;
+
+        loop {
+            if let Some(res) = get_closest(range) {
+                result = Some(res);
+                break;
+            }
+            range += 1;
+            if range >= input.len() {
+                break;
+            }
+        }
+
+        result
+    };
+
+    let available = match within_range() {
+        Some(res) => res.to_owned(),
+        None => return None,
+    };
 
     let mut steps = vec![];
 
@@ -40,7 +79,7 @@ pub fn best_match(input: &Map, position: &Point, visited: &Vec<Point>) -> Option
             None => continue,
         };
 
-        if path.len() < steps.len() {
+        if steps.len() == 0 || path.len() < steps.len() {
             steps = path.to_owned();
         }
     }
@@ -52,12 +91,6 @@ pub fn best_match(input: &Map, position: &Point, visited: &Vec<Point>) -> Option
     }
 }
 
-#[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();
@@ -124,3 +157,48 @@ pub fn find_path(map: &Map, start: Point, goal: Point) -> Option<Vec<Point>> {
 
     Some(path)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_goes_around_the_maze() {
+        let mut map = HashMap::new();
+
+        let c = Tile::Current;
+        let v = Tile::Visited;
+        let w = Tile::Wall;
+
+        let positions = vec![
+            vec![w, w, w, w, w], // [(0,0), (1,0), (2,0), (3,0), (4,0)]
+            vec![w, v, v, v, w], // [(0,1), (1,1), (2,1), (3,1), (4,1)]
+            vec![w, v, w, c, w], // [(0,2), (1,2), (2,2), (3,2), (4,2)]
+            vec![w, v, w, w, w], // [(0,3), (1,3), (2,3), (3,3), (4,3)]
+            vec![w, v, v, v, w], // [(0,4), (1,4), (2,4), (3,4), (4,4)]
+            vec![w, w, w, w, w], // [(0,5), (1,5), (2,5), (3,5), (4,5)]
+        ];
+
+        for (y, row) in positions.iter().enumerate() {
+            for (x, tile) in row.iter().enumerate() {
+                let (x, y) = (x.to_owned() as i64, y.to_owned() as i64);
+                map.insert((x, y), tile.to_owned());
+            }
+        }
+
+        assert_eq!(
+            find_path(&map, (3, 2), (3, 4)),
+            Some(vec![
+                (3, 4),
+                (2, 4),
+                (1, 4),
+                (1, 3),
+                (1, 2),
+                (1, 1),
+                (2, 1),
+                (3, 1),
+                (3, 2)
+            ])
+        );
+    }
+}
diff --git a/day_15/src/repair_droid.rs b/day_15/src/repair_droid.rs
@@ -22,6 +22,8 @@ pub struct RepairDroid {
     input: Receiver<i64>,
     output: Sender<i64>,
     grid: HashMap<Point, Tile>,
+    end: Option<Point>,
+    end_route: Option<Vec<Point>>,
     position: Point,
     direction: Direction,
     iterations: u64,
@@ -49,6 +51,8 @@ impl RepairDroid {
             visited: vec![(0, -1)],
             direction: Up,
             iterations: 0,
+            end: None,
+            end_route: None,
         }
     }
 
@@ -102,19 +106,48 @@ impl RepairDroid {
                 continue;
             }
 
+            let start = x == 0 && y == 0;
+            let end = !self.end.is_none() && self.end.unwrap() == (x, y);
+
             let x = (x + x_padding) as usize;
             let y = (y + y_padding) as usize;
 
             if let Some(elem) = grid.get_mut(y) {
-                elem[x] = match tile {
-                    Tile::Current => 'D',
-                    Tile::Wall => '#',
-                    Tile::Visited => '.',
-                    _ => ' ',
+                elem[x] = if start {
+                    '☆'
+                } else if end {
+                    '★'
+                } else {
+                    match tile {
+                        Tile::Current => 'D',
+                        Tile::Wall => '#',
+                        Tile::Visited => '.',
+                        _ => ' ',
+                    }
                 };
             }
         }
 
+        if let Some(vec) = &self.end_route {
+            for (x, y) in vec {
+                let (x, y) = (x.to_owned(), y.to_owned());
+                let start = x == 0 && y == 0;
+                let end = self.end.unwrap() == (x, y);
+                let x = (x + x_padding) as usize;
+                let y = (y + y_padding) as usize;
+
+                if let Some(elem) = grid.get_mut(y) {
+                    elem[x] = if start {
+                        '☆'
+                    } else if end {
+                        '★'
+                    } else {
+                        'x'
+                    };
+                }
+            }
+        }
+
         for row in grid {
             println!("{}", row.clone().iter().collect::<String>());
         }
@@ -129,6 +162,7 @@ impl RepairDroid {
                 if x == &self.position.0 && y == &self.position.1 {
                     continue;
                 }
+
                 let direction = if x == &prev.0 {
                     if y < &prev.1 {
                         Up
@@ -190,7 +224,7 @@ impl RepairDroid {
         Direction::dir(self.direction)
     }
 
-    fn move_droid(&mut self) -> Status {
+    fn move_droid(&mut self) -> bool {
         let next_direction = self.next_direction();
 
         self.output.send(next_direction.to_owned()).unwrap();
@@ -200,6 +234,10 @@ impl RepairDroid {
             Err(error) => panic!("error: {}", error),
         };
 
+        if status == MovedAndOnOxygen {
+            self.end = Some(self.position.clone());
+        }
+
         match status {
             Wall => {
                 let wall_position = self.get_position(self.direction);
@@ -210,7 +248,6 @@ impl RepairDroid {
                 self.grid.insert(self.position.clone(), Tile::Visited);
                 self.position = self.get_position(self.direction);
                 self.grid.insert(self.position.clone(), Tile::Current);
-
                 vec![(0, 1), (1, 0), (-1, 0), (0, -1)]
                     .iter()
                     .for_each(|(x, y)| {
@@ -228,14 +265,30 @@ impl RepairDroid {
             }
         };
 
-        status
+        let unknown_left = self.grid.iter().fold(0, |acc, curr| {
+            if curr.1 == &Tile::Unknown {
+                acc + 1
+            } else {
+                acc
+            }
+        });
+
+        unknown_left == 0
     }
 
-    pub fn run(&mut self) {
-        while self.move_droid() != MovedAndOnOxygen {
-            sleep(Duration::from_millis(60));
+    pub fn run(&mut self) -> usize {
+        while !self.move_droid() {
+            sleep(Duration::from_millis(10));
             self.iterations += 1;
             self.print();
         }
+
+        if let Some(result) = paths::find_path(&self.grid.to_owned(), (0, 0), self.end.unwrap()) {
+            self.end_route = Some(result.to_owned());
+            self.print();
+            result.len()
+        } else {
+            0
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ fn main() {`
`8`	`8`	`println!("{:?}", part_01(&input));`
`9`	`9`	`}`
`10`	`10`
`11`		`-fn part_01(input: &Vec<i64>) {`
	`11`	`+fn part_01(input: &Vec<i64>) -> usize {`
`12`	`12`	`let (b_sender, a_receiver) = channel();`
`13`	`13`	`let (a_sender, b_receiver) = channel();`
`14`	`14`