Refactoring Day 14 to use entropy to find the least random configuration of points to detect the tree

Author: jwcarman

src/main/kotlin/adventofcode/day14/RestroomRedoubt.kt

@@ -23,6 +23,8 @@ import adventofcode.util.lcmInt
 import adventofcode.util.occurrences
 import adventofcode.util.removeAll
 import adventofcode.util.splitsAsInt
+import kotlin.math.ln
+import kotlin.math.roundToInt
 
 
 data class Robot(val ray: Ray) {
@@ -50,13 +52,13 @@ fun List<Point2D>.safetyFactor(maxX: Int, maxY: Int): Int {
     val midY = maxY / 2
     return filter { it.x != midX && it.y != midY }
         .map { (x, y) ->
-        when {
-            x < midX && y < midY -> "1"
-            x > midX && y < midY -> "2"
-            x < midX && y > midY -> "3"
-            else -> "4"
+            when {
+                x < midX && y < midY -> "1"
+                x > midX && y < midY -> "2"
+                x < midX && y > midY -> "3"
+                else -> "4"
+            }
         }
-    }
         .occurrences()
         .values.reduce(Int::times)
 }
@@ -76,36 +78,25 @@ fun Set<Point2D>.printGrid(maxX: Int, maxY: Int) {
     println(grid)
 }
 
-fun String.findTree(): Long {
+fun List<Point2D>.calculateShannonEntropy(maxX: Int, maxY: Int, gridWidth: Int, gridHeight: Int): Double {
+    val cellWidth = maxX * 1.0 / gridWidth
+    val cellHeight = maxY * 1.0 / gridHeight
+    return groupBy { (x, y) -> Point2D((x / cellWidth).roundToInt(), (y / cellHeight).roundToInt()) }
+        .values
+        .map { it.size.toDouble() / size }
+        .sumOf { -it * ln(it) }
+}
+
+
+fun String.findTree(): Int {
     val robots = parseRobots()
     val maxX = robots.maxOf { it.ray.origin.x } + 1
     val maxY = robots.maxOf { it.ray.origin.y } + 1
+    val sequences = robots.map { it.points(maxX, maxY) }
 
-    val sequences = robots.map { it.points(maxX, maxY) }.toList()
-
-    var t = 1
-    val maxT = lcmInt(maxX, maxY)
-    var maxCount = 0
-    while (t <= maxT) {
-        val points = sequences.map { it.next() }.toSet()
-
-        val count = points.count { p -> setOf(p.northEast(), p.northWest(), p.southEast(), p.southWest()).any { it in points } }
-        if(count > maxCount) {
-            println("t = ${t}")
-            points.printGrid(maxX, maxY)
-            println()
-            maxCount = count
-        }
-        //if(points.groupBy { it.y }.values.any{it.size > 3}) {
-
-        //}
-//        while (points.size >= tree.size) {
-//            if (points.containsAll(tree)) {
-//                return t
-//            }
-//            points = points.filter { it.y > 0 }.map { it.north() }.toSet()
-//        }
-        t++
+    val minEntropyT = (1..lcmInt(maxX, maxY)).minBy { t ->
+        sequences.map { it.next() }.calculateShannonEntropy(maxX, maxY, 10, 10)
     }
-    return -1L
+    robots.map { it.move(minEntropyT, maxX, maxY) }.toSet().printGrid(maxX, maxY)
+    return minEntropyT
 }

src/main/kotlin/adventofcode/util/graph/Graph.kt

@@ -34,6 +34,9 @@ interface Graph<V : Any, E : Any> {
     fun dfs(start: V, end: V): List<V> = Graphs.dfs(start, end, ::neighbors)
     fun bfs(start: V, end: V): List<V> = Graphs.bfs(start, end, ::neighbors)
 
+    fun dfsTraversal(start: V): List<V> = Graphs.dfsTraversal(start, ::neighbors)
+    fun bfsTraversal(start: V): List<V> = Graphs.bfsTraversal(start, ::neighbors)
+
     fun reachable(start: V, maxSteps: Int) = Graphs.reachable(start, maxSteps, ::neighbors)
 
 }

src/main/kotlin/adventofcode/util/graph/Graphs.kt

@@ -40,7 +40,12 @@ object Graphs {
         val visited = mutableSetOf<V>()
         vertices.forEach { vertex -> dist[vertex] = Double.POSITIVE_INFINITY }
         dist[start] = 0.0
-        val queue = PriorityQueue { l: V, r: V -> compareDoubles(dist.getOrDefault(l, Double.MAX_VALUE), dist.getOrDefault(r, Double.MAX_VALUE)) }
+        val queue = PriorityQueue { l: V, r: V ->
+            compareDoubles(
+                dist.getOrDefault(l, Double.MAX_VALUE),
+                dist.getOrDefault(r, Double.MAX_VALUE)
+            )
+        }
         queue.add(start)
         while (queue.isNotEmpty()) {
             val vertex = queue.poll()
@@ -77,11 +82,19 @@ object Graphs {
     }
 
     fun <V> dfs(start: V, end: V, neighbors: (V) -> List<V>): List<V> {
-        return search(start, end, neighbors) { list, element -> list.add(0, element) }
+        return search(start, end, neighbors) { addFirst(it) }
     }
 
     fun <V> bfs(start: V, end: V, neighbors: (V) -> List<V>): List<V> {
-        return search(start, end, neighbors) { list, element -> list.add(element) }
+        return search(start, end, neighbors) { addLast(it) }
+    }
+
+    fun <V> dfsTraversal(start: V, neighbors: (V) -> List<V>): List<V> {
+        return traverse(start, neighbors) { addFirst(it) }
+    }
+
+    fun <V> bfsTraversal(start: V, neighbors: (V) -> List<V>): List<V> {
+        return traverse(start, neighbors) { addLast(it) }
     }
 
     fun <V> allPaths(start: V, end: V, neighbors: (V) -> List<V>): List<List<V>> {
@@ -101,7 +114,7 @@ object Graphs {
         return paths
     }
 
-    fun <V> connectedComponents(vertices:Set<V>, neighbors: (V) -> List<V>): List<Set<V>> {
+    fun <V> connectedComponents(vertices: Set<V>, neighbors: (V) -> List<V>): List<Set<V>> {
         val components = mutableListOf<Set<V>>()
         val visited = mutableSetOf<V>()
         vertices.forEach { vertex ->
@@ -114,17 +127,34 @@ object Graphs {
         return components
     }
 
+    private fun <V> traverse(
+        start: V,
+        neighbors: (V) -> List<V>,
+        append: MutableList<V>.(V) -> Unit
+    ): List<V> {
+        val visited = mutableSetOf(start)
+        val vertices = mutableListOf(start)
+        val traversal = mutableListOf<V>()
+        while (vertices.isNotEmpty()) {
+            val vertex = vertices.removeFirst()
+            traversal.add(vertex)
+            neighbors(vertex).filter { it !in visited }.forEach { neighbor ->
+                visited += neighbor
+                vertices.append(neighbor)
+            }
+        }
+        return traversal
+    }
+
     private fun <V> search(
         start: V,
         end: V,
         neighbors: (V) -> List<V>,
-        add: (MutableList<List<V>>, List<V>) -> Unit
+        append: MutableList<List<V>>.(List<V>) -> Unit
     ): List<V> {
         val visited = mutableSetOf<V>()
         visited += start
-        val paths = mutableListOf<List<V>>()
-        add(paths, listOf(start))
-
+        val paths = mutableListOf(listOf(start))
         while (paths.isNotEmpty()) {
             val path = paths.removeFirst()
             val terminus = path.last()
@@ -133,7 +163,7 @@ object Graphs {
             }
             neighbors(terminus).filter { it !in visited }.forEach { neighbor ->
                 visited += neighbor
-                add(paths, path + neighbor)
+                paths.append(path + neighbor)
             }
         }
         return listOf()

src/test/kotlin/adventofcode/Day14Test.kt

@@ -18,6 +18,7 @@ package adventofcode
 
 import adventofcode.day14.calculateSafetyFactorAt
 import adventofcode.day14.findTree
+import io.kotest.matchers.ints.shouldBeGreaterThan
 
 import io.kotest.matchers.shouldBe
 import org.junit.jupiter.api.Test
@@ -36,15 +37,15 @@ class Day14Test {
 
     @Test
     fun example2() {
-        calculatePart2(readExample2()) shouldBe -1
+        calculatePart2(readExample2()) shouldBeGreaterThan 0
     }
 
     @Test
     fun part2() {
-        calculatePart2(readInput()) shouldBe -1
+        calculatePart2(readInput()) shouldBe 7709
     }
 
     private fun calculatePart1(input: String): Int = input.calculateSafetyFactorAt(100)
 
-    private fun calculatePart2(input: String): Long = input.findTree()
+    private fun calculatePart2(input: String): Int = input.findTree()
 }

src/test/kotlin/adventofcode/util/graph/GraphsTest.kt

@@ -17,6 +17,7 @@
 package adventofcode.util.graph
 
 import adventofcode.util.geom.plane.Point2D
+import io.kotest.matchers.shouldBe
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 
@@ -40,7 +41,7 @@ class GraphsTest {
             Point2D(-1, 0),
             Point2D(0, -1)
         )
-
-        assertThat(Graphs.reachable(Point2D.origin()) {it.neighbors().filter { it in searchSpace }}).hasSize(5)
+        assertThat(Graphs.reachable(Point2D.origin()) { it.neighbors().filter { n -> n in searchSpace } }).hasSize(5)
     }
+
 }