Solved day04 part 2

Author: Gentleman1983

build.gradle

@@ -4,7 +4,7 @@ plugins {
 
 // project meta data
 group 'de.havox_design.aoc2023'
-version '0.4.2'
+version '0.4.4'
 
 // Switch to gradle "all" distribution.
 wrapper {

day04/README.md

@@ -48,3 +48,44 @@ each of the three matches after the first).
 So, in this example, the Elf's pile of scratchcards is worth **`13` points**.
 
 Take a seat in the large pile of colorful cards. **How many points are they worth in total**?
+
+# Part Two
+Just as you're about to report your findings to the Elf, one of you realizes that the rules have actually been printed 
+on the back of every card this whole time.
+
+There's no such thing as "points". Instead, scratchcards only cause you to **win more scratchcards** equal to the 
+number of winning numbers you have.
+
+Specifically, you win **copies** of the scratchcards below the winning card equal to the number of matches. So, if 
+card `10` were to have `5` matching numbers, you would win one copy each of cards `11`, `12`, `13`, `14`, and `15`.
+
+Copies of scratchcards are scored like normal scratchcards and have the **same card number** as the card they copied. 
+So, if you win a copy of card `10` and it has `5` matching numbers, it would then win a copy of the same cards that 
+the original card `10` won: cards `11`, `12`, `13`, `14`, and `15`. This process repeats until none of the copies 
+cause you to win any more cards. (Cards will never make you copy a card past the end of the table.)
+
+This time, the above example goes differently:
+```
+Card 1: 41 48 83 86 17 | 83 86  6 31 17  9 48 53
+Card 2: 13 32 20 16 61 | 61 30 68 82 17 32 24 19
+Card 3:  1 21 53 59 44 | 69 82 63 72 16 21 14  1
+Card 4: 41 92 73 84 69 | 59 84 76 51 58  5 54 83
+Card 5: 87 83 26 28 32 | 88 30 70 12 93 22 82 36
+Card 6: 31 18 13 56 72 | 74 77 10 23 35 67 36 11
+```
+* Card `1` has four matching numbers, so you win one copy each of the next four cards: cards `2`, `3`, `4`, and `5`.
+* Your original card `2` has two matching numbers, so you win one copy each of cards `3` and `4`.
+* Your copy of card `2` also wins one copy each of cards `3` and `4`.
+* Your four instances of card `3` (one original and three copies) have two matching numbers, so you win four copies 
+each of cards `4` and `5`.
+* Your eight instances of card `4` (one original and seven copies) have one matching number, so you win eight copies of 
+card `5`.
+* Your fourteen instances of card `5` (one original and thirteen copies) have no matching numbers and win no more cards.
+* Your one instance of card `6` (one original) has no matching numbers and wins no more cards.
+
+Once all of the originals and copies have been processed, you end up with `1` instance of card `1`, `2` instances of 
+card `2`, `4` instances of card `3`, `8` instances of card `4`, `14` instances of card `5`, and `1` instance of card 
+`6`. In total, this example pile of scratchcards causes you to ultimately have `30` scratchcards!
+
+Process all of the original and copied scratchcards until no more scratchcards are won. Including the original set of 
+scratchcards, **how many total scratchcards do you end up with**?

day04/src/main/kotlin/de/havox_design/aoc2023/day04/Day04.kt

@@ -7,8 +7,23 @@ class Day04(private var filename: String) {
             .map { ScratchCard.from(it) }
             .sumOf { it.scoreV1() }
 
-    fun solvePart2(): Long =
-        0L
+    fun solvePart2(): Long {
+        val cards = getResourceAsText(filename)
+            .filter(String::isNotBlank)
+            .map { ScratchCard.from(it) }
+
+        for (i in cards.indices) {
+            val winnings = cards[i]
+                .countMatching()
+            val originalCount = cards[i].count
+            for (w in 1..winnings) {
+                cards[i + w].count += originalCount
+            }
+        }
+
+        return cards
+            .sumOf { it.count }
+    }
 
     private fun getResourceAsText(path: String): List<String> =
         this.javaClass.classLoader.getResourceAsStream(path)!!.bufferedReader().readLines()

day04/src/main/kotlin/de/havox_design/aoc2023/day04/ScratchCard.kt

@@ -1,6 +1,6 @@
 package de.havox_design.aoc2023.day04
 
-data class ScratchCard(val winningNumbers: List<Int>, val playerNumbers: List<Int>) {
+data class ScratchCard(val winningNumbers: List<Int>, val playerNumbers: List<Int>, var count: Long = 1L) {
     fun scoreV1(): Long {
         var score = 0L
         playerNumbers
@@ -14,6 +14,9 @@ data class ScratchCard(val winningNumbers: List<Int>, val playerNumbers: List<In
         return score
     }
 
+    fun countMatching(): Int = playerNumbers
+        .count { it in winningNumbers }
+
     companion object {
         private const val NAME_END_DELIMITER: String = ":"
         private const val DATA_DELIMITER: String = "|"

day04/src/test/kotlin/de/havox_design/aoc2023/day04/Day04Test.kt

@@ -27,13 +27,13 @@ class Day04Test {
         @JvmStatic
         private fun getDataForTestSolvePart1(): Stream<Arguments> =
             Stream.of(
-                Arguments.of("part1sample.txt", 13L)
+                Arguments.of("sample.txt", 13L)
             )
 
         @JvmStatic
         private fun getDataForTestSolvePart2(): Stream<Arguments> =
             Stream.of(
-                Arguments.of("part2sample1.txt", 0L)
+                Arguments.of("sample.txt", 30L)
             )
     }
 }