Solve 2025 day 9 part 2

Author: sim642

src/main/scala/eu/sim642/adventofcode2025/Day9.scala

@@ -2,17 +2,103 @@ package eu.sim642.adventofcode2025
 
 import eu.sim642.adventofcodelib.box.Box
 import eu.sim642.adventofcodelib.pos.Pos
+import eu.sim642.adventofcodelib.SeqImplicits.*
+import eu.sim642.adventofcodelib.graph.{BFS, GraphTraversal, UnitNeighbors}
+
+import scala.collection.immutable.SortedSet
+import scala.collection.mutable
 
 object Day9 {
 
-  def largestArea(redTiles: Seq[Pos]): Long = {
-    (for {
-      // faster than combinations(2)
-      (p1, i) <- redTiles.iterator.zipWithIndex
-      p2 <- redTiles.view.slice(i + 1, redTiles.size).iterator
-    } yield Box.bounding(Seq(p1, p2)).size[Long]).max
+  trait Part {
+    def largestArea(redTiles: Seq[Pos]): Long
+  }
+
+  object Part1 extends Part {
+    override def largestArea(redTiles: Seq[Pos]): Long = {
+      (for {
+        // faster than combinations(2)
+        (p1, i) <- redTiles.iterator.zipWithIndex
+        p2 <- redTiles.view.slice(i + 1, redTiles.size).iterator
+      } yield Box.bounding(Seq(p1, p2)).size[Long]).max
+    }
+  }
+
+  object Part2 extends Part {
+    override def largestArea(redTiles: Seq[Pos]): Long = {
+      // TODO: clean up
+      // TODO: optimize (with polygon checks?)
+      val xs = redTiles.map(_.x).distinct.sorted
+      val ys = redTiles.map(_.y).distinct.sorted
+      //println(xs)
+      //println(ys)
+
+      def mapPos(p: Pos): Pos =
+        Pos(xs.indexOf(p.x) * 2 + 1, ys.indexOf(p.y) * 2 + 1) // leave edge around for fill
+
+      val grid = mutable.ArraySeq.fill(ys.size * 2 - 1 + 2, xs.size * 2 - 1 + 2)('.')
+
+      for ((redTile1, redTile2) <- redTiles lazyZip redTiles.rotateLeft(1)) {
+        val gridPos1 = mapPos(redTile1)
+        val gridPos2 = mapPos(redTile2)
+        for (gridPos <- Box.bounding(Seq(gridPos1, gridPos2)).iterator)
+          grid(gridPos.y)(gridPos.x) = 'X'
+      }
+
+      for (redTile <- redTiles) {
+        val gridPos = mapPos(redTile)
+        //println((redTile, gridPos))
+        grid(gridPos.y)(gridPos.x) = '#'
+      }
+
+      //for (row <- grid) {
+      //  for (cell <- row)
+      //    print(cell)
+      //  println()
+      //}
+
+      val graphTraversal = new GraphTraversal[Pos] with UnitNeighbors[Pos] {
+        override val startNode: Pos = Pos.zero
+
+        override def unitNeighbors(pos: Pos): IterableOnce[Pos] =
+          Pos.axisOffsets.map(pos + _).filter(p => p.x >= 0 && p.y >= 0 && p.y < grid.size && p.x < grid(p.y).size && grid(p.y)(p.x) == '.')
+      }
+
+      val outside = BFS.traverse(graphTraversal).nodes
+
+      def isValid(box: Box): Boolean = {
+        val gridBox = Box(mapPos(box.min), mapPos(box.max))
+        !gridBox.iterator.exists(outside)
+      }
+
+      (for {
+        // faster than combinations(2)
+        (p1, i) <- redTiles.iterator.zipWithIndex
+        p2 <- redTiles.view.slice(i + 1, redTiles.size).iterator
+        box = Box.bounding(Seq(p1, p2))
+        if isValid(box)
+      } yield box.size[Long]).max
+    }
   }
 
+  /*object Part2 extends Part {
+    override def largestArea(redTiles: Seq[Pos]): Long = {
+
+      def isValid(box: Box): Boolean = {
+        val boxCorners = Seq(box.min, Pos(box.max.x, box.min.y), box.max, Pos(box.min.x, box.max.y))
+        ???
+      }
+
+      (for {
+        // faster than combinations(2)
+        (p1, i) <- redTiles.iterator.zipWithIndex
+        p2 <- redTiles.view.slice(i + 1, redTiles.size).iterator
+        box = Box.bounding(Seq(p1, p2))
+        if isValid(box)
+      } yield box.size[Long]).max
+    }
+  }*/
+
   def parseRedTile(s: String): Pos = s match {
     case s"$x,$y" => Pos(x.toInt, y.toInt)
   }
@@ -22,6 +108,7 @@ object Day9 {
   lazy val input: String = scala.io.Source.fromInputStream(getClass.getResourceAsStream("day9.txt")).mkString.trim
 
   def main(args: Array[String]): Unit = {
-    println(largestArea(parseRedTiles(input)))
+    println(Part1.largestArea(parseRedTiles(input)))
+    println(Part2.largestArea(parseRedTiles(input)))
   }
 }

src/test/scala/eu/sim642/adventofcode2025/Day9Test.scala

@@ -16,10 +16,18 @@ class Day9Test extends AnyFunSuite {
       |7,3""".stripMargin
 
   test("Part 1 examples") {
-    assert(largestArea(parseRedTiles(exampleInput)) == 50)
+    assert(Part1.largestArea(parseRedTiles(exampleInput)) == 50)
   }
 
   test("Part 1 input answer") {
-    assert(largestArea(parseRedTiles(input)) == 4729332959L)
+    assert(Part1.largestArea(parseRedTiles(input)) == 4729332959L)
+  }
+
+  test("Part 2 examples") {
+    assert(Part2.largestArea(parseRedTiles(exampleInput)) == 24)
+  }
+
+  ignore("Part 2 input answer") { // TODO: optimize (~8.5s)
+    assert(Part2.largestArea(parseRedTiles(input)) == 1474477524L)
   }
 }