Use the abstract AdventOfCode class in all solutions

This drastically reduces the amount of repeated code and makes most
functions in Utils.kt obsolete.

Author: rhaendel

.gitignore

@@ -3,7 +3,6 @@
 .kotlin/
 build
 src/input/**/*.txt
-!src/input/2024/ForTests.txt
 !src/input/2024/Day99.txt
 local.properties
 /.kotlintest/

src/input/2024/ForTests.txt

@@ -12,9 +12,9 @@ abstract class AdventOfCode<T>(val year: Int, val day: Int) {
     private val input = readInput()
 
     fun run(expectedPart1: T, expectedPart2: T) {
-        println("Day $day $year, part 1")
+        println("Day $day $year - ${this::class.simpleName} - part 1")
         printAndCheck(::part1, expectedPart1)
-        println("Day $day $year, part 2")
+        println("Day $day $year - ${this::class.simpleName} - part 2")
         printAndCheck(::part2, expectedPart2)
     }
 

src/main/kotlin/de/ronny_h/aoc/AdventOfCode.kt

@@ -2,50 +2,10 @@ package de.ronny_h.aoc.extensions
 
 import java.math.BigInteger
 import java.security.MessageDigest
-import kotlin.io.path.Path
-import kotlin.io.path.readText
-import kotlin.reflect.KSuspendFunction1
-import kotlin.time.TimedValue
-import kotlin.time.measureTimedValue
-
-/**
- * Reads lines from the given input txt file.
- */
-fun readInput(name: String) = Path("src/input/2024/$name.txt").readText().trim().lines()
 
 /**
  * Converts string to md5 hash.
  */
 fun String.md5() = BigInteger(1, MessageDigest.getInstance("MD5").digest(toByteArray()))
     .toString(16)
     .padStart(32, '0')
-
-fun printAndCheck(input: List<String>, block: (List<String>) -> Int, expected: Int) {
-    printAndCheck(measureTimedValue { block(input).toLong() }, expected.toLong())
-}
-
-fun printAndCheck(input: List<String>, block: (List<String>) -> Long, expected: Long) {
-    printAndCheck(measureTimedValue { block(input) }, expected)
-}
-
-fun printAndCheck(input: List<String>, block: (List<String>) -> String, expected: String) {
-    printAndCheck(measureTimedValue { block(input) }, expected)
-}
-
-suspend fun printAndCheck(input: List<String>, block: KSuspendFunction1<List<String>, Int>, expected: Int) {
-    printAndCheck(measureTimedValue { block(input).toLong() }, expected.toLong())
-}
-
-suspend fun printAndCheck(input: List<String>, block: KSuspendFunction1<List<String>, Long>, expected: Long) {
-    printAndCheck(measureTimedValue { block(input) }, expected)
-}
-
-private fun printAndCheck(result: TimedValue<Long>, expected: Long) {
-    println("result: ${result.value}, expected: $expected, took: ${result.duration}")
-    check(result.value == expected)
-}
-
-private fun printAndCheck(result: TimedValue<String>, expected: String) {
-    println("result: ${result.value}, expected: $expected, took: ${result.duration}")
-    check(result.value == expected)
-}

src/main/kotlin/de/ronny_h/aoc/extensions/Utils.kt

@@ -1,22 +1,11 @@
 package de.ronny_h.aoc.year24.day02
 
-import de.ronny_h.aoc.extensions.printAndCheck
-import de.ronny_h.aoc.extensions.readInput
+import de.ronny_h.aoc.AdventOfCode
 import kotlin.math.abs
 
-fun main() {
-    val day = "Day02"
-    val input = readInput(day)
-    val reports = RedNosedReports()
+fun main() = RedNosedReports().run(670, 700)
 
-    println("$day part 1")
-    printAndCheck(input, reports::part1, 670)
-
-    println("$day part 2")
-    printAndCheck(input, reports::part2, 700)
-}
-
-class RedNosedReports {
+class RedNosedReports : AdventOfCode<Int>(2024, 2) {
     fun parseReports(input: List<String>) = input
         .filter { it.isNotBlank() }
         .map { line ->
@@ -42,7 +31,7 @@ class RedNosedReports {
         }.component1()
     }
 
-    fun part1(input: List<String>) = parseReports(input)
+    override fun part1(input: List<String>) = parseReports(input)
         .map(::isSafeReport)
         .count { it }
 
@@ -56,7 +45,7 @@ class RedNosedReports {
         return false
     }
 
-    fun part2(input: List<String>) = parseReports(input)
+    override fun part2(input: List<String>) = parseReports(input)
         .map { isSafeReport(it) || isSafeReportWithOneLevelRemoved(it) }
         .count { it }
 

src/main/kotlin/de/ronny_h/aoc/year24/day02/RedNosedReports.kt

@@ -1,22 +1,11 @@
 package de.ronny_h.aoc.year24.day03
 
-import de.ronny_h.aoc.extensions.printAndCheck
-import de.ronny_h.aoc.extensions.readInput
+import de.ronny_h.aoc.AdventOfCode
 import kotlin.text.get
 
-fun main() {
-    val day = "Day03"
-    val input = readInput(day)
-    val mullItOver = MullItOver()
+fun main() = MullItOver().run(174960292, 56275602)
 
-    println("$day part 1")
-    printAndCheck(input, mullItOver::part1, 174960292)
-
-    println("$day part 2")
-    printAndCheck(input, mullItOver::part2, 56275602)
-}
-
-class MullItOver {
+class MullItOver : AdventOfCode<Int>(2024, 3) {
     private val mulRegex = """(?<mul>mul\((\d{1,3}),(\d{1,3})\))"""
     private val doRegex = """(?<do>do\(\))"""
     private val dontRegex = """(?<dont>don't\(\))"""
@@ -31,11 +20,11 @@ class MullItOver {
         .findAll(line)
         .sumOf(::multiply)
 
-    fun part1(input: List<String>): Int {
+    override fun part1(input: List<String>): Int {
         return input.sumOf(::findAndMultiply)
     }
 
-    fun part2(input: List<String>): Int {
+    override fun part2(input: List<String>): Int {
         var doIt = true
 
         return input

src/main/kotlin/de/ronny_h/aoc/year24/day03/MullItOver.kt

@@ -1,27 +1,16 @@
 package de.ronny_h.aoc.year24.day04
 
+import de.ronny_h.aoc.AdventOfCode
 import de.ronny_h.aoc.extensions.Grid
-import de.ronny_h.aoc.extensions.printAndCheck
-import de.ronny_h.aoc.extensions.readInput
 
-fun main() {
-    val day = "Day04"
-    val input = readInput(day)
-    val search = CeresSearch()
+fun main() = CeresSearch().run(2500, 1933)
 
-    println("$day part 1")
-    printAndCheck(input, search::part1, 2500)
-
-    println("$day part 2")
-    printAndCheck(input, search::part2, 1933)
-}
-
-class CeresSearch {
-    fun part1(input: List<String>): Int {
+class CeresSearch : AdventOfCode<Int>(2024, 4) {
+    override fun part1(input: List<String>): Int {
         return XMasGrid(input).searchForXMAS()
     }
 
-    fun part2(input: List<String>): Int {
+    override fun part2(input: List<String>): Int {
         return XMasGrid(input).searchForMASCross()
     }
 }

src/main/kotlin/de/ronny_h/aoc/year24/day04/CeresSearch.kt

@@ -1,22 +1,10 @@
 package de.ronny_h.aoc.year24.day05
 
-import de.ronny_h.aoc.extensions.printAndCheck
-import de.ronny_h.aoc.extensions.readInput
-import kotlin.collections.get
+import de.ronny_h.aoc.AdventOfCode
 
-fun main() {
-    val day = "Day05"
-    val input = readInput(day)
-    val queue = PrintQueue()
+fun main() = PrintQueue().run(6384, 5353)
 
-    println("$day part 1")
-    printAndCheck(input, queue::part1, 6384)
-
-    println("$day part 2")
-    printAndCheck(input, queue::part2, 5353)
-}
-
-class PrintQueue {
+class PrintQueue : AdventOfCode<Int>(2024, 5) {
     private fun parseRules(input: List<String>): List<Pair<Int, Int>> = input
         .takeWhile { it.contains("|") }
         .map {
@@ -31,15 +19,15 @@ class PrintQueue {
                 .map(String::toInt)
         }
 
-    fun part1(input: List<String>): Int {
+    override fun part1(input: List<String>): Int {
         val rules = parseRules(input)
         val updates = parseUpdates(input)
         val pageComparator = PageComparator(rules)
         val orderedUpdates = updates.filter { it == it.sortedWith(pageComparator) }
         return orderedUpdates.sumOf { it[it.size / 2] }
     }
 
-    fun part2(input: List<String>): Int {
+    override fun part2(input: List<String>): Int {
         val rules = parseRules(input)
         val updates = parseUpdates(input)
         val pageComparator = PageComparator(rules)

src/main/kotlin/de/ronny_h/aoc/year24/day05/PrintQueue.kt

@@ -1,30 +1,19 @@
 package de.ronny_h.aoc.year24.day06
 
+import de.ronny_h.aoc.AdventOfCode
 import de.ronny_h.aoc.extensions.Coordinates
 import de.ronny_h.aoc.extensions.Direction
 import de.ronny_h.aoc.extensions.Direction.NORTH
 import de.ronny_h.aoc.extensions.Grid
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.produce
-import de.ronny_h.aoc.extensions.printAndCheck
-import de.ronny_h.aoc.extensions.readInput
 import java.lang.Runtime.getRuntime
 import java.util.concurrent.atomic.AtomicInteger
 
-suspend fun main() {
-    val day = "Day06"
-    val input = readInput(day)
-    val guard = GuardGallivant()
+fun main() = GuardGallivant().run(4580, 1480)
 
-    println("$day part 1")
-    printAndCheck(input, guard::part1, 4580)
-
-    println("$day part 2")
-    printAndCheck(input, guard::part2, 1480)
-}
-
-class GuardGallivant {
-    fun part1(input: List<String>): Int {
+class GuardGallivant : AdventOfCode<Int>(2024, 6) {
+    override fun part1(input: List<String>): Int {
         val visited = mutableSetOf<Coordinates>()
         Lab(input).doTheGuardWalk { position, _ ->
             visited.add(position)
@@ -33,7 +22,7 @@ class GuardGallivant {
         return visited.size
     }
 
-    suspend fun part2(input: List<String>): Int {
+    override fun part2(input: List<String>): Int = runBlocking {
         val lab = Lab(input)
         val loopCount = AtomicInteger(0)
 
@@ -57,7 +46,7 @@ class GuardGallivant {
             }.awaitAll()
         }
 
-        return loopCount.get()
+        return@runBlocking loopCount.get()
     }
 }
 

src/main/kotlin/de/ronny_h/aoc/year24/day06/GuardGallivant.kt

@@ -1,34 +1,23 @@
 package de.ronny_h.aoc.year24.day07
 
-import de.ronny_h.aoc.extensions.printAndCheck
-import de.ronny_h.aoc.extensions.readInput
+import de.ronny_h.aoc.AdventOfCode
 import kotlin.math.pow
 
-fun main() {
-    val day = "Day07"
-    val input = readInput(day)
-    val repair = BridgeRepair()
+fun main() = BridgeRepair().run(1399219271639, 275791737999003)
 
-    println("$day part 1")
-    printAndCheck(input, repair::part1, 1399219271639)
-
-    println("$day part 2")
-    printAndCheck(input, repair::part2, 275791737999003)
-}
-
-class BridgeRepair {
+class BridgeRepair : AdventOfCode<Long>(2024, 7) {
     private fun parseEquations(input: List<String>) = input.map { line ->
         val (result, numbers) = line.split(": ")
         Equation(result.toLong(), numbers.split(" ").map(String::toLong))
     }
 
-    fun part1(input: List<String>) = parseEquations(input)
+    override fun part1(input: List<String>) = parseEquations(input)
         .map { it.checkSolvability(listOf(Long::plus, Long::times)) }
         .filter { it.solvable }
         .sumOf { it.result }
 
 
-    fun part2(input: List<String>) = parseEquations(input)
+    override fun part2(input: List<String>) = parseEquations(input)
         .map { it.checkSolvability(listOf(Long::plus, Long::times, ::concat)) }
         .filter { it.solvable }
         .sumOf { it.result }