Complete day 12 part 2

diff --git a/src/day12.rs b/src/day12.rs
index a8fd4993cf0ebd74b5aa323df19597d491e75c56..cda944018066ed9c75bbe88c84f56a24c7fe0389 100644 (file)
--- a/src/day12.rs
+++ b/src/day12.rs
@@ -7,19 +7,19 @@ type Plot = char;
 struct Point(i32, i32);
 
 #[derive(Debug, Clone)]
-struct Region {
-    plots: HashSet<Point>,
-    plant: char,
+struct Region<T: Eq + Copy> {
+    points: HashSet<Point>,
+    content: T,
 }
 
-impl Region {
+impl<T: Eq + Copy> Region<T> {
     fn perimeter(&self) -> u64 {
-        self.plots
+        self.points
             .iter()
             .map(|p| {
                 4 - p
-                    .adjacent(i32::MAX.try_into().unwrap())
-                    .filter(|q| self.plots.contains(q))
+                    .adjacent_unchecked()
+                    .filter(|q| self.points.contains(q))
                     .count()
             })
             .sum::<usize>()
@@ -28,12 +28,53 @@ impl Region {
     }
 
     fn area(&self) -> u64 {
-        self.plots.len().try_into().unwrap()
+        self.points.len().try_into().unwrap()
+    }
+
+    fn sides(&self) -> u64 {
+        DIRS.iter()
+            .copied()
+            .map(|d| {
+                let ps: Vec<_> = self
+                    .points
+                    .iter()
+                    .copied()
+                    .map(move |p| p + d)
+                    .filter(|p| !self.points.contains(p))
+                    .collect();
+                let is: Vec<_> = ps.iter().copied().map(|Point(i, _)| i).collect();
+                let js: Vec<_> = ps.iter().copied().map(|Point(_, j)| j).collect();
+                let (imin, imax) = (is.iter().min(), is.iter().max());
+                let (jmin, jmax) = (js.iter().min(), js.iter().max());
+                let (&min, &max) = (imin.min(jmin).unwrap(), imax.max(jmax).unwrap());
+                let n: usize = (max - min).try_into().unwrap();
+                let mut map = Map::of(false, n + 1);
+                for p in ps {
+                    map[p - Point(min, min)] = true;
+                }
+                let v: u64 = map
+                    .regions()
+                    .filter(
+                        |&Region {
+                             points: _,
+                             content: c,
+                         }| c,
+                    )
+                    .count()
+                    .try_into()
+                    .unwrap();
+                v
+            })
+            .sum::<u64>()
     }
 
     fn price(&self) -> u64 {
         self.area() * self.perimeter()
     }
+
+    fn discount_price(&self) -> u64 {
+        self.area() * self.sides()
+    }
 }
 
 #[rustfmt::skip]
@@ -50,11 +91,13 @@ impl Point {
     }
 
     fn adjacent(self, bound: usize) -> impl Iterator<Item = Point> {
-        DIRS.iter()
-            .copied()
-            .map(move |d| d + self)
+        self.adjacent_unchecked()
             .filter(move |p| p.in_bounds(bound))
     }
+
+    fn adjacent_unchecked(self) -> impl Iterator<Item = Point> {
+        DIRS.iter().copied().map(move |d| self + d)
+    }
 }
 
 impl Add for Point {
@@ -103,35 +146,37 @@ impl<T> Map<T> {
     }
 }
 
-impl Map<Plot> {
-    fn regions(&self) -> MapRegions {
+impl<T: Eq + Copy> Map<T> {
+    fn regions(&self) -> MapRegions<T> {
         MapRegions::new(self)
     }
+
+    fn of(val: T, n: usize) -> Self {
+        Map(std::iter::repeat_with(|| vec![val; n]).take(n).collect())
+    }
 }
 
 #[derive()]
-struct MapRegions<'a> {
-    map: &'a Map<Plot>,
+struct MapRegions<'a, T: Eq + Copy> {
+    map: &'a Map<T>,
     seen: Map<bool>,
     iter: Vec<Point>,
     bound: usize,
 }
 
-impl<'a> MapRegions<'a> {
-    fn new(map: &'a Map<Plot>) -> Self {
+impl<'a, T: Eq + Copy> MapRegions<'a, T> {
+    fn new(map: &'a Map<T>) -> Self {
         MapRegions {
             map,
-            seen: Map(std::iter::repeat_with(|| vec![false; map.0.len()])
-                .take(map.0.len())
-                .collect()),
+            seen: Map::of(false, map.0.len()),
             iter: map.points().collect(),
             bound: map.0.len(),
         }
     }
 }
 
-impl Iterator for MapRegions<'_> {
-    type Item = Region;
+impl<T: Eq + Copy> Iterator for MapRegions<'_, T> {
+    type Item = Region<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let mut p = self.iter.pop()?;
@@ -154,7 +199,10 @@ impl Iterator for MapRegions<'_> {
             }));
             points.extend(iterators.drain(..).flatten());
         }
-        Some(Region { plots, plant: c })
+        Some(Region {
+            points: plots,
+            content: c,
+        })
     }
 }
 
@@ -167,7 +215,10 @@ pub fn part1(input: &str) -> u64 {
 }
 
 pub fn part2(input: &str) -> u64 {
-    0
+    parse(input)
+        .regions()
+        .map(|r| r.discount_price())
+        .sum::<u64>()
 }
 
 #[cfg(test)]
@@ -226,7 +277,12 @@ mod test {
         assert_eq!(
             parse(TINY_INPUT)
                 .regions()
-                .map(|Region { plots: _, plant: c }| c)
+                .map(
+                    |Region {
+                         points: _,
+                         content: c,
+                     }| c
+                )
                 .collect::<Vec<_>>(),
             ['C', 'E', 'B', 'D', 'A'],
         )
@@ -241,14 +297,23 @@ mod test {
     }
 
     #[test]
-    #[ignore]
+    fn test_discount_price() {
+        assert_eq!(
+            parse(INPUT_STR)
+                .regions()
+                .map(|r| r.discount_price())
+                .sum::<u64>(),
+            1206
+        )
+    }
+
+    #[test]
     fn test_part1() {
-        assert_eq!(part1(&crate::input(0).unwrap()), 0)
+        assert_eq!(part1(&crate::input(12).unwrap()), 1433460)
     }
 
     #[test]
-    #[ignore]
     fn test_part2() {
-        assert_eq!(part2(&crate::input(0).unwrap()), 0)
+        assert_eq!(part2(&crate::input(12).unwrap()), 855082)
     }
 }