day9 part2 complete

src/day9.rs

···
 pub fn day9_part2(input: &str) -> String {
     let points = parse(input);
 
-    // let red_or_green_tiles_shape = RightAngledShape::new(&points);
+    let red_or_green_tiles_shape = RightAngledShape::new(&points);
 
     let pair = points
-        .iter()
+        .into_iter()
         .combinations(2)
         .map(|pair| (pair[0], pair[1]))
-        .filter(|(l, r)| {
-            !points
-                .iter()
-                .any(|pt| Point::rect_strict_contains_point(**l, **r, *pt))
+        .filter(|rect| {
+            red_or_green_tiles_shape.contains_rect(*rect)
         })
         .max_by_key(|(l, r)| l.rectangular_area(r))
         .unwrap();
 
-    dbg!(pair);
-    pair.0.rectangular_area(pair.1).to_string()
+    dbg!(&pair);
+    pair.0.rectangular_area(&pair.1).to_string()
 }
 
 fn parse(input: &str) -> Vec<Point> {

src/lib.rs

···
     fn day9_part2_test() {
         let test_result = day9::day9_part2(include_str!("../input/day9.test.txt"));
         assert_eq!(test_result, "24");
-        // let result = day9::day9_part2(include_str!("../input/day9.txt"));
-        // assert_eq!(result, "6083499488");
+        let result = day9::day9_part2(include_str!("../input/day9.txt"));
+        assert_eq!(result, "1343576598");
     }
 
 

src/spatial.rs

···
-use std::{collections::BTreeSet, convert::Infallible, num::ParseIntError, str::FromStr};
+use std::{num::ParseIntError, str::FromStr};
 
 use itertools::Itertools;
 
···
         let width = self.col.abs_diff(r.col) + 1;
         width * height
     }
-    pub fn rect_strict_contains_point(r1: Point, r2: Point, p: Point) -> bool {
-        let row_condition = if r1.row <= r2.row {
-            p.row > r1.row && p.row < r2.row
-        } else {
-            p.row < r1.row && p.row > r2.row
-        };
-        let col_condition = if r1.col <= r2.col {
-            p.col > r1.col && p.col < r2.col
-        } else {
-            p.col < r1.col && p.col > r2.col
-        };
-        dbg!(r1, r2, p, row_condition, col_condition);
-
-        row_condition && col_condition
-    }
 }
 
 #[derive(Debug, Clone)]
···
         }
     }
 
-    pub fn area(&self) -> usize {
-        todo!()
+    pub fn contains_rect(&self, rect: (Point, Point)) -> bool {
+        !(Self::rect_strict_contains_line(
+            rect,
+            (self.corners[0], self.corners[self.corners.len() - 1]),
+        ) || self
+            .corners
+            .windows(2)
+            .any(|window| Self::rect_strict_contains_line(rect, (window[0], window[1]))))
     }
 
-    pub fn contains_rect(&self, other_corner1: Point, other_corner2: Point) -> bool {
-        todo!()
+    fn rect_strict_contains_line(rect: (Point, Point), line: (Point, Point)) -> bool {
+        let left_col = rect.0.col.min(rect.1.col);
+        let right_col = rect.0.col.max(rect.1.col);
+        let top_row = rect.0.row.min(rect.1.row);
+        let bottom_row = rect.0.row.max(rect.1.row);
+
+        if line.0.row == line.1.row {
+            //horizontal line
+            let row_cond = line.0.row >= bottom_row || line.0.row <= top_row;
+            let left_cond = line.0.col <= left_col && line.1.col <= left_col;
+            let right_cond = line.0.col >= right_col && line.1.col >= right_col;
+
+            !row_cond && !left_cond && !right_cond
+        } else {
+            //vertical line
+            let col_cond = line.0.col >= right_col || line.0.col <= left_col;
+            let above_cond = line.0.row <= top_row && line.1.row <= top_row;
+            let below_cond = line.0.row >= bottom_row && line.1.row >= bottom_row;
+
+            !col_cond && !above_cond && !below_cond
+        }
     }
 }
 
···
             + (self.z as isize - other.z as isize).abs().pow(2)) as f64)
             .sqrt()
     }
-    pub fn format(&self) -> String {
-        format!("{},{},{}", self.x, self.y, self.z)
-    }
-}
-
-fn connected_components(pairs: &[(Point3D, Point3D)]) -> BTreeSet<BTreeSet<Point>> {
-    todo!()
 }
 
 pub fn all_coords(width: usize, height: usize) -> impl Iterator<Item = Point> {