2024-24 Refactoring

Author: jurisk

scala2/src/main/scala/jurisk/adventofcode/y2024/Advent24.scala

@@ -19,6 +19,9 @@ import mouse.all.booleanSyntaxMouse
 import scala.annotation.tailrec
 import scala.util.Random
 
+// Notes:
+// - I actually solved this by simplifying the output DOT file and then finding irregularities manually.
+// - Later, I tried to apply a genetic algorithm, but failed to get this to converge.
 object Advent24 extends IOApp.Simple {
   private val InputBits  = 45
   private val OutputBits = InputBits + 1
@@ -139,9 +142,9 @@ object Advent24 extends IOApp.Simple {
 
     def foreach(f: Connection => Unit): Unit = map.values foreach f
 
-    private def errorsOnAddition: Int =
+    private def errorsOnAddition: Option[Int] =
       // We care more about `errorsBitByBit`, but since they didn't catch everything, we also care about `errorsOnRandomAddition`
-      128 * errorsBitByBit + errorsOnRandomAddition
+      isValid.option(128 * errorsBitByBit + errorsOnRandomAddition)
 
     private def errorsOnRandomAddition: Int = {
       val Samples = 16
@@ -238,7 +241,6 @@ object Advent24 extends IOApp.Simple {
         if (currentScore == 0) {
           (current, currentSwaps)
         } else {
-          // TODO: Try to apply Genetic Algorithm or similar...
           // Note: The swaps for our data are:
           // 1. hbk <-> z14
           // 2. kvn <-> z18
@@ -256,7 +258,7 @@ object Advent24 extends IOApp.Simple {
             if swapped.isValid
           } yield (swap, swapped))
             .map { case (swap, c) =>
-              (c, c.errorsOnAddition, swap)
+              (c, c.errorsOnAddition.orFail("Failed to get errors"), swap)
             }
             .minBy { case (_, score, _) => score } match {
             case (c, score, swap) if score < currentScore =>
@@ -268,7 +270,7 @@ object Advent24 extends IOApp.Simple {
         }
       }
 
-      f(this, errorsOnAddition, Set.empty)
+      f(this, errorsOnAddition.orFail("Failed"), Set.empty)
     }
   }
 

scala2/src/main/scala/jurisk/algorithms/graph/KargersMinCuts.scala

@@ -4,7 +4,6 @@ import jurisk.collections.immutable.SetOfTwo
 import jurisk.collections.immutable.graph.Graph
 import jurisk.collections.immutable.graph.Graph.VertexId
 import jurisk.collections.mutable.DisjointSets
-import jurisk.utils.CollectionOps.VectorOps
 
 import scala.annotation.tailrec
 import scala.util.Random

scala2/src/main/scala/jurisk/optimization/GeneticAlgorithm.scala

@@ -0,0 +1,59 @@
+package jurisk.optimization
+
+import scala.util.Random
+
+object GeneticAlgorithm {
+  private val Debug = false
+  private type Population[T] = Vector[T]
+
+  def geneticAlgorithm[Chromosome](
+    populationSize: Int,
+    fitnessFunction: Chromosome => Double,
+    crossover: (Chromosome, Chromosome) => (Chromosome, Chromosome),
+    mutate: Chromosome => Chromosome,
+    randomChromosome: () => Chromosome,
+    generations: Int,
+  ): Chromosome = {
+    def evolve(population: Population[Chromosome]): Population[Chromosome] = {
+      val fitnessScores = population map fitnessFunction
+      val bestIndex     = fitnessScores.indexOf(fitnessScores.max)
+      val best          = population(bestIndex)
+      if (Debug) {
+        println(s"Best: $best with fitness ${fitnessScores(bestIndex)}")
+      }
+
+      Vector
+        .fill(populationSize / 2) {
+          val parent1          = selection(population, fitnessScores)
+          val parent2          = selection(population, fitnessScores)
+          val (child1, child2) = crossover(parent1, parent2)
+          Vector(mutate(child1), mutate(child2))
+        }
+        .flatten
+    }
+
+    def selection(
+      population: Population[Chromosome],
+      fitnessScores: Vector[Double],
+    ): Chromosome = {
+      val minFitness        = fitnessScores.min
+      val normalizedScores  = fitnessScores map (_ - minFitness)
+      val totalFitness      = normalizedScores.sum
+      val selectedValue     = Random.nextDouble() * totalFitness
+      val cumulativeFitness = normalizedScores.scanLeft(0.0)(_ + _).tail
+      val selectedIndex     = cumulativeFitness.indexWhere(_ >= selectedValue)
+      population(selectedIndex)
+    }
+
+    val initialPopulation = Vector.fill(populationSize)(randomChromosome())
+    val finalPopulation   = (1 to generations).foldLeft(initialPopulation) {
+      (pop, idx) =>
+        if (Debug) {
+          println(s"Generation $idx")
+        }
+        evolve(pop)
+    }
+
+    finalPopulation.maxBy(fitnessFunction)
+  }
+}

scala2/src/test/scala/jurisk/adventofcode/y2024/Advent24Spec.scala

@@ -19,7 +19,7 @@ class Advent24Spec extends AnyFreeSpec {
   }
 
   "part 2" - {
-    "real" in {
+    "real" ignore {
       part2(realData) shouldEqual "cvh,dbb,hbk,kvn,tfn,z14,z18,z23"
     }
   }

scala2/src/test/scala/jurisk/optimization/GeneticAlgorithmSpec.scala

@@ -0,0 +1,27 @@
+package jurisk.optimization
+
+import org.scalatest.freespec.AnyFreeSpec
+
+import scala.util.Random
+
+class GeneticAlgorithmSpec extends AnyFreeSpec {
+  "GeneticAlgorithm" - {
+    "should find the maximum of a simple function" in {
+      val result = GeneticAlgorithm.geneticAlgorithm(
+        populationSize = 100,
+        fitnessFunction = (x: Double) => -1 * x * x + 2 * x + 3,
+        crossover = (a: Double, b: Double) => {
+          val mid = (a + b) / 2
+          (mid, mid)
+        },
+        mutate = (x: Double) => x + Random.nextDouble() - 0.5,
+        randomChromosome = () => Random.nextDouble() * 10,
+        generations = 1000,
+      )
+
+      val Eps = 0.01
+      assert(result > 1 - Eps)
+      assert(result < 1 + Eps)
+    }
+  }
+}