Solved day07 part 2

Author: Gentleman1983

build.gradle

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

day07/README.md

@@ -78,3 +78,33 @@ with its rank (`765` * 1 + `220` * 2 + `28` * 3 + `684` * 4 + `483` * 5). So the
 **`6440`**.
 
 Find the rank of every hand in your set. **What are the total winnings**?
+
+# Part Two
+To make things a little more interesting, the Elf introduces one additional rule. Now, `J` cards are 
+[jokers](https://en.wikipedia.org/wiki/Joker_(playing_card)) - wildcards that can act like whatever card would make the 
+hand the strongest type possible.
+
+To balance this, **`J` cards are now the weakest** individual cards, weaker even than `2`. The other cards stay in the 
+same order: `A`, `K`, `Q`, `T`, `9`, `8`, `7`, `6`, `5`, `4`, `3`, `2`, `J`.
+
+`J` cards can pretend to be whatever card is best for the purpose of determining hand type; for example, `QJJQ2` is now 
+considered **four of a kind**. However, for the purpose of breaking ties between two hands of the same type, `J` is 
+always treated as `J`, not the card it's pretending to be: `JKKK2` is weaker than `QQQQ2` because `J` is weaker than 
+`Q`.
+
+Now, the above example goes very differently:
+```
+32T3K 765
+T55J5 684
+KK677 28
+KTJJT 220
+QQQJA 483
+```
+* `32T3K` is still the only **one pair**; it doesn't contain any jokers, so its strength doesn't increase.
+* `KK677` is now the only two pair, making it the second-weakest hand.
+* `T55J5`, `KTJJT`, and `QQQJA` are now all **four of a kind**! `T55J5` gets rank `3`, `QQQJA` gets rank `4`, and 
+`KTJJT` gets rank `5`.
+
+With the new joker rule, the total winnings in this example are **`5905`**.
+
+Using the new joker rule, find the rank of every hand in your set. **What are the new total winnings**?

day07/src/main/kotlin/de/havox_design/aoc2023/day07/Card.kt

@@ -1,30 +1,36 @@
 package de.havox_design.aoc2023.day07
 
-enum class Card(val symbol: Char, private val order: Int) {
-    TWO('2', 2),
-    THREE('3', 3),
-    FOUR('4', 4),
-    FIVE('5', 5),
-    SIX('6', 6),
-    SEVEN('7', 7),
-    EIGHT('8', 8),
-    NINE('9', 9),
-    TEN('T', 10),
-    JOKER('J', 11),
-    QUEEN('Q', 12),
-    KING('K', 13),
-    ACE('A', 14);
+enum class Card(val symbol: Char, private val orderPartOne: Int, private val orderPartTwo: Int) {
+    TWO('2', 2, 2),
+    THREE('3', 3, 3),
+    FOUR('4', 4, 4),
+    FIVE('5', 5, 5),
+    SIX('6', 6, 6),
+    SEVEN('7', 7, 7),
+    EIGHT('8', 8, 8),
+    NINE('9', 9, 9),
+    TEN('T', 10, 10),
+    JOKER('J', 11, 1),
+    QUEEN('Q', 12, 12),
+    KING('K', 13, 13),
+    ACE('A', 14, 14);
 
     companion object {
         fun from(c: Char): Card {
             if (entries.map { card -> card.symbol }.contains(c)) {
-                return entries.first { card -> card.symbol == c }
+                return entries
+                    .first { card -> card.symbol == c }
             }
 
             throw IllegalArgumentException("No knows card symbol '${c}'")
         }
 
-        fun compare(a: Card, b: Card): Int =
-            a.order.compareTo(b.order)
+        fun compare(a: Card, b: Card, partOne: Boolean): Int {
+            if (partOne) {
+                return a.orderPartOne.compareTo(b.orderPartOne)
+            }
+
+            return a.orderPartTwo.compareTo(b.orderPartTwo)
+        }
     }
 }

day07/src/main/kotlin/de/havox_design/aoc2023/day07/Day07.kt

@@ -3,26 +3,31 @@ package de.havox_design.aoc2023.day07
 class Day07(private var filename: String) {
     private val ELEMENT_DELIMITER = " "
 
-    fun solvePart1(): Long {
-        val data = mapInput(getResourceAsText(filename))
-        val sortedData = data.sortedBy { game -> game.first }.toList()
+    fun solvePart1(): Long =
+        process(true)
+
+    fun solvePart2(): Long =
+        process(false)
+
+    private fun process(isPartOne: Boolean): Long {
+        val data = mapInput(getResourceAsText(filename), isPartOne)
+        val sortedData = data
+            .sortedBy { game -> game.first }
+            .toList()
         var winnings = 0L
 
-        for(index in sortedData.indices) {
+        for (index in sortedData.indices) {
             winnings += (index + 1) * sortedData[index].second
         }
 
         return winnings
     }
 
-    fun solvePart2(): Long =
-        0L
-
-    private fun mapInput(input: List<String>):List<Pair<Hand,Int>> =
+    private fun mapInput(input: List<String>, isPartOne: Boolean): List<Pair<Hand, Int>> =
         input
             .map { row ->
                 val elements = row.split(ELEMENT_DELIMITER)
-                val hand = Hand.from(elements[0])
+                val hand = Hand.from(elements[0], isPartOne)
                 val bit = elements[1].toInt()
 
                 return@map Pair(hand, bit)

day07/src/main/kotlin/de/havox_design/aoc2023/day07/GameType.kt

@@ -10,46 +10,101 @@ enum class GameType(private var order: Int) {
     HIGH_CARD(0);
 
     companion object {
-        fun from(hand: Hand): GameType {
+        fun from(hand: Hand, isPartOne: Boolean): GameType {
+            if (isPartOne) {
+                return fromPartOne(hand)
+            }
+
+            return fromPartTwo(hand)
+        }
+
+        fun compare(a: GameType, b: GameType): Int =
+            a.order.compareTo(b.order)
+
+        private fun fromPartOne(hand: Hand): GameType {
             val cardMap = getCardMap(hand)
 
-            if(cardMap.size == 1) {
+            if (cardMap.size == 1) {
                 return FIVE_OF_A_KIND
             }
-            if(cardMap.size == 2) {
-                if(cardMap.values.max() == 4) {
+            if (cardMap.size == 2) {
+                if (cardMap.values.max() == 4) {
                     return FOUR_OF_A_KIND
                 }
                 return FULL_HOUSE
             }
-            if(cardMap.size == 3) {
-                if(cardMap.values.max() == 3) {
+            if (cardMap.size == 3) {
+                if (cardMap.values.max() == 3) {
                     return THREE_OF_A_KIND
                 }
                 return TWO_PAIRS
             }
-            if(cardMap.values.max() == 2) {
+            if (cardMap.values.max() == 2) {
                 return ONE_PAIR
             }
             return HIGH_CARD
         }
 
-        fun compare(a: GameType, b: GameType): Int =
-            a.order.compareTo(b.order)
+        private fun fromPartTwo(hand: Hand): GameType {
+            val numberOfJokers = getNumberOfJokers(hand)
+
+            if (numberOfJokers == 0) {
+                return fromPartOne(hand)
+            }
+
+            val cardMap = getCardMap(hand)
+                .filter { entry -> entry.key != Card.JOKER }
+
+
+            if (numberOfJokers == 5 || cardMap.values.max() + numberOfJokers == 5) {
+                return FIVE_OF_A_KIND
+            }
+            if (cardMap.values.max() + numberOfJokers == 4) {
+                return FOUR_OF_A_KIND
+            }
+            if (cardMap.values.max() + numberOfJokers >= 3) {
+                if (cardMap.size == 2 && numberOfJokers <= 1) {
+                    return FULL_HOUSE
+                }
+
+                return THREE_OF_A_KIND
+            }
+            if (cardMap.values.max() == 2 && numberOfJokers == 1) {
+                return TWO_PAIRS
+            }
+
+            if (numberOfJokers == 1) {
+                return ONE_PAIR
+            }
+
+            return HIGH_CARD
+        }
 
+        @SuppressWarnings("kotlin:S6611")
         private fun getCardMap(hand: Hand): Map<Card, Int> {
             val result = HashMap<Card, Int>()
 
-            for(c in hand.cards) {
-                if(result.containsKey(c)) {
+            for (c in hand.cards) {
+                if (result.containsKey(c)) {
                     result[c] = result[c]!! + 1
-                }
-                else {
+                } else {
                     result[c] = 1
                 }
             }
 
             return result
         }
+
+        private fun getNumberOfJokers(hand: Hand): Int {
+            var numberOfJokers = 0
+
+            for (c in hand.cards) {
+                if (c == Card.JOKER) {
+                    numberOfJokers++
+                }
+            }
+
+            return numberOfJokers
+        }
     }
 }

day07/src/main/kotlin/de/havox_design/aoc2023/day07/Hand.kt

@@ -1,35 +1,35 @@
 package de.havox_design.aoc2023.day07
 
-class Hand(val cards: List<Card>): Comparable<Hand> {
+class Hand(val cards: List<Card>, private val isPartOne: Boolean) : Comparable<Hand> {
     override fun compareTo(other: Hand): Int =
-        compare(this, other)
+        compare(this, other, isPartOne)
 
-    companion object{
-        fun from(input: String): Hand {
+    companion object {
+        fun from(input: String, isPartOne: Boolean): Hand {
             val hand = ArrayList<Card>()
 
-            for(c in input.toCharArray()) {
+            for (c in input.toCharArray()) {
                 hand.add(Card.from(c))
             }
 
-            return Hand(hand)
+            return Hand(hand, isPartOne)
         }
 
-        fun compare(a: Hand, b: Hand): Int {
-            if(a == b) {
+        fun compare(a: Hand, b: Hand, isPartOne: Boolean): Int {
+            if (a == b) {
                 return 0
             }
 
-            val aGameType = GameType.from(a)
-            val bGameType = GameType.from(b)
+            val aGameType = GameType.from(a, isPartOne)
+            val bGameType = GameType.from(b, isPartOne)
 
-            if(aGameType == bGameType) {
-                for(index in a.cards.indices) {
-                    if(a.cards[index] == b.cards[index]) {
+            if (aGameType == bGameType) {
+                for (index in a.cards.indices) {
+                    if (a.cards[index] == b.cards[index]) {
                         continue
                     }
 
-                    return Card.compare(a.cards[index], b.cards[index])
+                    return Card.compare(a.cards[index], b.cards[index], isPartOne)
                 }
             }
 

day07/src/test/kotlin/de/havox_design/aoc2023/day07/Day07Test.kt

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