Year 2025 Day 9

Author: maneatingape

README.md

@@ -85,6 +85,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 6 | [Trash Compactor](https://adventofcode.com/2025/day/6) | [Source](src/year2025/day06.rs) | 20 |
 | 7 | [Laboratories](https://adventofcode.com/2025/day/7) | [Source](src/year2025/day07.rs) | 5 |
 | 8 | [Playground](https://adventofcode.com/2025/day/8) | [Source](src/year2025/day08.rs) | 527 |
+| 9 | [Movie Theater](https://adventofcode.com/2025/day/9) | [Source](src/year2025/day09.rs) | 683 |
 
 ## 2024
 

benches/benchmark.rs

@@ -95,5 +95,5 @@ benchmark!(year2024
 );
 
 benchmark!(year2025
-    day01, day02, day03, day04, day05, day06, day07, day08
+    day01, day02, day03, day04, day05, day06, day07, day08, day09
 );

src/lib.rs

@@ -74,5 +74,5 @@ library!(year2024 "Locate the Chief Historian in time for the big Christmas slei
 );
 
 library!(year2025 "Finish the North Pole decorations in time for Christmas."
-    day01, day02, day03, day04, day05, day06, day07, day08
+    day01, day02, day03, day04, day05, day06, day07, day08, day09
 );

src/main.rs

@@ -141,5 +141,5 @@ run!(year2024
 );
 
 run!(year2025
-    day01, day02, day03, day04, day05, day06, day07, day08
+    day01, day02, day03, day04, day05, day06, day07, day08, day09
 );

src/year2025/day09.rs

@@ -0,0 +1,110 @@
+use crate::util::grid::*;
+use crate::util::hash::*;
+use crate::util::iter::*;
+use crate::util::parse::*;
+use crate::util::point::*;
+use std::collections::VecDeque;
+
+const OUTSIDE: i64 = 0;
+const INSIDE: i64 = 1;
+const UNKNOWN: i64 = 2;
+
+type Tile = [u64; 2];
+
+pub fn parse(input: &str) -> Vec<Tile> {
+    input.iter_unsigned::<u64>().chunk::<2>().collect()
+}
+
+pub fn part1(tiles: &[Tile]) -> u64 {
+    let mut area = 0;
+
+    for (i, &[x1, y1]) in tiles.iter().enumerate() {
+        for &[x2, y2] in tiles.iter().skip(i + 1) {
+            let dx = x1.abs_diff(x2) + 1;
+            let dy = y1.abs_diff(y2) + 1;
+            area = area.max(dx * dy);
+        }
+    }
+
+    area
+}
+
+pub fn part2(tiles: &[Tile]) -> u64 {
+    let size = tiles.len();
+
+    let mut xs: Vec<_> = tiles.iter().map(|&[x, _]| x).collect();
+    xs.push(0);
+    xs.push(u64::MAX);
+    xs.sort_unstable();
+    xs.dedup();
+
+    let mut ys: Vec<_> = tiles.iter().map(|&[_, y]| y).collect();
+    ys.push(0);
+    ys.push(u64::MAX);
+    ys.sort_unstable();
+    ys.dedup();
+
+    let shrink_x: FastMap<_, _> = xs.iter().enumerate().map(|(i, &x)| (x, i as i32)).collect();
+    let shrink_y: FastMap<_, _> = ys.iter().enumerate().map(|(i, &y)| (y, i as i32)).collect();
+    let shrunk: Vec<_> = tiles.iter().map(|&[x, y]| (shrink_x[&x], shrink_y[&y])).collect();
+
+    let mut area = 0;
+    let mut todo = VecDeque::from([ORIGIN]);
+    let mut grid = Grid::new(shrink_x.len() as i32, shrink_y.len() as i32, UNKNOWN);
+
+    for i in 0..size {
+        let (x1, y1) = shrunk[i];
+        let (x2, y2) = shrunk[(i + 1) % size];
+
+        for x in x1.min(x2)..=x1.max(x2) {
+            for y in y1.min(y2)..=y1.max(y2) {
+                grid[Point::new(x, y)] = INSIDE;
+            }
+        }
+    }
+
+    while let Some(point) = todo.pop_front() {
+        for next in ORTHOGONAL.map(|o| point + o) {
+            if grid.contains(next) && grid[next] == UNKNOWN {
+                grid[next] = OUTSIDE;
+                todo.push_back(next);
+            }
+        }
+    }
+
+    for y in 1..grid.height {
+        for x in 1..grid.width {
+            let point = Point::new(x, y);
+            let value = i64::from(grid[point] != OUTSIDE);
+            grid[point] = value + grid[point + UP] + grid[point + LEFT] - grid[point + UP + LEFT];
+        }
+    }
+
+    for i in 0..size {
+        for j in i + 1..size {
+            let (x1, y1) = shrunk[i];
+            let (x2, y2) = shrunk[j];
+
+            let x3 = x1.min(x2);
+            let x4 = x1.max(x2);
+            let y3 = y1.min(y2);
+            let y4 = y1.max(y2);
+
+            let expected = (x4 - x3 + 1) as i64 * (y4 - y3 + 1) as i64;
+            let actual = grid[Point::new(x4, y4)]
+                - grid[Point::new(x3 - 1, y4)]
+                - grid[Point::new(x4, y3 - 1)]
+                + grid[Point::new(x3 - 1, y3 - 1)];
+
+            if expected == actual {
+                let [x1, y1] = tiles[i];
+                let [x2, y2] = tiles[j];
+                let dx = x1.abs_diff(x2) + 1;
+                let dy = y1.abs_diff(y2) + 1;
+                area = area.max(dx * dy);
+            }
+        }
+    }
+
+    area
+}

tests/test.rs

@@ -87,5 +87,5 @@ test!(year2024
 );
 
 test!(year2025
-    day01, day02, day03, day04, day05, day06, day07, day08
+    day01, day02, day03, day04, day05, day06, day07, day08, day09
 );

tests/year2025/day09.rs

@@ -0,0 +1,23 @@
+use aoc::year2025::day09::*;
+
+const EXAMPLE: &str = "\
+7,1
+11,1
+11,7
+9,7
+9,5
+2,5
+2,3
+7,3";
+
+#[test]
+fn part1_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part1(&input), 50);
+}
+
+#[test]
+fn part2_test() {
+    let input = parse(EXAMPLE);
+    assert_eq!(part2(&input), 24);
+}