Extracted some generic functions as utils.

Jadarma · Jadarma · commit 14f2c940655b · 2023-04-06T22:00:21.000+03:00
diff --git a/solutions/aockt/util/Collections.kt b/solutions/aockt/util/Collections.kt
@@ -0,0 +1,30 @@
+package aockt.util
+
+/**
+ * Generate a [Sequence] of permutations of this collection.
+ * For obvious reasons, will throw if the collection is too large.
+ */
+fun <T> Collection<T>.generatePermutations(): Sequence<List<T>> = when (size) {
+    !in 0 .. 9 -> throw Exception("Too many permutations. This is probably not what you want to use.")
+    0 -> emptySequence()
+    1 -> sequenceOf(this.toList())
+    else -> {
+        val first = first()
+        drop(1)
+            .generatePermutations()
+            .flatMap { perm -> (0..perm.size).map { perm.toMutableList().apply { add(it, first) } } }
+    }
+}
+
+/**
+ * Returns the power set of the collection (all possible unordered combinations) except it's a [List] and not a [Set]
+ * because repeated values are allowed.
+ */
+fun <T> Collection<T>.powerSet(): List<List<T>> = when (size) {
+    0 -> listOf(emptyList())
+    else -> {
+        val first = listOf(first())
+        val next = drop(1).powerSet()
+        next.map { first + it } + next
+    }
+}
diff --git a/solutions/aockt/y2015/Y2015D09.kt b/solutions/aockt/y2015/Y2015D09.kt
@@ -1,29 +1,10 @@
 package aockt.y2015
 
+import aockt.util.generatePermutations
 import io.github.jadarma.aockt.core.Solution
 
 object Y2015D09 : Solution {
 
-    // The code for generating permutations is a slightly refactored version of Marcin Moskala's implementation,
-    // because it's short and I want to keep dependencies to a minimum. Find the original at:
-    // https://github.com/MarcinMoskala/KotlinDiscreteMathToolkit/blob/17a7329af042c5de232051027ec1155011d57da8/src/main/java/com/marcinmoskala/math/PermutationsExt.kt#L20
-    // TODO: Make Util.
-    private fun <T> List<T>.permutations(): Set<List<T>> = when (size) {
-        0 -> emptySet()
-        1 -> setOf(take(1))
-        else -> drop(1)
-            .permutations()
-            .flatMap { sublist -> (0..sublist.size).map { sublist.plusAt(it, first()) } }
-            .toSet()
-    }
-
-    private fun <T> List<T>.plusAt(index: Int, element: T): List<T> = when (index) {
-        !in 0..size -> throw Error("Cannot put at index $index because size is $size")
-        0 -> listOf(element) + this
-        size -> this + element
-        else -> dropLast(size - index) + element + drop(index)
-    }
-
     private val inputRegex = Regex("""^(\w+) to (\w+) = (\d+)$""")
 
     /** Parses a single line of input and returns a triple containing two locations and the distance between them. */
@@ -36,7 +17,7 @@ object Y2015D09 : Solution {
      * Given a list of distances between all pairs of locations on the map, returns all possible paths that visit all
      * of them and their total distance.
      */
-    private fun bruteForceRoutes(locationData: List<Triple<String, String, Int>>): List<Pair<List<String>, Int>> {
+    private fun bruteForceRoutes(locationData: List<Triple<String, String, Int>>): Sequence<Pair<List<String>, Int>> {
         val locations = mutableSetOf<String>()
         val distances = mutableMapOf<Pair<String, String>, Int>()
 
@@ -49,7 +30,7 @@ object Y2015D09 : Solution {
 
         return locations
             .toList()
-            .permutations()
+            .generatePermutations()
             .map { route -> route to route.windowed(2).sumOf { distances.getValue(it[0] to it[1]) } }
     }
 
diff --git a/solutions/aockt/y2015/Y2015D13.kt b/solutions/aockt/y2015/Y2015D13.kt
@@ -1,29 +1,10 @@
 package aockt.y2015
 
+import aockt.util.generatePermutations
 import io.github.jadarma.aockt.core.Solution
 
 object Y2015D13 : Solution {
 
-    // The code for generating permutations is a slightly refactored version of Marcin Moskala's implementation,
-    // because it's short and I want to keep dependencies to a minimum. Find the original at:
-    // https://github.com/MarcinMoskala/KotlinDiscreteMathToolkit/blob/17a7329af042c5de232051027ec1155011d57da8/src/main/java/com/marcinmoskala/math/PermutationsExt.kt#L20
-    // TODO: Make Util.
-    private fun <T> List<T>.permutations(): Set<List<T>> = when (size) {
-        0 -> emptySet()
-        1 -> setOf(take(1))
-        else -> drop(1)
-            .permutations()
-            .flatMap { sublist -> (0..sublist.size).map { sublist.plusAt(it, first()) } }
-            .toSet()
-    }
-
-    private fun <T> List<T>.plusAt(index: Int, element: T): List<T> = when (index) {
-        !in 0..size -> throw Error("Cannot put at index $index because size is $size")
-        0 -> listOf(element) + this
-        size -> this + element
-        else -> dropLast(size - index) + element + drop(index)
-    }
-
     private val inputRegex = Regex("""^(\w+) would (lose|gain) (\d+) happiness units by sitting next to (\w+).$""")
 
     /**
@@ -44,7 +25,7 @@ object Y2015D13 : Solution {
     private fun bruteForceArrangement(
         guestData: List<Triple<String, String, Int>>,
         includeApatheticSelf: Boolean = false,
-    ): List<Pair<List<String>, Int>> {
+    ): Sequence<Pair<List<String>, Int>> {
         val guests = mutableSetOf<String>()
         val happinessScores = mutableMapOf<String, MutableMap<String, Int>>()
 
@@ -68,7 +49,7 @@ object Y2015D13 : Solution {
 
         return guests
             .toList()
-            .permutations()
+            .generatePermutations()
             .map { arrangement ->
                 arrangement to arrangement
                     .plusElement(arrangement.first())
diff --git a/solutions/aockt/y2015/Y2015D17.kt b/solutions/aockt/y2015/Y2015D17.kt
@@ -1,27 +1,14 @@
 package aockt.y2015
 
+import aockt.util.powerSet
 import io.github.jadarma.aockt.core.Solution
 
 object Y2015D17 : Solution {
 
-    /**
-     * Returns the power set of the [items] (all possible unordered combinations) except it's a [List] and not a [Set]
-     * because repeated values are allowed.
-     * TODO: Make Util.
-     */
-    private fun powerSet(items: List<Int>): List<List<Int>> = when (items.size) {
-        0 -> listOf(emptyList())
-        else -> {
-            val next = powerSet(items.drop(1))
-            val nextWithThis = next.map { listOf(items.first()) + it }
-            nextWithThis + next
-        }
-    }
-
     /** Parses the input and returns all valid ways of filling the containers. */
     private fun commonPart(input: String): List<List<Int>> = input
         .lines().map(String::toInt)
-        .let(this::powerSet)
+        .powerSet()
         .filter { it.sum() == 150 }
 
     override fun partOne(input: String) = commonPart(input).count()
diff --git a/tests/aockt/util/CollectionsUtilTest.kt b/tests/aockt/util/CollectionsUtilTest.kt
@@ -0,0 +1,58 @@
+package aockt.util
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.DisplayName
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder
+
+@DisplayName("Utils: Collections")
+class CollectionsUtilTest : FunSpec({
+
+    context("Permutations") {
+        test("generate simple permutations correctly") {
+            val list = listOf(1, 2, 3)
+            val permutations = listOf(
+                listOf(1, 2, 3),
+                listOf(1, 3, 2),
+                listOf(2, 1, 3),
+                listOf(2, 3, 1),
+                listOf(3, 1, 2),
+                listOf(3, 2, 1),
+            )
+
+            list.generatePermutations().toList() shouldContainExactlyInAnyOrder permutations
+        }
+
+        test("only work for small collections") {
+            val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
+            shouldThrow<Exception> { list.generatePermutations() }
+        }
+    }
+
+    context("Power Sets") {
+        test("generate simple power sets") {
+            val items = listOf(1, 2, 3)
+            val powerSet = listOf(
+                emptyList(),
+                listOf(1),
+                listOf(2),
+                listOf(3),
+                listOf(1, 2),
+                listOf(1, 3),
+                listOf(2, 3),
+                listOf(1, 2, 3),
+            )
+            items.powerSet().also(::println) shouldContainExactlyInAnyOrder powerSet
+        }
+        test("work with duplicate items") {
+            val items = listOf(1, 1)
+            val powerSet = listOf(
+                emptyList(),
+                listOf(1),
+                listOf(1),
+                listOf(1, 1),
+            )
+            items.powerSet().also(::println) shouldContainExactlyInAnyOrder powerSet
+        }
+    }
+})
