From 273204ca6bff4443da9ea6bdc45c952f99f77d92 Mon Sep 17 00:00:00 2001
From: Matej Focko <me@mfocko.xyz>
Date: Mon, 2 Dec 2024 16:07:45 +0100
Subject: [PATCH] day(01): convert to the solution using abstract class

Signed-off-by: Matej Focko <me@mfocko.xyz>
---
 src/Day01.kt | 71 +++++++++++++++++++++++++++-------------------------
 1 file changed, 37 insertions(+), 34 deletions(-)

diff --git a/src/Day01.kt b/src/Day01.kt
index dd8845a..c815cdb 100644
--- a/src/Day01.kt
+++ b/src/Day01.kt
@@ -1,44 +1,47 @@
-fun parseInput(inputType: String): Pair<MutableList<Int>, MutableList<Int>> =
-    readInput(1, inputType).fold(mutableListOf<Int>() to mutableListOf<Int>()) { (left, right), line ->
-        val nums = line.split(Regex("\\s+"))
+class Day01(
+    inputType: String,
+) : Day<Int, Int>() {
+    private val left: MutableList<Int>
+    private val right: MutableList<Int>
 
-        left.add(nums[0].toInt())
-        right.add(nums[1].toInt())
+    init {
+        val (left, right) =
+            readInput(
+                1,
+                inputType,
+            ).fold(mutableListOf<Int>() to mutableListOf<Int>()) { (left, right), line ->
+                val nums = line.split(Regex("\\s+"))
 
-        left to right
+                left.add(nums[0].toInt())
+                right.add(nums[1].toInt())
+
+                left to right
+            }
+
+        this.left = left
+        this.right = right
     }
 
-fun precompute(input: Pair<MutableList<Int>, MutableList<Int>>) {
-    input.first.sort()
-    input.second.sort()
-}
-
-fun part1(input: Pair<List<Int>, List<Int>>): Int =
-    input.first.zip(input.second).sumOf { (l, r) -> maxOf(l - r, r - l) }
-
-fun part2(input: Pair<List<Int>, List<Int>>): Int {
-    val (left, right) = input
-    val freqs = buildMap<Int, Int> {
-        right.forEach { it ->
-            put(it, 1 + getOrDefault(it, 0))
-        }
+    override fun precompute() {
+        left.sort()
+        right.sort()
     }
 
-    return left.sumOf { it -> it * freqs.getOrDefault(it, 0) }
+    override fun part1(): Int = left.zip(right).sumOf { (l, r) -> maxOf(l - r, r - l) }
+
+    override fun part2(): Int {
+        val freqs =
+            buildMap<Int, Int> {
+                right.forEach { it ->
+                    put(it, 1 + getOrDefault(it, 0))
+                }
+            }
+
+        return left.sumOf { it -> it * freqs.getOrDefault(it, 0) }
+    }
 }
 
 fun main() {
-    // Test of sample
-    val testInput = parseInput("sample")
-    precompute(testInput)
-
-    check(part1(testInput) == 11)
-    check(part2(testInput) == 31)
-
-    // Challenge input
-    val input = parseInput("input")
-    precompute(input)
-
-    part1(input).println()
-    part2(input).println()
+    Day01("sample").test(11, 31)
+    Day01("input").run()
 }