Merge branch 'release/15days2023'

0legg · 0legg · commit c1a286654303 · 2023-12-14T21:20:27.000-08:00
diff --git a/year2023/src/main/kotlin/net/olegg/aoc/year2023/day11/Day11.kt b/year2023/src/main/kotlin/net/olegg/aoc/year2023/day11/Day11.kt
@@ -0,0 +1,57 @@
+package net.olegg.aoc.year2023.day11
+
+import net.olegg.aoc.someday.SomeDay
+import net.olegg.aoc.utils.Vector2D
+import net.olegg.aoc.utils.pairs
+import net.olegg.aoc.year2023.DayOf2023
+
+/**
+ * See [Year 2023, Day 11](https://adventofcode.com/2023/day/11)
+ */
+object Day11 : DayOf2023(11) {
+  override fun first(): Any? {
+    return solve(2)
+  }
+
+  override fun second(): Any? {
+    return solve(1000000)
+  }
+
+  private fun solve(add: Long): Long {
+    val emptyRows = matrix.mapIndexedNotNull { index, row ->
+      index.takeIf { row.all { it == '.' } }
+    }
+    val emptyColumns = matrix.first().indices
+      .filter { column ->
+        matrix.all { it[column] == '.' }
+      }
+
+    val galaxies = matrix.flatMapIndexed { y, row ->
+      row.mapIndexedNotNull { x, c ->
+        if (c == '#') {
+          Vector2D(x, y)
+        } else {
+          null
+        }
+      }
+    }
+
+    return galaxies.pairs()
+      .map {
+        val dx = (minOf(it.first.x, it.second.x)..<maxOf(it.first.x, it.second.x))
+          .sumOf { x ->
+            if (x in emptyColumns) add else 1
+          }
+
+        val dy = (minOf(it.first.y, it.second.y)..<maxOf(it.first.y, it.second.y))
+          .sumOf { y ->
+            if (y in emptyRows) add else 1
+          }
+
+        dx + dy
+      }
+      .sum()
+  }
+}
+
+fun main() = SomeDay.mainify(Day11)
diff --git a/year2023/src/main/kotlin/net/olegg/aoc/year2023/day12/Day12.kt b/year2023/src/main/kotlin/net/olegg/aoc/year2023/day12/Day12.kt
@@ -0,0 +1,71 @@
+package net.olegg.aoc.year2023.day12
+
+import net.olegg.aoc.someday.SomeDay
+import net.olegg.aoc.utils.parseInts
+import net.olegg.aoc.utils.toPair
+import net.olegg.aoc.year2023.DayOf2023
+
+/**
+ * See [Year 2023, Day 12](https://adventofcode.com/2023/day/12)
+ */
+object Day12 : DayOf2023(12) {
+  private val DOTS = "\\.+".toRegex()
+  private val EMPTY = setOf('.', '?', null)
+  private val FILLED = setOf('#', '?')
+
+  override fun first(): Any? {
+    return lines
+      .map { line -> line.split(" ").toPair() }
+      .map { (line, counts) ->
+        line to counts.parseInts(",")
+      }
+      .sumOf { (line, counts) ->
+        count(line, counts)
+      }
+  }
+
+  override fun second(): Any? {
+    return lines
+      .map { line -> line.split(" ").toPair() }
+      .map { (line, counts) ->
+        line to counts.parseInts(",")
+      }
+      .map { (line, counts) ->
+        List(5) { line }.joinToString(separator = "?") to List(5) { counts }.flatten()
+      }
+      .sumOf { (line, counts) ->
+        count(line, counts)
+      }
+  }
+
+  private fun count(line: String, counts: List<Int>): Long {
+    val dyn = Array(counts.size + 1) { LongArray(line.length + 1) { 0 } }
+
+    dyn[0][line.length] = 1
+    line.withIndex()
+      .reversed()
+      .takeWhile { it.value != '#' }
+      .forEach { dyn[0][it.index] = 1 }
+
+    for (j in 1..counts.size) {
+      val count = counts[counts.size - j]
+      val fix = if (j == 1) 0 else 1
+      for (i in line.length - 1 downTo 0) {
+        if (line[i] in EMPTY) {
+          dyn[j][i] += dyn[j].getOrElse(i + 1) { 0 }
+        }
+        if (line[i] in FILLED) {
+          if (line.getOrNull(i - 1) in EMPTY &&
+            (i + 1..<i + count).all { line.getOrNull(it) in FILLED } &&
+            line.getOrNull(i + count) in EMPTY) {
+            dyn[j][i] += dyn[j - 1].getOrElse(i + count + fix) { 0 }
+          }
+        }
+      }
+    }
+
+    return dyn.last().first()
+  }
+}
+
+fun main() = SomeDay.mainify(Day12)
diff --git a/year2023/src/main/kotlin/net/olegg/aoc/year2023/day13/Day13.kt b/year2023/src/main/kotlin/net/olegg/aoc/year2023/day13/Day13.kt
@@ -0,0 +1,57 @@
+package net.olegg.aoc.year2023.day13
+
+import net.olegg.aoc.someday.SomeDay
+import net.olegg.aoc.year2023.DayOf2023
+
+/**
+ * See [Year 2023, Day 13](https://adventofcode.com/2023/day/13)
+ */
+object Day13 : DayOf2023(13) {
+  override fun first(): Any? {
+    val patterns = data.split("\n\n").map { pattern -> pattern.lines().map { it.toList() } }
+    val transposed = patterns.map { it.transpose() }
+
+    return transposed.sumOf { it.rowsBeforeReflection() } + 100 * patterns.sumOf { it.rowsBeforeReflection() }
+  }
+
+  override fun second(): Any? {
+    val patterns = data.split("\n\n").map { pattern -> pattern.lines().map { it.toList() } }
+    val transposed = patterns.map { it.transpose() }
+
+    return transposed.sumOf { it.rowsBeforeSmudge() } + 100 * patterns.sumOf { it.rowsBeforeSmudge() }
+  }
+
+  private fun List<List<Char>>.transpose(): List<List<Char>> {
+    return List(first().size) { row ->
+      List(size) { column -> this[column][row] }
+    }
+  }
+
+  private fun List<List<Char>>.rowsBeforeReflection(): Int {
+    val rev = asReversed()
+    for (i in 1..<size) {
+      val below = drop(i)
+      val above = rev.takeLast(i)
+
+      if (above.zip(below).all { (a, b) -> a == b }) {
+        return i
+      }
+    }
+    return 0
+  }
+
+  private fun List<List<Char>>.rowsBeforeSmudge(): Int {
+    val rev = asReversed()
+    for (i in 1..<size) {
+      val below = drop(i)
+      val above = rev.takeLast(i)
+
+      if (above.zip(below).sumOf { (a, b) -> a.zip(b).count { (ca, cb) -> ca != cb } } == 1) {
+        return i
+      }
+    }
+    return 0
+  }
+}
+
+fun main() = SomeDay.mainify(Day13)
diff --git a/year2023/src/main/kotlin/net/olegg/aoc/year2023/day14/Day14.kt b/year2023/src/main/kotlin/net/olegg/aoc/year2023/day14/Day14.kt
@@ -0,0 +1,75 @@
+package net.olegg.aoc.year2023.day14
+
+import net.olegg.aoc.someday.SomeDay
+import net.olegg.aoc.year2023.DayOf2023
+
+/**
+ * See [Year 2023, Day 14](https://adventofcode.com/2023/day/14)
+ */
+object Day14 : DayOf2023(14) {
+  override fun first(): Any? {
+    val shifted = matrix.transpose().shiftLeft()
+
+    return shifted.transpose().northLoad()
+  }
+
+  override fun second(): Any? {
+    val seen = mutableMapOf<List<List<Char>>, Int>()
+    val rev = mutableMapOf<Int, List<List<Char>>>()
+
+    var curr = matrix
+    var step = 0
+
+    while (curr !in seen){
+      rev[step] = curr
+      seen[curr] = step
+      step++
+      val north = curr.transpose().shiftLeft().transpose()
+      val west = north.shiftLeft()
+      val south = west.transpose().flip().shiftLeft().flip().transpose()
+      curr = south.flip().shiftLeft().flip()
+    }
+
+    val head = seen.getValue(curr)
+    val loop = step - head
+    val tail = (1000000000 - head) % loop
+
+    val final = rev.getValue(head + tail)
+
+    return final.northLoad()
+  }
+
+  private fun List<List<Char>>.transpose(): List<List<Char>> {
+    return List(first().size) { row ->
+      List(size) { column -> this[column][row] }
+    }
+  }
+
+  private fun List<List<Char>>.northLoad(): Int {
+    return mapIndexed { y, row ->
+      (size - y) * row.count { it == 'O' }
+    }.sum()
+  }
+
+  private fun List<List<Char>>.shiftLeft() = map { row ->
+    val total = StringBuilder()
+    val round = StringBuilder()
+    "#$row".reversed().forEach { char ->
+      when (char) {
+        '.' -> total.append(char)
+        'O' -> round.append(char)
+        '#' -> {
+          total.append(round).append(char)
+          round.setLength(0)
+        }
+      }
+    }
+
+    total.setLength(total.length - 1)
+    total.reverse().toList()
+  }
+
+  private fun List<List<Char>>.flip() = map { it.asReversed() }
+}
+
+fun main() = SomeDay.mainify(Day14)
diff --git a/year2023/src/main/kotlin/net/olegg/aoc/year2023/day15/Day15.kt b/year2023/src/main/kotlin/net/olegg/aoc/year2023/day15/Day15.kt
@@ -0,0 +1,59 @@
+package net.olegg.aoc.year2023.day15
+
+import net.olegg.aoc.someday.SomeDay
+import net.olegg.aoc.utils.toPair
+import net.olegg.aoc.year2023.DayOf2023
+import net.olegg.aoc.year2023.day15.Day15.Step.Companion.toStep
+
+/**
+ * See [Year 2023, Day 15](https://adventofcode.com/2023/day/15)
+ */
+object Day15 : DayOf2023(15) {
+  override fun first(): Any? {
+    return data.split(",").sumOf { step ->
+      step.hash()
+    }
+  }
+
+  override fun second(): Any? {
+    val steps = data.split(",").map { it.toStep() }
+
+    val boxes = List(256) { LinkedHashMap<String, Int>() }
+
+    steps.forEach { step ->
+      val index = step.label.hash()
+      when (step) {
+        is Step.Remove -> boxes[index].remove(step.label)
+        is Step.Add -> boxes[index][step.label] = step.value
+      }
+    }
+
+    return boxes.mapIndexed { box, lenses ->
+      (box + 1) * lenses.values.mapIndexed { index, value -> (index + 1) * value }.sum()
+    }.sum()
+  }
+
+  private fun String.hash() = fold(0) { acc, char -> (acc + char.code) * 17 % 256 }
+
+  sealed interface Step {
+    val label: String
+
+    data class Add(
+      override val label: String,
+      val value: Int,
+    ) : Step
+
+    data class Remove(
+      override val label: String,
+    ) : Step
+
+    companion object {
+      fun String.toStep() = when {
+        last() == '-' -> Remove(dropLast(1))
+        else -> split("=").toPair().let { Add(it.first, it.second.toInt()) }
+      }
+    }
+  }
+}
+
+fun main() = SomeDay.mainify(Day15)
