2025 09.2

Author: Lexicality

src/aoc/y2025/day09.rs

@@ -7,12 +7,11 @@
 // <https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12>.
 // See the Licence for the specific language governing permissions and limitations under the Licence.
 
-use std::{collections::HashMap, fmt::Display};
+use std::fmt::Display;
 
 use itertools::Itertools;
-use num::Integer;
 
-use crate::{AoCError, BigCoord2D, CommonGrid, Coordinate, Coordinate2D, symbols};
+use crate::{AoCError, BigCoord2D, CommonGrid, Coordinate, symbols};
 
 pub fn part_1(data: crate::DataIn) -> crate::AoCResult<String> {
     let coords: Vec<BigCoord2D> = data.map(|line| line.parse()).try_collect()?;
@@ -36,58 +35,6 @@ pub fn part_1(data: crate::DataIn) -> crate::AoCResult<String> {
     Ok(ret.to_string())
 }
 
-/// Adapted from http://web.archive.org/web/20080812141848/http://local.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/
-fn inside_polygon(point: BigCoord2D, polygon: &[BigCoord2D]) -> bool {
-    polygon
-        .iter()
-        .tuple_windows()
-        .filter(|(poly_a, poly_b)| {
-            let poly_min = poly_a.get_min(poly_b);
-            let poly_max = poly_a.get_max(poly_b);
-            if point.y <= poly_min.y {
-                // why does this only check y coords? who knows.
-                return false;
-            } else if point.x > poly_max.x || point.y > poly_max.y {
-                return false;
-            } else if poly_a.y == poly_b.y {
-                // ????
-                return false;
-            }
-            // mystery statement
-            let xinters =
-                (point.y - poly_a.y) * (poly_b.x - poly_a.x) / (poly_b.y - poly_a.y) + poly_a.x;
-            poly_a.x == poly_b.x || point.x <= xinters
-        })
-        .count()
-        .is_odd()
-}
-
-fn cached_inside_polygon(
-    point: BigCoord2D,
-    polygon: &[BigCoord2D],
-    prechecked: &mut HashMap<BigCoord2D, bool>,
-) -> bool {
-    if let Some(result) = prechecked.get(&point) {
-        return *result;
-    }
-    let result = inside_polygon(point, polygon);
-    log::trace!(
-        "Magic function says {point} is {} poly",
-        if result { "inside" } else { "outside" }
-    );
-    prechecked.insert(point, result);
-    result
-}
-
-fn rectangulate(a: &BigCoord2D, b: &BigCoord2D) -> impl Iterator<Item = BigCoord2D> {
-    log::trace!("wtf wtf {a} {b}");
-    // I'm moderately sure I've written this code before but I don't know where it is
-    (a.x..=b.x)
-        .cartesian_product(a.y..=b.y)
-        .map(BigCoord2D::from_tuple)
-        .inspect(|c| log::trace!("wtf {c}"))
-}
-
 pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
     let coords = {
         let mut coords: Vec<BigCoord2D> = data.map(|line| line.parse()).try_collect()?;
@@ -96,7 +43,7 @@ pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
         coords
     };
 
-    let mut prechecked: HashMap<BigCoord2D, bool> = coords
+    let lines: Vec<BigCoord2D> = coords
         .iter()
         .tuple_windows()
         .flat_map(|(a, b)| {
@@ -110,7 +57,6 @@ pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
                 (a.y..=b.y).map(|y| BigCoord2D { x, y }).collect_vec()
             }
         })
-        .map(|c| (c, true))
         .collect();
 
     // stupid test grid
@@ -139,7 +85,7 @@ pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
         }
 
         let mut grid: SparseGrid<GridState, BigCoord2D> =
-            prechecked.keys().map(|a| (*a, GridState::Green)).collect();
+            lines.iter().map(|a| (*a, GridState::Green)).collect();
 
         coords.iter().for_each(|c| {
             grid.set(*c, GridState::Red);
@@ -161,60 +107,19 @@ pub fn part_2(data: crate::DataIn) -> crate::AoCResult<String> {
         .inspect(|(dist, a, b)| {
             log::debug!("Square of area {dist} between {a} and {b}");
         })
-        .find(|(_, a, b)| {
-            rectangulate(a, b).all(|point| cached_inside_polygon(point, &coords, &mut prechecked))
+        .filter(|(_, min, max)| {
+            !coords
+                .iter()
+                .any(|c| c.x > min.x && c.y > min.y && c.x < max.x && c.y < max.y)
+        })
+        .find(|(_, min, max)| {
+            !lines
+                .iter()
+                .any(|c| c.x > min.x && c.y > min.y && c.x < max.x && c.y < max.y)
         })
         .map(|(dist, _, _)| dist)
         .ok_or(AoCError::new("No valid rectangles?"))?;
 
-    // stupid test grid v2
-    log::debug!("postchecked:\n{}", {
-        use aoc_macros::VoidState;
-
-        use crate::SparseGrid;
-
-        #[derive(Debug, VoidState)]
-        enum GridState {
-            #[void]
-            Void,
-            Red,
-            Green,
-            White,
-        }
-
-        impl Display for GridState {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                match self {
-                    Self::Void => symbols::VOID,
-                    Self::Red => symbols::BLOCK,
-                    Self::Green => symbols::SHADE_DARK,
-                    Self::White => symbols::SHADE_LIGHT,
-                }
-                .fmt(f)
-            }
-        }
-
-        let mut grid: SparseGrid<GridState, BigCoord2D> = prechecked
-            .iter()
-            .map(|(coord, state)| {
-                (
-                    *coord,
-                    if *state {
-                        GridState::Green
-                    } else {
-                        GridState::White
-                    },
-                )
-            })
-            .collect();
-
-        coords.iter().for_each(|c| {
-            grid.set(*c, GridState::Red);
-        });
-
-        grid
-    });
-
     Ok(ret.to_string())
 }