upload 2023 folder + utils + day 1 & 2 so far

Author: Matsemann

adventofcode2023/pom.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+
+    <name>adventofcode2023</name>
+
+    <groupId>com.matsemann</groupId>
+    <artifactId>adventofcode2023</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <kotlin.version>1.9.21</kotlin.version>
+
+        <kotlin.compiler.jvmTarget>21</kotlin.compiler.jvmTarget>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-stdlib-jdk8</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-test</artifactId>
+            <version>${kotlin.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-maven-plugin</artifactId>
+                <version>${kotlin.version}</version>
+                <extensions>true</extensions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

adventofcode2023/src/main/kotlin/com/matsemann/adventofcode2023/Day01.kt

@@ -0,0 +1,49 @@
+package com.matsemann.adventofcode2023
+
+import com.matsemann.adventofcode2023.utils.*
+
+fun day01_1(lines: List<String>): Any {
+    return lines
+        .map { it.split("").ints() }
+        .map { it.first().toString() + it.last().toString() }
+        .map { it.toInt() }
+        .sum()
+}
+
+
+fun day01_2(lines: List<String>): Any {
+    val replacements = listOf(
+        "one" to "1",
+        "two" to "2",
+        "three" to "3",
+        "four" to "4",
+        "five" to "5",
+        "six" to "6",
+        "seven" to "7",
+        "eight" to "8",
+        "nine" to "9"
+    )
+
+    return lines
+        .map {
+            // substitute => "one" to "one1one" etc (to survive eightwo otherwise being eigh2 after a replacement)
+            replacements.fold(it) { acc, pair ->
+                acc.replace(pair.first, pair.first + pair.second + pair.first)
+            }
+        }
+        // Then just use logic from part1
+        .map { it.split("").ints() }
+        .map { it.first().toString() + it.last().toString() }
+        .map { it.toInt() }
+        .sum()
+}
+
+fun main() {
+
+//    run("1", fileName = "day01_ex.txt", func = ::day01_1)
+    run("2", fileName = "day01_ex2.txt", func = ::day01_2)
+
+
+//    run("1", fileName = "day01.txt", func = ::day01_1)
+    run("2", fileName = "day01.txt", func = ::day01_2)
+}

adventofcode2023/src/main/kotlin/com/matsemann/adventofcode2023/Day02.kt

@@ -0,0 +1,53 @@
+package com.matsemann.adventofcode2023
+
+import com.matsemann.adventofcode2023.utils.*
+import kotlin.math.max
+
+data class CubeDraw(val r: Int, val g: Int, val b: Int)
+
+fun parseCubeDraws(lines: List<String>): List<Pair<Int, List<CubeDraw>>> {
+    return lines.map {
+        val spl = it.split(":")
+        val gameNr = spl[0].firstInt()
+
+        val draws = spl[1].split("; ").map { draw ->
+            val colors = draw.split(", ")
+            val r = colors.find { color -> color.contains("red") }?.firstInt() ?: 0
+            val g = colors.find { color -> color.contains("green") }?.firstInt() ?: 0
+            val b = colors.find { color -> color.contains("blue") }?.firstInt() ?: 0
+            CubeDraw(r, g, b)
+        }
+        gameNr to draws
+    }
+}
+
+fun day02_1(lines: List<String>): Any {
+    val limit = CubeDraw(12, 13, 14)
+
+    return parseCubeDraws(lines)
+        .filter {
+            it.second.all { draw ->
+                draw.r <= limit.r && draw.g <= limit.g && draw.b <= limit.b
+            }
+        }.sumOf { it.first }
+}
+
+
+fun day02_2(lines: List<String>): Any {
+    return parseCubeDraws(lines)
+        .sumOf { game ->
+            game.second.fold(CubeDraw(0, 0, 0)) { limit, draw ->
+                CubeDraw(max(limit.r, draw.r), max(limit.g, draw.g), max(limit.b, draw.b))
+            }.let { it.r * it.b * it.g }
+        }
+}
+
+fun main() {
+
+//    run("1", fileName = "day02_ex.txt", func = ::day02_1)
+    run("2", fileName = "day02_ex.txt", func = ::day02_2)
+
+
+//    run("1", fileName = "day02.txt", func = ::day02_1)
+    run("2", fileName = "day02.txt", func = ::day02_2)
+}

adventofcode2023/src/main/kotlin/com/matsemann/adventofcode2023/utils/CacheUtils.kt

@@ -0,0 +1,31 @@
+package com.matsemann.adventofcode2023.utils
+
+
+class Cached<I1, O>(val func: Cached<I1, O>.(I1) -> O) {
+    private val cache = mutableMapOf<I1, O>()
+
+    operator fun invoke(i: I1): O {
+        return if (i in cache) {
+            cache[i]!!
+        } else {
+            this.func(i).also {
+                cache[i] = it
+            }
+        }
+    }
+}
+
+class Cached2<I1, I2, O>(val func: Cached2<I1, I2, O>.(I1, I2) -> O) {
+    private val cache = mutableMapOf<Pair<I1, I2>, O>()
+
+    operator fun invoke(i1: I1, i2: I2): O {
+        val key = i1 to i2
+        return if (key in cache) {
+            cache[key]!!
+        } else {
+            this.func(i1, i2).also {
+                cache[key] = it
+            }
+        }
+    }
+}

adventofcode2023/src/main/kotlin/com/matsemann/adventofcode2023/utils/CombinationUtils.kt

@@ -0,0 +1,155 @@
+package com.matsemann.adventofcode2023.utils
+
+/**
+ * A general cartesian function, accepts any number of lists
+ * and returns a sequence. So it's lazy, only ever keeping
+ * the current product in memory when iterating through it
+ *
+ * cartesian([1,2], [a,b,c])
+ * => [(1,a), (1,b), (1,c), (2,a), (2,b), (2,c)]
+ */
+fun <E> cartesian(lists: List<List<E>>): Sequence<List<E>> {
+    return sequence {
+        val counters = Array(lists.size) { 0 }
+        val length = lists.fold(1) { acc, list -> acc * list.size }
+
+        for (i in 0 until length) {
+            val result = lists.mapIndexed { index, list ->
+                list[counters[index]]
+            }
+            yield(result)
+            for (pointer in lists.size - 1 downTo 0) {
+                counters[pointer]++
+                if (counters[pointer] == lists[pointer].size) {
+                    counters[pointer] = 0
+                } else {
+                    break
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Cartesian product of two lists,
+ * util for keeping typing
+ */
+fun <E, F> cartesian(list1: List<E>, list2: List<F>): Sequence<Pair<E, F>> =
+    cartesian(listOf(list1, list2)).map { it[0] as E to it[1] as F }
+
+/**
+ * Cartesian product of two lists,
+ * util for keeping typing
+ */
+@JvmName("cartesianExt")
+fun <E, F> List<E>.cartesian(list2: List<F>) = cartesian(this, list2)
+
+/**
+ * Cartesian product of three lists,
+ * util for keeping typing
+ */
+fun <E, F, G> cartesian(list1: List<E>, list2: List<F>, list3: List<G>): Sequence<Triple<E, F, G>> =
+    cartesian(listOf(list1, list2, list3)).map { Triple(it[0] as E, it[1] as F, it[2] as G) }
+
+
+/**
+ * All combinations of items in the list, of the given length.
+ * If length is not given, the length is the size of the list
+ * Similar to permutations, but order doesn't matter.
+ *
+ * [a, b, c], length=2 => [(a,b), (a,c), (b, c)]
+ * (while permutations would also have (b,a) for instance)
+ */
+fun <E> combinations(list: List<E>, length: Int? = null): Sequence<List<E>> {
+
+    return sequence {
+        val n = list.size
+        val r = length ?: list.size
+        // a b c d , 2
+        val counters = Array(r) { it } // 0,1
+        val maxes = Array(r) { it + n - r } // 2 3
+
+        yield(counters.map { list[it] })
+        while (true) {
+            val lastNotAtMax = counters.indices.findLast { counter ->
+                counters[counter] != maxes[counter]
+            } ?: return@sequence // All was at max
+
+            counters[lastNotAtMax]++
+
+            // Increase the others behind (that were one max)
+            for (toUpdate in lastNotAtMax + 1 until r) {
+                counters[toUpdate] = counters[toUpdate - 1] + 1
+            }
+
+            yield(counters.map { list[it] })
+
+
+        }
+
+    }
+
+}
+
+/**
+ * All possible permutations of the list for the given length.
+ * If length is not given, the length is the size of the list
+ *
+ * [a, b, c], length=2 =>
+ * [(a,b), (a,c), (b,a), (b,c), (c,a), (c,b)]
+ */
+fun <E> permutations(list: List<E>, length: Int? = null): Sequence<List<E>> = sequence {
+    val n = list.size
+    val r = length ?: list.size
+
+    val indices = list.indices.toMutableList()
+    val cycles = (n downTo (n - r)).toMutableList()
+    yield(indices.take(r).map { list[it] })
+
+    while (true) {
+        var broke = false
+        for (i in (r - 1) downTo 0) {
+            cycles[i]--
+            if (cycles[i] == 0) {
+                val end = indices[i]
+                for (j in i until indices.size - 1) {
+                    indices[j] = indices[j + 1]
+                }
+                indices[indices.size - 1] = end
+                cycles[i] = n - i
+            } else {
+                val j = cycles[i]
+                val tmp = indices[i]
+                indices[i] = indices[-j + indices.size]
+                indices[-j + indices.size] = tmp
+                yield(indices.take(r).map { list[it] })
+                broke = true
+                break
+            }
+        }
+        if (!broke) {
+            break
+        }
+    }
+}
+
+operator fun <E> Int.times(list: List<E>): List<List<E>> {
+    return List(this) { list }
+}
+
+@JvmName("timesMutable")
+operator fun <E> Int.times(list: MutableList<E>) =
+    MutableList(this) { list.toMutableList() }
+
+
+
+fun main() {
+    println(permutations(listOf("a", "b", "c")).toList())
+    println(permutations(listOf("a", "b", "c"), 2).toList())
+    println(permutations(listOf("a", "b", "c", "d"), 2).toList())
+    println(permutations(listOf("a", "b", "c", "d"), 2).map { it.toSet() }.toSet())
+    println()
+    println(combinations(listOf("a", "b", "c", "d"), 2).toList())
+    println()
+    println(cartesian(2 * listOf("a", "b", "c", "d")).toList())
+}