Solution 2015-15 (Science for Hungry People)

Author: rhaendel

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

@@ -31,6 +31,7 @@ fun <A, B> combinationsOf(first: List<A>, second: List<B>) = sequence {
 fun <E> permutationsOf(list: List<E>): Sequence<List<E>> = sequence {
     if (list.isEmpty()) {
         yield(emptyList())
+        return@sequence
     }
 
     for (i in list.indices) {
@@ -39,3 +40,20 @@ fun <E> permutationsOf(list: List<E>): Sequence<List<E>> = sequence {
         }
     }
 }
+
+/**
+ * @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]`.
+ */
+fun sequenceNumbersOfEqualSum(n: Int, sum: Int): Sequence<List<Int>> = sequence {
+    if (n == 1) {
+        yield(listOf(sum))
+        return@sequence
+    }
+
+    for (i in 0..sum) {
+        sequenceNumbersOfEqualSum(n - 1, sum - i).forEach { shorterList ->
+            yield(shorterList + i)
+        }
+    }
+}

src/main/kotlin/de/ronny_h/aoc/year2015/day15/ScienceForHungryPeople.kt

@@ -0,0 +1,72 @@
+package de.ronny_h.aoc.year2015.day15
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.sequenceNumbersOfEqualSum
+import kotlin.math.max
+
+fun main() = ScienceForHungryPeople().run(222870, 117936)
+
+class ScienceForHungryPeople : AdventOfCode<Int>(2015, 15) {
+
+    private val totalTeaspoons = 100
+    private val totalCalories = 500
+
+    override fun part1(input: List<String>): Int {
+        val ingredients = input.parseIngredients()
+        return sequenceNumbersOfEqualSum(ingredients.size, totalTeaspoons)
+            .map { totalScoreOf(ingredients, it) }
+            .max()
+    }
+
+    override fun part2(input: List<String>): Int {
+        val ingredients = input.parseIngredients()
+        return sequenceNumbersOfEqualSum(ingredients.size, totalTeaspoons)
+            .filter { calorieTotalOf(ingredients, it) == totalCalories }
+            .map { totalScoreOf(ingredients, it) }
+            .max()
+    }
+
+    private fun calorieTotalOf(ingredients: List<Ingredient>, teaspoons: List<Int>): Int =
+        ingredients.withIndex().sumOf {
+            it.value.calories * teaspoons[it.index]
+        }
+
+    private fun totalScoreOf(
+        ingredients: List<Ingredient>,
+        teaspoons: List<Int>
+    ): Int {
+        val sums = ingredients.foldIndexed(Ingredient(0, 0, 0, 0, 0)) { i, acc, ingredient ->
+            Ingredient(
+                capacity = acc.capacity + teaspoons[i] * ingredient.capacity,
+                durability = acc.durability + teaspoons[i] * ingredient.durability,
+                flavor = acc.flavor + teaspoons[i] * ingredient.flavor,
+                texture = acc.texture + teaspoons[i] * ingredient.texture,
+                calories = acc.calories + teaspoons[i] + ingredient.calories,
+            )
+        }.let {
+            Ingredient(
+                capacity = max(it.capacity, 0),
+                durability = max(it.durability, 0),
+                flavor = max(it.flavor, 0),
+                texture = max(it.texture, 0),
+                calories = max(it.calories, 0),
+            )
+        }
+        return sums.capacity * sums.durability * sums.flavor * sums.texture
+    }
+}
+
+fun List<String>.parseIngredients() = this.map {
+    val (capacity, durability, flavor, texture, calories) = it.substringAfter(": ").split(", ")
+    Ingredient(
+        capacity = capacity.secondAsInt(),
+        durability = durability.secondAsInt(),
+        flavor = flavor.secondAsInt(),
+        texture = texture.secondAsInt(),
+        calories = calories.secondAsInt(),
+    )
+}
+
+private fun String.secondAsInt(): Int = split(" ")[1].toInt()
+
+data class Ingredient(val capacity: Int, val durability: Int, val flavor: Int, val texture: Int, val calories: Int)

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

@@ -82,4 +82,23 @@ class CombinationsTest : StringSpec({
             permutationsOf(input).toList() shouldContainExactlyInAnyOrder permutations
         }
     }
+
+    "sequenceNumbersOfEqualSum(n, sum) yields all lists of 'n' elements with a sum of 'sum'" {
+        forAll(
+            row(1, 100, listOf(listOf(100))),
+            row(2, 1, listOf(listOf(1, 0), listOf(0, 1))),
+            row(2, 2, listOf(listOf(2, 0), listOf(1, 1), listOf(0, 2))),
+            row(2, 3, listOf(listOf(3, 0), listOf(2, 1), listOf(1, 2), listOf(0, 3))),
+            row(
+                3, 3, listOf(
+                    listOf(3, 0, 0), listOf(2, 1, 0), listOf(1, 2, 0), listOf(0, 3, 0),
+                    listOf(2, 0, 1), listOf(1, 1, 1), listOf(0, 2, 1),
+                    listOf(1, 0, 2), listOf(0, 1, 2),
+                    listOf(0, 0, 3),
+                )
+            ),
+        ) { n, sum, expected ->
+            sequenceNumbersOfEqualSum(n, sum).toList() shouldBe expected
+        }
+    }
 })

src/test/kotlin/de/ronny_h/aoc/year2015/day15/ScienceForHungryPeopleTest.kt

@@ -0,0 +1,24 @@
+package de.ronny_h.aoc.year2015.day15
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class ScienceForHungryPeopleTest : StringSpec({
+
+    val input = listOf(
+        "Butterscotch: capacity -1, durability -2, flavor 6, texture 3, calories 8",
+        "Cinnamon: capacity 2, durability 3, flavor -2, texture -1, calories 3",
+    )
+
+    "input can be parsed" {
+        input.parseIngredients() shouldBe listOf(Ingredient(-1, -2, 6, 3, 8), Ingredient(2, 3, -2, -1, 3))
+    }
+
+    "part 1: The total score of the highest-scoring cookie with two ingredients" {
+        ScienceForHungryPeople().part1(input) shouldBe 62842880
+    }
+
+    "part 2: The total score of the highest-scoring cookie with two ingredients with a calorie total of 500" {
+        ScienceForHungryPeople().part2(input) shouldBe 57600000
+    }
+})