From c421c33529780a9d26828910a3110a88784663dd Mon Sep 17 00:00:00 2001
From: Jack Kinsey <j.jameskinsey@gmail.com>
Date: Sun, 8 Dec 2024 16:17:05 -0500
Subject: [PATCH] Tidy up day 8

---
 src/day08.rs | 37 +++++++++++++++++++++----------------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/src/day08.rs b/src/day08.rs
index 4baa335..77b7930 100644
--- a/src/day08.rs
+++ b/src/day08.rs
@@ -5,9 +5,19 @@ fn input() -> &'static str {
     include_str!("../input/day08.txt")
 }
 
-#[derive(Debug, Hash, Ord, PartialOrd, Eq, PartialEq, Copy, Clone)]
+#[derive(Debug, Hash, Eq, PartialEq, Copy, Clone)]
 struct Point(i32, i32);
 
+impl Point {
+    fn in_bounds(&self, bound: i32) -> bool {
+        self.0 >= 0 && self.1 >= 0 && self.0 < bound && self.1 < bound
+    }
+
+    fn scale(&self, multiplier: i32) -> Point {
+        Point(self.0 * multiplier, self.1 * multiplier)
+    }
+}
+
 impl Add for Point {
     type Output = Point;
 
@@ -45,38 +55,33 @@ fn parse(input: &str) -> HashMap<char, Vec<Point>> {
 fn get_nearby_colinear_points(bound: i32, a: Point, b: Point) -> Vec<Point> {
     [a - b + a, b - a + b]
         .iter()
-        .filter(move |Point(i, j)| *i >= 0 && *i < bound && *j >= 0 && *j < bound)
+        .filter(|p| p.in_bounds(bound))
         .copied()
         .collect()
 }
 
 fn get_colinear_points(bound: i32, a: Point, b: Point) -> Vec<Point> {
-    let d = a.min(b) - a.max(b);
-    let mut p0 = a.min(b);
-    while p0.0 >= 0 && p0.1 >= 0 && p0.0 < bound && p0.1 < bound {
-        p0 = p0 + d;
-    }
-    p0 = p0 - d;
-    [p0].iter()
+    let d = a - b;
+    [a].iter()
         .cycle()
-        .zip(0..)
-        .map(|(p, n)| *p - Point(n * d.0, n * d.1))
-        .take_while(|&Point(i, j)| i >= 0 && j >= 0 && i < bound && j < bound)
+        .zip(-bound..bound)
+        .map(|(p, n)| *p - d.scale(n))
+        .filter(|p| p.in_bounds(bound))
         .collect()
 }
 
-fn find_nearby_antinodes(size: i32, pos: &[Point]) -> impl Iterator<Item = Point> + use<'_> {
+fn find_nearby_antinodes(bound: i32, pos: &[Point]) -> impl Iterator<Item = Point> + use<'_> {
     pos.iter()
         .flat_map(|p| pos.iter().map(move |q| (p, q)))
         .filter(|(a, b)| a != b)
-        .flat_map(move |(a, b)| get_nearby_colinear_points(size, *a, *b))
+        .flat_map(move |(a, b)| get_nearby_colinear_points(bound, *a, *b))
 }
 
-fn find_antinodes(size: i32, pos: &[Point]) -> impl Iterator<Item = Point> + use<'_> {
+fn find_antinodes(bound: i32, pos: &[Point]) -> impl Iterator<Item = Point> + use<'_> {
     pos.iter()
         .flat_map(|p| pos.iter().map(move |q| (p, q)))
         .filter(|(a, b)| a != b)
-        .flat_map(move |(a, b)| get_colinear_points(size, *a, *b))
+        .flat_map(move |(a, b)| get_colinear_points(bound, *a, *b))
 }
 
 pub fn part1() {
-- 
2.38.5