Solution 2015-17 (No Such Thing as Too Much)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/Combinations.kt

@@ -1,5 +1,7 @@
 package de.ronny_h.aoc.extensions
 
+import java.lang.Math.pow
+
 
 /**
  * @return All pairwise combinations of list elements without the reflexive ones.
@@ -41,6 +43,23 @@ fun <E> permutationsOf(list: List<E>): Sequence<List<E>> = sequence {
     }
 }
 
+fun <E> allSublistsOf(list: List<E>): Sequence<List<E>> = sequence {
+    // count a binary number with list.size digits from 0...0 to 1...1
+    var number = 0
+    while (number < pow(2.0, list.size.toDouble())) {
+        val sublist = ArrayList<E>(list.size)
+        val binary = number.toString(2).reversed()
+        // take the list elements at indices of the 1 bits
+        binary.forEachIndexed { i, bit ->
+            if (bit == '1') {
+                sublist.add(list[i])
+            }
+        }
+        yield(sublist)
+        number++
+    }
+}
+
 /**
  * @return A sequence of `List<Int>` where each list is of length [n] and its elements count from `0` to [sum] in such a way
  * that `sum(list[0], list[1], ... list[n-1]) == [sum]`.

src/main/kotlin/de/ronny_h/aoc/year2015/day17/NoSuchThingAsTooMuch.kt

@@ -0,0 +1,33 @@
+package de.ronny_h.aoc.year2015.day17
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.allSublistsOf
+
+fun main() = NoSuchThingAsTooMuch().run(654, 0)
+
+class NoSuchThingAsTooMuch : AdventOfCode<Int>(2015, 17) {
+    override fun part1(input: List<String>): Int =
+        differentCombinationsToStore(input.map(String::toInt), 150)
+
+    override fun part2(input: List<String>): Int =
+        differentWaysToStoreWithMinimalNumberOfContainers(input.map(String::toInt), 150)
+}
+
+fun differentCombinationsToStore(containers: List<Int>, capacity: Int): Int =
+    allSublistsOf(containers).count { it.sum() == capacity }
+
+fun differentWaysToStoreWithMinimalNumberOfContainers(containers: List<Int>, capacity: Int): Int {
+    var minimalNumberOfContainers = containers.size
+    var count = 0
+    allSublistsOf(containers).forEach {
+        if (it.sum() == capacity) {
+            if (it.size < minimalNumberOfContainers) {
+                minimalNumberOfContainers = it.size
+                count = 1
+            } else if (it.size == minimalNumberOfContainers) {
+                count++
+            }
+        }
+    }
+    return count
+}

src/test/kotlin/de/ronny_h/aoc/extensions/CombinationsTest.kt

@@ -83,6 +83,22 @@ class CombinationsTest : StringSpec({
         }
     }
 
+    "allSublistsOf for lists with up to three elements" {
+        forAll(
+            row(emptyList(), listOf(emptyList())),
+            row(listOf(1), listOf(emptyList(), listOf(1))),
+            row(listOf(1, 2), listOf(emptyList(), listOf(1), listOf(2), listOf(1, 2))),
+            row(
+                listOf(1, 2, 3), listOf(
+                    emptyList(), listOf(1), listOf(2), listOf(1, 2),
+                    listOf(3), listOf(1, 3), listOf(2, 3), listOf(1, 2, 3)
+                )
+            ),
+        ) { list, expected ->
+            allSublistsOf(list).toList() shouldBe expected
+        }
+    }
+
     "sequenceNumbersOfEqualSum(n, sum) yields all lists of 'n' elements with a sum of 'sum'" {
         forAll(
             row(1, 100, listOf(listOf(100))),

src/test/kotlin/de/ronny_h/aoc/year2015/day17/NoSuchThingAsTooMuchTest.kt

@@ -0,0 +1,17 @@
+package de.ronny_h.aoc.year2015.day17
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class NoSuchThingAsTooMuchTest : StringSpec({
+
+    val input = listOf(20, 15, 10, 5, 5)
+
+    "part 1: number of combinations to store 25 litres of eggnog" {
+        differentCombinationsToStore(input, 25) shouldBe 4
+    }
+
+    "part 2: number of combinations to store 25 litres of eggnog with minimal number of containers" {
+        differentWaysToStoreWithMinimalNumberOfContainers(input, 25) shouldBe 3
+    }
+})