Year 2024 Day 12

Author: maneatingape

README.md

@@ -83,6 +83,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 9 | [Disk Fragmenter](https://adventofcode.com/2024/day/9) | [Source](src/year2024/day09.rs) | 106 |
 | 10 | [Hoof It](https://adventofcode.com/2024/day/10) | [Source](src/year2024/day10.rs) | 38 |
 | 11 | [Plutonian Pebbles](https://adventofcode.com/2024/day/11) | [Source](src/year2024/day11.rs) | 248 |
+| 12 | [Garden Groups](https://adventofcode.com/2024/day/12) | [Source](src/year2024/day12.rs) | 2901 |
 
 ## 2023
 

benches/benchmark.rs

@@ -303,4 +303,5 @@ mod year2024 {
     benchmark!(year2024, day09);
     benchmark!(year2024, day10);
     benchmark!(year2024, day11);
+    benchmark!(year2024, day12);
 }

src/lib.rs

@@ -302,4 +302,5 @@ pub mod year2024 {
     pub mod day09;
     pub mod day10;
     pub mod day11;
+    pub mod day12;
 }

src/main.rs

@@ -372,5 +372,6 @@ fn year2024() -> Vec<Solution> {
         solution!(year2024, day09),
         solution!(year2024, day10),
         solution!(year2024, day11),
+        solution!(year2024, day12),
     ]
 }

src/year2024/day12.rs

@@ -0,0 +1,133 @@
+//! # Garden Groups
+use crate::util::grid::*;
+use crate::util::hash::*;
+use crate::util::point::*;
+use std::collections::VecDeque;
+
+pub fn parse(input: &str) -> Grid<u8> {
+    Grid::parse(input)
+}
+
+pub fn part1(grid: &Grid<u8>) -> i32 {
+    let mut result = 0;
+    let mut todo = VecDeque::new();
+    let mut seen = grid.same_size_with(false);
+    let mut added = grid.same_size_with(false);
+
+    for y in 0..grid.height {
+        for x in 0..grid.width {
+            let point = Point::new(x, y);
+            if seen[point] {
+                continue;
+            }
+
+            let kind = grid[point];
+            let mut area = 0;
+            let mut perm = 0;
+
+            todo.push_back(point);
+            seen[point] = true;
+
+            while let Some(point) = todo.pop_front() {
+                area += 1;
+                perm += 4;
+                added[point] = true;
+
+                for next in ORTHOGONAL.map(|o| point + o) {
+                    if grid.contains(next) && grid[next] == kind {
+                        if !seen[next] {
+                            seen[next] = true;
+                            todo.push_back(next);
+                        }
+                        if added[next] {
+                            perm -= 2;
+                        }
+                    }
+                }
+            }
+
+            result += area * perm;
+        }
+    }
+
+    result
+}
+
+pub fn part2(grid: &Grid<u8>) -> u32 {
+    let mut result = 0;
+    let mut seen = grid.same_size_with(false);
+
+    for y in 0..grid.height {
+        for x in 0..grid.width {
+            let point = Point::new(x, y);
+            if !seen[point] {
+                result += flood_fill(grid, &mut seen, point);
+            }
+        }
+    }
+
+    result
+}
+
+fn flood_fill(grid: &Grid<u8>, seen: &mut Grid<bool>, start: Point) -> u32 {
+    let kind = grid[start];
+    let mut todo = VecDeque::new();
+
+    let mut corner = FastMap::new();
+    let mut middle = FastMap::new();
+
+    let mut size = 0;
+
+    todo.push_back(start);
+    seen[start] = true;
+
+    while let Some(point) = todo.pop_front() {
+        size += 1;
+
+        let x = 2 * point.x;
+        let y = 2 * point.y;
+
+        *corner.entry(Point::new(x, y)).or_insert(0) += 1;
+        *corner.entry(Point::new(x + 2, y)).or_insert(0) += 1;
+        *corner.entry(Point::new(x, y + 2)).or_insert(0) += 1;
+        *corner.entry(Point::new(x + 2, y + 2)).or_insert(0) += 1;
+
+        *middle.entry(Point::new(x + 1, y)).or_insert(0) += 1;
+        *middle.entry(Point::new(x, y + 1)).or_insert(0) += 1;
+        *middle.entry(Point::new(x + 2, y + 1)).or_insert(0) += 1;
+        *middle.entry(Point::new(x + 1, y + 2)).or_insert(0) += 1;
+
+        for next in ORTHOGONAL.map(|o| point + o) {
+            if grid.contains(next) && grid[next] == kind && !seen[next] {
+                seen[next] = true;
+                todo.push_back(next);
+            }
+        }
+    }
+
+    corner.retain(|_, v| *v < 4);
+    middle.retain(|_, v| *v < 2);
+    let mut sides = 0;
+
+    for &point in corner.keys() {
+        let mut count = 0;
+        let mut v1 = UP;
+        let mut v2 = RIGHT;
+
+        for _ in 0..4 {
+            if middle.contains_key(&(point + v1)) && middle.contains_key(&(point + v2)) {
+                count += 1;
+            }
+            v1 = v1.clockwise();
+            v2 = v2.clockwise();
+        }
+
+        if count == 1 {
+            sides += 1;
+        } else if count == 4 {
+            sides += 2;
+        }
+    }
+
+    size * sides
+}

tests/test.rs

@@ -292,4 +292,5 @@ mod year2024 {
     mod day09_test;
     mod day10_test;
     mod day11_test;
+    mod day12_test;
 }

tests/year2024/day12_test.rs

@@ -0,0 +1,35 @@
+use aoc::year2024::day12::*;
+
+const FIRST_EXAMPLE: &str = "\
+RRRRIICCFF
+RRRRIICCCF
+VVRRRCCFFF
+VVRCCCJFFF
+VVVVCJJCFE
+VVIVCCJJEE
+VVIIICJJEE
+MIIIIIJJEE
+MIIISIJEEE
+MMMISSJEEE";
+
+const SECOND_EXAMPLE: &str = "\
+AAAAAA
+AAABBA
+AAABBA
+ABBAAA
+ABBAAA
+AAAAAA";
+
+#[test]
+fn part1_test() {
+    let input = parse(FIRST_EXAMPLE);
+    assert_eq!(part1(&input), 1930);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(FIRST_EXAMPLE);
+    assert_eq!(part2(&input), 1206);
+    let input = parse(SECOND_EXAMPLE);
+    assert_eq!(part2(&input), 368);
+}