Refactor

Author: michaeltroger

src/Day8.kt

@@ -15,56 +15,61 @@ fun main() {
         parsedInput.forEach {
             val map = it.first().groupBy { it.length }.toSortedMap()
 
-            val one = map[2]!!.first()
-            val four = map[4]!!.first()
-            val seven = map[3]!!.first()
-            val eight = map[7]!!.first()
+            val segments = Array(10) { "" }
+
+            // 1, 4, 7, 8 have unique segment count
+            segments[1] = map[2]!!.first().sortAlphabetically()
+            segments[4] = map[4]!!.first().sortAlphabetically()
+            segments[7] = map[3]!!.first().sortAlphabetically()
+            segments[8] = map[7]!!.first().sortAlphabetically()
+
+            val digitsWith5Segments = map[5]!!.toMutableList() // 2, 3, 5 have 5 segments
 
-            val digitsWith5Segments = map[5]!!.toMutableList()
             // 3 =
-            val threeIndex = digitsWith5Segments.indexOfFirst { it.contains(one[0]) && it.contains(one[1]) }
-            val three = digitsWith5Segments.removeAt(threeIndex)
+            val threeIndex = digitsWith5Segments.indexOfFirst { it.contains(segments[1][0]) && it.contains(segments[1][1]) }
+            segments[3] = digitsWith5Segments.removeAt(threeIndex).sortAlphabetically()
 
             // 5 =
-            val fiveHint = four.replace(one[0].toString(), "").replace(one[1].toString(), "")
+            val fiveHint = segments[4].replace(segments[1][0].toString(), "").replace(segments[1][1].toString(), "")
             val fiveIndex = digitsWith5Segments.indexOfFirst { it.contains(fiveHint[0]) && it.contains(fiveHint[1]) }
-            val five = digitsWith5Segments.removeAt(fiveIndex)
+            segments[5] = digitsWith5Segments.removeAt(fiveIndex).sortAlphabetically()
 
             // 2 =
-            val two = digitsWith5Segments.first()
+            segments[2] = digitsWith5Segments.first().sortAlphabetically()
+
+            val digitsWith6Segments = map[6]!!.toMutableList() // 0, 6, 9 have 6 segments
 
-            val digitsWith6Segments = map[6]!!.toMutableList()
             // 6 =
-            val sixIndex = digitsWith6Segments.indexOfFirst { it.contains(one[0]) xor it.contains(one[1]) }
-            val six = digitsWith6Segments.removeAt(sixIndex)
+            val sixIndex = digitsWith6Segments.indexOfFirst { it.contains(segments[1][0]) xor it.contains(segments[1][1]) }
+            segments[6] = digitsWith6Segments.removeAt(sixIndex).sortAlphabetically()
 
             // 0
-            val zeroHint = eight
-                .replace(four[0].toString(), "")
-                .replace(four[1].toString(), "")
-                .replace(four[2].toString(), "")
-                .replace(four[3].toString(), "")
-                .replace(seven[0].toString(), "")
-                .replace(seven[1].toString(), "")
-                .replace(seven[2].toString(), "")
+            val zeroHint = segments[8]
+                .replace(segments[4][0].toString(), "")
+                .replace(segments[4][1].toString(), "")
+                .replace(segments[4][2].toString(), "")
+                .replace(segments[4][3].toString(), "")
+                .replace(segments[7][0].toString(), "")
+                .replace(segments[7][1].toString(), "")
+                .replace(segments[7][2].toString(), "")
             val zeroIndex = digitsWith6Segments.indexOfFirst { it.contains(zeroHint[0]) && it.contains(zeroHint[1]) }
-            val zero = digitsWith6Segments.removeAt(zeroIndex)
+            segments[0] = digitsWith6Segments.removeAt(zeroIndex).sortAlphabetically()
 
             // 9 =
-            val nine = digitsWith6Segments.first()
+            segments[9] = digitsWith6Segments.first().sortAlphabetically()
 
             val output = it[1].map {
-                    when (it.toCharArray().sorted().joinToString("")) {
-                        zero.toCharArray().sorted().joinToString("") -> 0
-                        one.toCharArray().sorted().joinToString("") -> 1
-                        two.toCharArray().sorted().joinToString("") -> 2
-                        three.toCharArray().sorted().joinToString("") -> 3
-                        four.toCharArray().sorted().joinToString("") -> 4
-                        five.toCharArray().sorted().joinToString("") -> 5
-                        six.toCharArray().sorted().joinToString("") -> 6
-                        seven.toCharArray().sorted().joinToString("") -> 7
-                        eight.toCharArray().sorted().joinToString("") -> 8
-                        nine.toCharArray().sorted().joinToString("") -> 9
+                    when (it.sortAlphabetically()) {
+                        segments[0] -> 0
+                        segments[1] -> 1
+                        segments[2] -> 2
+                        segments[3] -> 3
+                        segments[4] -> 4
+                        segments[5] -> 5
+                        segments[6] -> 6
+                        segments[7] -> 7
+                        segments[8] -> 8
+                        segments[9] -> 9
                         else -> throw Error()
                     }.toString()
 
@@ -85,3 +90,5 @@ fun main() {
     println(part2(input))
 }
 
+private fun String.sortAlphabetically() = toCharArray().sorted().joinToString("")
+