Refactor 2025 day 11 for alternative solutions

Author: sim642

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

@@ -5,48 +5,72 @@ import scala.collection.mutable
 object Day11 {
 
   type Device = String
+  type Devices = Map[Device, Seq[Device]]
 
-  trait Part {
+  trait PartDevices {
     val from: Device
     val via: Set[Device]
     val to: Device = "out"
-
-    def countPaths(devices: Map[Device, Seq[Device]]): Long = {
-      val memo = mutable.Map.empty[Device, Map[Set[Device], Long]]
-
-      def helper(device: Device): Map[Set[Device], Long] = {
-        memo.getOrElseUpdate(device, {
-          val deviceVia = via.intersect(Set(device))
-          if (device == to)
-            Map(deviceVia -> 1)
-          else
-            devices(device).flatMap(helper).groupMapReduce(_._1 ++ deviceVia)(_._2)(_ + _)
-        })
-      }
-
-      helper(from)(via)
-    }
   }
 
-  object Part1 extends Part {
+  trait Part1Devices extends PartDevices {
     override val from: Device = "you"
     override val via: Set[Device] = Set.empty
   }
 
-  object Part2 extends Part {
+  trait Part2Devices extends PartDevices {
     override val from: Device = "svr"
     override val via: Set[Device] = Set("dac", "fft")
   }
 
+  trait PartSolution extends PartDevices {
+    def countPaths(devices: Devices): Long
+  }
+
+  trait Solution {
+    val Part1: PartSolution
+    val Part2: PartSolution
+  }
+
+  /**
+   * Solution, which counts paths separately for subsets of visited vias.
+   */
+  object ViaMapSolution extends Solution {
+    trait ViaMapPartSolution extends PartSolution {
+      override def countPaths(devices: Devices): Long = {
+        val memo = mutable.Map.empty[Device, Map[Set[Device], Long]]
+
+        def helper(device: Device): Map[Set[Device], Long] = {
+          memo.getOrElseUpdate(device, {
+            val deviceVia = via.intersect(Set(device))
+            if (device == to)
+              Map(deviceVia -> 1)
+            else
+              devices(device).flatMap(helper).groupMapReduce(_._1 ++ deviceVia)(_._2)(_ + _)
+          })
+        }
+
+        helper(from)(via)
+      }
+    }
+
+    override object Part1 extends ViaMapPartSolution with Part1Devices
+    override object Part2 extends ViaMapPartSolution with Part2Devices
+  }
+
+  // TODO: path count product solution
+
   def parseDevice(s: String): (Device, Seq[Device]) = s match {
     case s"$key: $values" => key -> values.split(" ").toSeq
   }
 
-  def parseDevices(input: String): Map[Device, Seq[Device]] = input.linesIterator.map(parseDevice).toMap
+  def parseDevices(input: String): Devices = input.linesIterator.map(parseDevice).toMap
 
   lazy val input: String = scala.io.Source.fromInputStream(getClass.getResourceAsStream("day11.txt")).mkString.trim
 
   def main(args: Array[String]): Unit = {
+    import ViaMapSolution._
+
     println(Part1.countPaths(parseDevices(input)))
     println(Part2.countPaths(parseDevices(input)))
   }

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

@@ -1,9 +1,15 @@
 package eu.sim642.adventofcode2025
 
-import Day11._
+import Day11.*
+import Day11Test.*
+import org.scalatest.Suites
 import org.scalatest.funsuite.AnyFunSuite
 
-class Day11Test extends AnyFunSuite {
+class Day11Test extends Suites(
+  new ViaMapSolutionTest,
+)
+
+object Day11Test {
 
   val exampleInput =
     """aaa: you hhh
@@ -32,19 +38,23 @@ class Day11Test extends AnyFunSuite {
       |ggg: out
       |hhh: out""".stripMargin
 
-  test("Part 1 examples") {
-    assert(Part1.countPaths(parseDevices(exampleInput)) == 5)
-  }
+  abstract class SolutionTest(solution: Solution) extends AnyFunSuite {
+    test("Part 1 examples") {
+      assert(solution.Part1.countPaths(parseDevices(exampleInput)) == 5)
+    }
 
-  test("Part 1 input answer") {
-    assert(Part1.countPaths(parseDevices(input)) == 643)
-  }
+    test("Part 1 input answer") {
+      assert(solution.Part1.countPaths(parseDevices(input)) == 643)
+    }
 
-  test("Part 2 examples") {
-    assert(Part2.countPaths(parseDevices(exampleInput2)) == 2)
-  }
+    test("Part 2 examples") {
+      assert(solution.Part2.countPaths(parseDevices(exampleInput2)) == 2)
+    }
 
-  test("Part 2 input answer") {
-    assert(Part2.countPaths(parseDevices(input)) == 417190406827152L)
+    test("Part 2 input answer") {
+      assert(solution.Part2.countPaths(parseDevices(input)) == 417190406827152L)
+    }
   }
+
+  class ViaMapSolutionTest extends SolutionTest(ViaMapSolution)
 }