Parallelize solutions + benchmarks

days/src/main/kotlin/Day18.kt

@@ -5,6 +5,8 @@ import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
 import be.vandewalleh.aoc.utils.input.createDay
 import java.util.*
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 enum class Operator { Add, Multiply }
 
@@ -13,10 +15,15 @@ operator fun Operator.invoke(a: Long, b: Long) = when (this) {
     Operator.Multiply -> a * b
 }
 
+private inline fun Logger.debug(msg: () -> Any) {
+    if (isDebugEnabled) debug(msg().toString())
+}
+
 @Day(18)
 class Day18(@Lines val input: Input<List<String>>) {
 
-    val lines = input.value.map { it.replace(" ", "") }
+    private val logger = LoggerFactory.getLogger("Day18")
+    private val lines = input.value.map { it.replace(" ", "") }
 
     private fun parseGroups(line: String): Map<Int, List<IntRange>> {
         var depth = 0
@@ -37,16 +44,15 @@ class Day18(@Lines val input: Input<List<String>>) {
             }
         }
 
-        check(openingPars.isEmpty())
-        return groups.also { println(it) }
+        return groups.also { logger.debug { it } }
     }
 
     private fun solveGroup(group: String, precedence: Boolean) = solveGroup(parseGroup(group), precedence)
 
     private fun solveGroup(group: Pair<LinkedList<Long>, LinkedList<Operator>>, precedence: Boolean): Long {
         val (operands, operators) = group
-        println(operands)
-        println(operators)
+        logger.debug { operands }
+        logger.debug { operators }
 
         if (!precedence) {
             for (i in operators.indices) {
@@ -64,19 +70,18 @@ class Day18(@Lines val input: Input<List<String>>) {
             var i = 0
             while (operators.any { it == Operator.Add }) {
 
-                val a = operands[i]
-                val b = operands[i + 1]
                 val operator = operators[i]
 
                 if (operator == Operator.Add) {
+                    val a = operands[i]
+                    val b = operands[i + 1]
                     val res = operator(a, b)
                     operands.removeAt(i)
                     operands[i] = res
                     operators.removeAt(i)
-                    i--
+                } else {
+                    i++
                 }
-
-                i++
             }
 
             return operands.reduce { a, b -> Operator.Multiply(a, b) }
@@ -105,8 +110,6 @@ class Day18(@Lines val input: Input<List<String>>) {
 
         operands.add(operand.toString().toLong())
 
-        check(operands.size == operators.size + 1)
-        check(operators.isNotEmpty())
         return Pair(operands, operators)
     }
 
@@ -117,7 +120,7 @@ class Day18(@Lines val input: Input<List<String>>) {
             val groups = parseGroups(l)
             if (groups.isEmpty()) break
 
-            val highestDepth = groups.keys.sorted().maxOrNull()!!
+            val highestDepth = groups.keys.maxOrNull()!!
             val solvableRanges = groups[highestDepth]!!
 
             val solved = ArrayDeque<Pair<IntRange, Long>>()
@@ -155,8 +158,17 @@ class Day18(@Lines val input: Input<List<String>>) {
         return solveGroup(l, precedence)
     }
 
-    fun part1() = lines.sumOf { solveLine(it) }
-    fun part2() = lines.sumOf { solveLine(it, precedence = true) }
+    fun part1() = lines
+        .parallelStream()
+        .map { solveLine(it) }
+        .reduce { t, u -> t + u }
+        .get()
+
+    fun part2() = lines
+        .parallelStream()
+        .map { solveLine(it, precedence = true) }
+        .reduce { t, u -> t + u }
+        .get()
 }
 
 fun main() = with(createDay<Day18>()) {