Day 9 - General sol

src/day9/main.rs

@@ -2,7 +2,7 @@ use anyhow::{Result, bail};
 use std::{
     collections::{HashMap, HashSet},
     fs,
-    ops::RangeInclusive,
+    ops::Range,
 };
 
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -42,19 +42,19 @@ impl<'a> Pair<'a> {
         }
     }
 
-    fn get_x_range(&'a self) -> RangeInclusive<i64> {
+    fn get_x_range(&'a self) -> Range<i64> {
         match self.b1.x.cmp(&self.b2.x) {
-            std::cmp::Ordering::Equal => self.b1.x..=self.b1.x,
+            std::cmp::Ordering::Equal => panic!("unrechable {:?}", self),
-            std::cmp::Ordering::Less => self.b1.x..=self.b2.x,
+            std::cmp::Ordering::Less => (self.b1.x + 1)..self.b2.x,
-            std::cmp::Ordering::Greater => self.b2.x..=self.b2.x,
+            std::cmp::Ordering::Greater => (self.b2.x + 1)..self.b1.x,
         }
     }
 
-    fn get_y_range(&'a self) -> RangeInclusive<i64> {
+    fn get_y_range(&'a self) -> Range<i64> {
         match self.b1.y.cmp(&self.b2.y) {
-            std::cmp::Ordering::Equal => self.b1.y..=self.b1.y,
+            std::cmp::Ordering::Equal => panic!("unrechable {:?}", self),
-            std::cmp::Ordering::Less => self.b1.y..=self.b2.y,
+            std::cmp::Ordering::Less => (self.b1.y + 1)..self.b2.y,
-            std::cmp::Ordering::Greater => self.b2.y..=self.b2.y,
+            std::cmp::Ordering::Greater => (self.b2.y + 1)..self.b1.y,
         }
     }
 
@@ -62,25 +62,19 @@ impl<'a> Pair<'a> {
     fn colide(&'a self, other: &'a Pair) -> Result<bool> {
         if self.b1.x == self.b2.x {
             if other.b1.x == other.b2.x {
-                let other_range = other.get_y_range();
+                return Ok(false);
-                let b1in = other_range.contains(&self.b1.y);
-                let b2in = other_range.contains(&self.b1.y);
-                // Might need to check this
-                return Ok(self.b1.x == other.b2.x && (b1in || b2in) && !(b1in && b2in));
             } else if other.b1.y == other.b2.y {
-                return Ok(self.get_y_range().contains(&other.b1.y));
+                return Ok(self.get_y_range().contains(&other.b1.y)
+                    && other.get_x_range().contains(&self.b1.x));
             } else {
                 bail!("Did not follow instructions 1 {:?}", other);
             }
         } else if self.b1.y == self.b2.y {
             if other.b1.y == other.b2.y {
-                let other_range = other.get_x_range();
+                return Ok(false);
-                let b1in = other_range.contains(&self.b1.x);
-                let b2in = other_range.contains(&self.b1.x);
-                // Might need to check this
-                return Ok(self.b1.y == other.b2.y && (b1in || b2in) && !(b1in && b2in));
             } else if other.b1.x == other.b2.x {
-                return Ok(self.get_x_range().contains(&other.b1.y));
+                return Ok(self.get_x_range().contains(&other.b1.x)
+                    && other.get_y_range().contains(&self.b1.y));
             } else {
                 bail!("Did not follow instructions 2 {:?}", other);
             }
@@ -88,6 +82,28 @@ impl<'a> Pair<'a> {
             bail!("Did not follow instructions 3 {:?}", self);
         }
     }
+
+    fn as_rect(&self) {
+        println!(
+            "<path style=\"fill:black\" d=\"M{} {} L{} {} L{} {} L{} {}\" count=\"{}\" />",
+            self.b1.x,
+            self.b1.y,
+            self.b2.x,
+            self.b1.y,
+            self.b2.x,
+            self.b2.y,
+            self.b1.x,
+            self.b2.y,
+            self.area
+        );
+    }
+
+    fn as_line(&self) {
+        println!(
+            "<line x1=\"{}\" y1=\"{}\" x2=\"{}\" y2=\"{}\" style=\"stroke:yellow;stroke-width:100\" />",
+            self.b1.x, self.b1.y, self.b2.x, self.b2.y,
+        );
+    }
 }
 
 fn main() -> Result<()> {
@@ -107,7 +123,7 @@ fn main() -> Result<()> {
             if i + 1 >= boxes.len() {
                 &boxes[0]
             } else {
-                &boxes[i]
+                &boxes[i + 1]
             },
         ))
     }
@@ -130,27 +146,13 @@ fn main() -> Result<()> {
 
     for (i, b1) in boxes.iter().enumerate() {
         for b2 in boxes.iter().skip(i) {
-            if b1.y >= 50265 && b2.y >= 50265 {
+            pairs.push(Pair::new(b1, b2))
-                pairs.push(Pair::new(b1, b2))
-            }
-            if b1.y <= 48488 && b2.y <= 48488 {
-                pairs.push(Pair::new(b1, b2))
-            }
-            if b1.x >= 94901 && b2.x >= 94901 {
-                pairs.push(Pair::new(b1, b2))
-            }
         }
     }
 
     pairs.sort_by(|a, b| a.area.cmp(&b.area));
 
     'b2: for b in pairs.iter().rev() {
-        //     //
-        //     //		1        p
-        //     //
-        //     //
-        //     //		t        2
-        //     //
         let max_x = b.b1.x.max(b.b2.x);
         let min_x = b.b1.x.min(b.b2.x);
         let max_y = b.b1.y.max(b.b2.y);
@@ -158,28 +160,68 @@ fn main() -> Result<()> {
 
         for p in boxes.iter() {
             if p.x > min_x && p.x < max_x && p.y > min_y && p.y < max_y {
-                println!(
-                    "<path style=\"fill:blue\" d=\"M{} {} L{} {} L{} {} L{} {}\" count=\"{}\" /><circle x=\"{}\" y=\"{}\" r=\"20\">",
-                    b.b1.x,
-                    b.b1.y,
-                    b.b2.x,
-                    b.b1.y,
-                    b.b2.x,
-                    b.b2.y,
-                    b.b1.x,
-                    b.b2.y,
-                    b.area,
-                    p.x,
-                    p.y
-                );
-
                 continue 'b2;
             }
         }
-        println!(
+        //
-            "<path style=\"fill:blue\" d=\"M{} {} L{} {} L{} {} L{} {}\" count=\"{}\">",
+        //		1        p
-            b.b1.x, b.b1.y, b.b2.x, b.b1.y, b.b2.x, b.b2.y, b.b1.x, b.b2.y, b.area
+        //
-        );
+        //
+        //		t        2
+        //
+        let p = TilePos {
+            x: b.b2.x,
+            y: b.b1.y,
+        };
+        let t = TilePos {
+            x: b.b1.x,
+            y: b.b2.y,
+        };
+        let ray1 = Pair {
+            b1: b.b1,
+            b2: &p,
+            area: 0,
+        };
+        let ray2 = Pair {
+            b1: b.b1,
+            b2: &t,
+            area: 0,
+        };
+        let ray3 = Pair {
+            b1: b.b2,
+            b2: &p,
+            area: 0,
+        };
+        let ray4 = Pair {
+            b1: b.b2,
+            b2: &t,
+            area: 0,
+        };
+
+        for i in order_pair.iter() {
+            let ray1c = i.colide(&ray1)?;
+            let ray2c = i.colide(&ray2)?;
+            let ray3c = i.colide(&ray3)?;
+            let ray4c = i.colide(&ray4)?;
+            if ray1c || ray2c || ray3c || ray4c {
+                if b.area == 1550760868 {
+                    println!(
+                        "\n\n\np {} = {:?}\n\n{:?}\n{:?}\n\n{:?}\n{:?}",
+                        b.area, i, ray1, ray2, ray3, ray4
+                    );
+                    b.as_rect();
+                    i.as_line();
+                }
+                continue 'b2;
+            }
+        }
+
+        println!("sol2 = {} {:?}", b.area, b);
+        b.as_rect();
+        ray1.as_line();
+        ray2.as_line();
+        ray3.as_line();
+        ray4.as_line();
         break;
     }