1 files changed, 29 insertions, 26 deletions

diff --git a/src/Day03.kt b/src/Day03.kt
index c6acda4..c64da47 100644
--- a/src/Day03.kt
+++ b/src/Day03.kt
@@ -1,46 +1,49 @@
 fun main() {
     fun addLists(l1: List<Int>, l2: List<Int>): List<Int> = l1.zip(l2).map { it.first + it.second }
 
-    fun bitListToNumber(bitList: List<Int>): Int = bitList.reduce { acc, bit -> acc * 2 + bit }
+    fun valueOfBits(bitList: List<Int>): Int = bitList.reduce { acc, bit -> acc * 2 + bit }
 
-    fun binaryStringToBitList(binaryString: String): List<Int> = binaryString.toList().map { bit -> bit.toString().toInt() }
+    fun invertBits(bitList: List<Int>): List<Int> = bitList.map { bit -> 1 - bit }
 
     fun mostCommonBits(input: List<List<Int>>): List<Int> =
         input
             .reduce(::addLists)
-            .map { bit -> if (bit.toDouble() / input.size >= 0.5) { 1 } else { 0 } }
-
-    fun part1(input: List<String>): Int =
-        mostCommonBits(input.map(::binaryStringToBitList))
-            .let { gammaBits ->
-                val epsilonBits = gammaBits.map { bit -> 1 - bit }
+            .map { bit -> if (bit.toDouble() / input.size >= 0.5) 1 else 0 }
+
+    fun selectByBitCriteria(
+        input: List<List<Int>>,
+        comparisonCriteria: (currentList: List<List<Int>>) -> List<Int>
+    ): List<Int>? {
+        var list = input
+        var index = 0
+
+        while (list.size > 1 && index < list[0].size) {
+            list = list.filter { e -> e[index] == comparisonCriteria(list)[index] }
+            index += 1
+        }
 
-                return bitListToNumber(gammaBits) * bitListToNumber(epsilonBits)
-            }
+        return list.getOrNull(0)
+    }
 
-    fun part2(input: List<String>): Int {
-            var oxygenList = input.map(::binaryStringToBitList)
-            var oxygenIdx = 0
-            while (oxygenList.size > 1) {
-                oxygenList = oxygenList.filter { e -> e[oxygenIdx] == mostCommonBits(oxygenList)[oxygenIdx]}
-                oxygenIdx += 1
+    fun part1(input: List<List<Int>>): Int =
+        mostCommonBits(input)
+            .let { gammaBits ->
+                val epsilonBits = invertBits(gammaBits)
+                return valueOfBits(gammaBits) * valueOfBits(epsilonBits)
             }
 
-            var scrubberList = input.map(::binaryStringToBitList)
-            var scrubberIdx = 0
-            while (scrubberList.size > 1) {
-                scrubberList = scrubberList.filter { e -> e[scrubberIdx] != mostCommonBits(scrubberList)[scrubberIdx]}
-                scrubberIdx += 1
-            }
+    fun part2(input: List<List<Int>>): Int {
+        val oxygenRating = selectByBitCriteria(input) { mostCommonBits(it) }!!
+        val scrubberRating = selectByBitCriteria(input) { invertBits(mostCommonBits(it)) }!!
 
-            return bitListToNumber(oxygenList[0]) * bitListToNumber(scrubberList[0])
-        }
+        return valueOfBits(oxygenRating) * valueOfBits(scrubberRating)
+    }
 
-    val testInput = readInput("Day03_test")
+    val testInput = readInputAsBitLists("Day03_test")
     check(part1(testInput) == 198)
     check(part2(testInput) == 230)
 
-    val input = readInput("Day03")
+    val input = readInputAsBitLists("Day03")
     println(part1(input))
     println(part2(input))
 }