feat: simplified things

ankjevel · ankjevel · commit 75083d7d6d51 · 2020-12-05T12:05:08.000+01:00
diff --git a/day03/src/main.rs b/day03/src/main.rs
@@ -4,9 +4,11 @@ use std::io::Result;
 
 pub mod manhattan;
 mod part_01;
+mod part_02;
 pub mod structs;
 
 use part_01::main as part_01;
+use part_02::main as part_02;
 use structs::Direction::{Down, Left, Right, Up};
 use structs::Movement;
 
@@ -16,6 +18,8 @@ fn main() -> Result<()> {
     let wires = parse_input(include_str!("../../input/day_03"));
 
     println!("part_01: {:?}", part_01(&wires).unwrap());
+    println!("part_02: {:?}", part_02(&wires).unwrap());
+
     Ok(())
 }
 
@@ -59,12 +63,25 @@ mod tests {
 
     const EXAMPLE_DATA_02: &'static str = "
         R98,U47,R26,D63,R33,U87,L62,D20,R33,U53,R51
-        U98,R91,D20,R16,D67,R40,U7,R15,U6,R77
+        U98,R91,D20,R16,D67,R40,U7,R15,U6,R7
+    ";
+
+    const EXAMPLE_DATA_00: &'static str = "
+        R8,U5,L5,D3
+        U7,R6,D4,L4
     ";
 
     #[test]
-    fn it_gets_the_correct_result_based_on_examples() {
+    fn it_gets_the_correct_result_based_on_examples_for_part_1() {
+        assert_eq!(6, part_01(&parse_input(EXAMPLE_DATA_00)).unwrap());
         assert_eq!(159, part_01(&parse_input(EXAMPLE_DATA_01)).unwrap());
         assert_eq!(135, part_01(&parse_input(EXAMPLE_DATA_02)).unwrap());
     }
+
+    #[test]
+    fn it_gets_the_correct_result_based_on_examples_for_part_2() {
+        assert_eq!(30, part_02(&parse_input(EXAMPLE_DATA_00)).unwrap());
+        assert_eq!(610, part_02(&parse_input(EXAMPLE_DATA_01)).unwrap());
+        assert_eq!(410, part_02(&parse_input(EXAMPLE_DATA_02)).unwrap());
+    }
 }
diff --git a/day03/src/part_01.rs b/day03/src/part_01.rs
@@ -15,51 +15,18 @@ enum State {
 
 use State::{Empty, Intersect, Occupied, Start};
 
-#[allow(dead_code)]
-fn min_max(input: &Vec<Vec<Point>>) -> (i32, i32, i32, i32) {
-    let (max_x, max_y) = input.iter().fold((0, 0), |(max_x, max_y), point| {
-        point.iter().fold((0, 0), |(max_x_x, max_y_y), point| {
-            (
-                max(max_x, max(max_x_x, point.x)),
-                max(max_y, max(max_y_y, point.y)),
-            )
-        })
-    });
-
-    let (min_x, min_y) = input.iter().fold((0, 0), |(min_x, min_y), point| {
-        point.iter().fold((0, 0), |(min_x_x, min_y_y), point| {
-            (
-                min(min_x, min(min_x_x, point.x)),
-                min(min_y, min(min_y_y, point.y)),
-            )
-        })
-    });
-
-    (min_x, min_y, max_x, max_y)
-}
-
 pub fn main(input: &Vec<Vec<Point>>) -> Result<u64> {
     let mut grid = HashMap::new();
     let mut intersecting = Vec::new();
     let start_point = Point { x: 0, y: 0 };
 
     grid.insert(start_point, Start);
 
-    // # for printing the board, slow process
-    // let (min_x, min_y, max_x, max_y) = min_max(&input);
-    // for x in min_x..max_x {
-    //     for y in min_y..max_y {
-    //         let state = if x == 0 && y == 0 { Start } else { Empty };
-    //         let point = Point { x, y };
-    //         grid.insert(point, state);
-    //     }
-    // }
-
     let mut current_wire = 0;
     for points in input.iter() {
         let mut prev = Point::new();
 
-        for current in points.iter().peekable() {
+        for current in points.iter() {
             for x in min(prev.x, current.x)..=max(prev.x, current.x) {
                 for y in min(prev.y, current.y)..=max(prev.y, current.y) {
                     let point = Point { x, y };
@@ -78,8 +45,10 @@ pub fn main(input: &Vec<Vec<Point>>) -> Result<u64> {
                     };
                 }
             }
+
             prev = *current;
         }
+
         current_wire += 1;
     }
 
diff --git a/day03/src/part_02.rs b/day03/src/part_02.rs
@@ -0,0 +1,80 @@
+use std::cmp::{max, min};
+use std::collections::HashMap;
+use std::io::Result;
+use std::u64::MAX;
+
+use super::Point;
+
+enum State {
+    Occupied(u8, u64),
+    Intersect,
+    Start,
+    Empty,
+}
+
+use State::{Empty, Intersect, Occupied, Start};
+
+fn calc_steps(from: i32, to: i32) -> i64 {
+    (to as i64 - from as i64).abs()
+}
+
+pub fn main(input: &Vec<Vec<Point>>) -> Result<u64> {
+    let mut grid = HashMap::new();
+    let mut shortest_route = MAX;
+
+    grid.insert(Point::new(), Start);
+
+    let mut current_wire = 0;
+    for wire in input.iter() {
+        let mut prev = Point::new();
+        let mut steps_total = 0;
+
+        for current in wire.iter() {
+            let x_neg = prev.x > current.x;
+            let y_neg = prev.y > current.y;
+
+            let mut x = prev.x;
+            let mut y = prev.y;
+
+            let mut steps_x = 0;
+            let mut steps_y = 0;
+
+            let mut check_current_state = |point: Point, current_steps: u64| {
+                let state = grid.entry(point).or_insert(Empty);
+                match state {
+                    Empty => *state = Occupied(current_wire, current_steps),
+                    Occupied(occupied_by, occupied_by_steps) => {
+                        if *occupied_by != current_wire {
+                            shortest_route =
+                                min(shortest_route, *occupied_by_steps + current_steps);
+                            *state = Intersect;
+                        }
+                    }
+                    _ => {}
+                };
+            };
+
+            let check_current_steps =
+                |steps_x: i64, steps_y: i64| -> u64 { (steps_total + (steps_x + steps_y)) as u64 };
+
+            for _ in min(prev.x, current.x)..max(prev.x, current.x) {
+                x = if x_neg { x - 1 } else { x + 1 };
+                steps_x = calc_steps(prev.x, x);
+                check_current_state(Point { x, y }, check_current_steps(steps_x, steps_y));
+            }
+
+            for _ in min(prev.y, current.y)..max(prev.y, current.y) {
+                y = if y_neg { y - 1 } else { y + 1 };
+                steps_y = calc_steps(prev.y, y);
+                check_current_state(Point { x, y }, check_current_steps(steps_x, steps_y));
+            }
+
+            steps_total += steps_x + steps_y;
+            prev = *current;
+        }
+
+        current_wire += 1;
+    }
+
+    Ok(shortest_route)
+}
