path
stringlengths 5
169
| owner
stringlengths 2
34
| repo_id
int64 1.49M
755M
| is_fork
bool 2
classes | languages_distribution
stringlengths 16
1.68k
⌀ | content
stringlengths 446
72k
| issues
float64 0
1.84k
| main_language
stringclasses 37
values | forks
int64 0
5.77k
| stars
int64 0
46.8k
| commit_sha
stringlengths 40
40
| size
int64 446
72.6k
| name
stringlengths 2
64
| license
stringclasses 15
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
src/year2015/day21/Day21.kt | lukaslebo | 573,423,392 | false | {"Kotlin": 222221} | package year2015.day21
import readInput
import kotlin.math.max
fun main() {
val input = readInput("2015", "Day21")
println(part1(input))
println(part2(input))
}
private fun part1(input: List<String>): Int {
val (bossInitialHP, bossDmg, bossArmor) = input.map { it.split(' ').last().toInt() }
val combinations = getEquipmentCombinations()
val cheapestWinningCombination = combinations.first { playerStats ->
fightBoss(playerStats, bossArmor, bossDmg, bossInitialHP)
}
return cheapestWinningCombination.cost
}
private fun part2(input: List<String>): Int {
val (bossInitialHP, bossDmg, bossArmor) = input.map { it.split(' ').last().toInt() }
val combinations = getEquipmentCombinations()
val mostExpensiveLosingCombination = combinations.last { playerStats ->
!fightBoss(playerStats, bossArmor, bossDmg, bossInitialHP)
}
return mostExpensiveLosingCombination.cost
}
private fun fightBoss(
playerStats: Stats,
bossArmor: Int,
bossDmg: Int,
bossInitialHP: Int,
playerInitialHP: Int = 100,
): Boolean {
var bossHP = bossInitialHP
var playerHP = playerInitialHP
val playerDmgPerRound = max(playerStats.damage - bossArmor, 1)
val bossDmgPerRound = max(bossDmg - playerStats.armor, 1)
while (bossHP > 0 && playerHP > 0) {
bossHP -= playerDmgPerRound
if (bossHP > 0) {
playerHP -= bossDmgPerRound
}
}
return playerHP > 0
}
private data class Stats(
val cost: Int,
val damage: Int,
val armor: Int,
) {
operator fun plus(other: Stats) = Stats(
cost = cost + other.cost,
damage = damage + other.damage,
armor = armor + other.armor,
)
}
private fun getEquipmentCombinations(): List<Stats> {
val weapons = listOf(
Stats(8, 4, 0),
Stats(10, 5, 0),
Stats(25, 6, 0),
Stats(40, 7, 0),
Stats(74, 8, 0),
)
val armors = listOf(
Stats(13, 0, 1),
Stats(31, 0, 2),
Stats(53, 0, 3),
Stats(75, 0, 4),
Stats(102, 0, 5),
)
val rings = listOf(
Stats(25, 1, 0),
Stats(50, 2, 0),
Stats(100, 3, 0),
Stats(20, 0, 1),
Stats(40, 0, 2),
Stats(80, 0, 3),
)
val combinations = HashSet(weapons)
combinations += armors.flatMap { armor -> combinations.map { armor + it } }
val ringCombos = rings.flatMap { ring -> rings.map { ring to it } }
.filter { it.first != it.second }
.map { it.first + it.second }
combinations += rings.flatMap { ring -> combinations.map { ring + it } } +
ringCombos.flatMap { ringCombo -> combinations.map { ringCombo + it } }
return combinations.sortedBy { it.cost }
} | 0 | Kotlin | 0 | 1 | f3cc3e935bfb49b6e121713dd558e11824b9465b | 2,756 | AdventOfCode | Apache License 2.0 |
src/2022/Day18.kt | ttypic | 572,859,357 | false | {"Kotlin": 94821} | package `2022`
import readInput
fun main() {
fun part1(input: List<String>): Int {
val drops = input.map {
val (x, y, z) = it.split(",").map(String::toInt)
Point3(x, y, z)
}.toSet()
return drops.sumOf { drop ->
drop.slideNeighbors().filter { !drops.contains(it) }.size
}
}
fun part2(input: List<String>): Int {
val drops = input.map {
val (x, y, z) = it.split(",").map(String::toInt)
Point3(x, y, z)
}.toSet()
val maxX = drops.maxOf { it.x }
val maxY = drops.maxOf { it.y }
val maxZ = drops.maxOf { it.z }
val minX = drops.minOf { it.x }
val minY = drops.minOf { it.y }
val minZ = drops.minOf { it.z }
return drops.sumOf { lavaDrop ->
lavaDrop.slideNeighbors().filter { !drops.contains(it) }.filter { airDrop ->
var freeAirDrops = airDrop.slideNeighbors().filter { !drops.contains(it) }.toSet()
val visitedDrops = mutableSetOf<Point3>()
do {
visitedDrops.addAll(freeAirDrops)
freeAirDrops = freeAirDrops.flatMap { it.slideNeighbors() }.filter { !drops.contains(it) && !visitedDrops.contains(it) }.toSet()
val isTrapped = freeAirDrops.all { it.x in minX..maxX && it.y in minY..maxY && it.z in minZ..maxZ}
} while (freeAirDrops.isNotEmpty() && isTrapped)
freeAirDrops.isNotEmpty()
}.size
}
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day18_test")
println(part1(testInput))
println(part2(testInput))
check(part1(testInput) == 64)
check(part2(testInput) == 58)
val input = readInput("Day18")
println(part1(input))
println(part2(input))
}
data class Point3(val x: Int, val y: Int, val z: Int)
fun Point3.slideNeighbors(): List<Point3> {
val (x, y, z) = this
return listOf(Point3(x - 1, y, z), Point3(x + 1, y, z), Point3(x, y - 1, z), Point3(x, y + 1, z), Point3(x, y, z - 1), Point3(x, y, z + 1))
}
| 0 | Kotlin | 0 | 0 | b3e718d122e04a7322ed160b4c02029c33fbad78 | 2,158 | aoc-2022-in-kotlin | Apache License 2.0 |
src/main/kotlin/nl/tiemenschut/aoc/y2023/day7.kt | tschut | 723,391,380 | false | {"Kotlin": 61206} | package nl.tiemenschut.aoc.y2023
import nl.tiemenschut.aoc.lib.dsl.aoc
import nl.tiemenschut.aoc.lib.dsl.day
import nl.tiemenschut.aoc.lib.dsl.parser.InputParser
import kotlin.math.pow
fun Char.toCardValue(jValue: Int): Int {
return when (this) {
'T' -> 10
'J' -> jValue
'Q' -> 12
'K' -> 13
'A' -> 14
else -> this.digitToInt()
}
}
data class Hand(val cards: List<Int>) {
fun score(): Int = ("${typeScore()}" + cards.joinToString("") { it.toString(16) }).toInt(16)
fun scoreWithJs(): Int {
if (cards.none { it == 1 }) return score()
val options = listOf(2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14)
val current = MutableList(cards.count { it == 1 }) { 0 }
current[current.size - 1] = -1
var max = typeScore()
do {
fun addOne(index: Int) {
if (index == -1) return
if (current[index] == options.size - 1) {
current[index] = 0
addOne(index - 1)
}
current[index] ++
}
addOne(current.size - 1)
val newCards = cards.toMutableList()
for (i in current.indices) {
newCards[newCards.indexOfFirst { it == 1 }] = options[current[i]]
}
max = max.coerceAtLeast(Hand(newCards).typeScore())
} while (current.any { it != options.size - 1 })
return ("$max" + cards.joinToString("") { it.toString(16) }).toInt(16)
}
private fun typeScore() = if (grouped.size == 1) 6
else if (grouped.maxBy { it.value }.value == 4) 5
else if (grouped.size == 2 && grouped.values.sorted() == listOf(2, 3)) 4
else if (grouped.size == 3 && grouped.values.sorted() == listOf(1, 1, 3)) 3
else if (grouped.size == 3 && grouped.values.sorted() == listOf(1, 2, 2)) 2
else if (grouped.size == 4) 1
else 0
private val grouped: Map<Int, Int> by lazy { cards.groupingBy { it }.eachCount() }
}
class HandsParser(private val jValue: Int) : InputParser<List<Pair<Hand, Int>>> {
override fun parse(input: String): List<Pair<Hand, Int>> = input.split("\n").map { line ->
val (hand, bid) = line.split(" ")
Hand(hand.map { it.toCardValue(jValue) }) to bid.toInt()
}
}
fun main() {
aoc {
puzzle { 2023 day 7 }
part1 { input ->
HandsParser(11).parse(input)
.sortedBy { it.first.score() }
.foldIndexed(0) { index, acc, pair ->
acc + (index + 1) * pair.second
}
}
part2 { input ->
HandsParser(1).parse(input)
.sortedBy { it.first.scoreWithJs() }
.foldIndexed(0) { index, acc, pair ->
acc + (index + 1) * pair.second
}
}
}
}
| 0 | Kotlin | 0 | 1 | a1ade43c29c7bbdbbf21ba7ddf163e9c4c9191b3 | 2,875 | aoc-2023 | The Unlicense |
src/com/kingsleyadio/adventofcode/y2023/Day11.kt | kingsleyadio | 435,430,807 | false | {"Kotlin": 134666, "JavaScript": 5423} | package com.kingsleyadio.adventofcode.y2023
import com.kingsleyadio.adventofcode.util.readInput
import java.util.*
fun main() {
part1()
part2()
}
private fun part1() = fastEvaluate(2)
private fun part2() = fastEvaluate(1_000_000)
private fun fastEvaluate(expansion: Int) {
val (world, planets) = buildModel(expansion)
var sumOfDistances = 0L
for (i in planets.indices) {
val planet = planets[i]
for (k in i + 1..planets.lastIndex) sumOfDistances += planet.fastDistanceTo(planets[k], world)
}
println(sumOfDistances)
}
private fun Index.fastDistanceTo(to: Index, world: List<IntArray>): Int {
val xDistance = (minOf(x, to.x) + 1..maxOf(x, to.x)).sumOf { xi -> world[minOf(y, to.y)][xi].coerceAtLeast(1) }
val yDistance = (minOf(y, to.y) + 1..maxOf(y, to.y)).sumOf { yi -> world[yi][minOf(x, to.x)].coerceAtLeast(1) }
return xDistance + yDistance
}
private fun evaluate(expansion: Int) {
val (world, planets) = buildModel(expansion)
var sumOfDistances = 0L
for (i in planets.indices) {
val planet = planets[i]
val paths = shortestPath(world, planet)
for (k in i + 1..planets.lastIndex) {
val second = planets[k]
sumOfDistances += paths[second.y][second.x]
}
}
println(sumOfDistances)
}
private fun shortestPath(world: List<IntArray>, start: Index): List<IntArray> {
val plane = List(world.size) { IntArray(world.size) { Int.MAX_VALUE } }
val queue = PriorityQueue<Path> { a, b -> a.cost - b.cost }
queue.offer(Path(start, 0))
while (queue.isNotEmpty()) {
val current = queue.poll()
val (to, cost) = current
if (plane[to.y][to.x] != Int.MAX_VALUE) continue
plane[to.y][to.x] = cost
sequence {
for (y in -1..1) for (x in -1..1) {
if (y != 0 && x != 0) continue
val point = Index(to.x + x, to.y + y)
val cell = plane.getOrNull(point.y)?.getOrNull(point.x) ?: continue
if (cell == Int.MAX_VALUE) yield(point)
}
}.forEach { point ->
val move = world[point.y][point.x].coerceAtLeast(1)
queue.add(Path(point, cost + move))
}
}
return plane
}
private fun buildModel(expansion: Int): Pair<List<IntArray>, List<Index>> {
return readInput(2023, 11, false).useLines { sequence ->
val world = arrayListOf<IntArray>()
for (line in sequence) {
val values = IntArray(line.length)
var space = 0
for (i in line.indices) {
val char = line[i]
val value = if (char == '#') 0 else 1
values[i] = value
if (value > 0) space++
}
if (space == values.size) for (i in values.indices) values[i] += expansion - 1
world.add(values)
}
for (i in world[0].indices) {
val allSpaces = world.all { it[i] > 0 }
if (allSpaces) for (j in world.indices) world[j][i] += expansion - 1
}
val planetIndices = arrayListOf<Index>()
for (j in world.indices) {
val row = world[j]
for (i in row.indices) {
val value = row[i]
if (value == 0) planetIndices.add(Index(i, j))
}
}
world to planetIndices
}
}
| 0 | Kotlin | 0 | 1 | 9abda490a7b4e3d9e6113a0d99d4695fcfb36422 | 3,393 | adventofcode | Apache License 2.0 |
src/Day04.kt | ktrom | 573,216,321 | false | {"Kotlin": 19490, "Rich Text Format": 2301} | fun main() {
fun part1(input: List<String>): Int {
return input.map { line ->
val intervals: List<IntRange> = transformIntoIntervals(line)
isSubInterval(intervals[0], intervals[1]) ||
isSubInterval(intervals[1], intervals[0])
}.sumOf {
var hasSubInterval = 0
if (it) {
hasSubInterval = 1
}
hasSubInterval
}
}
fun part2(input: List<String>): Int {
return input.map { line ->
val intervals: List<IntRange> = transformIntoIntervals(line)
overlap(intervals[0], intervals[1])
}.sumOf {
var hasOverlap = 0
if (it) {
hasOverlap = 1
}
hasOverlap
}
}
// test if implementation meets criteria from the description
val testInput = readInput("Day04_test")
println(part1(testInput) == 2)
val input = readInput("Day04")
println(part1(input))
println(part2(testInput) == 4)
println(part2(input))
}
// takes a string of the form "x1-y1, x2-y2" and returns list of corresponding
// int ranges, e.g. [[x1, y1 + 1], [x2, y2 + 1]]
fun transformIntoIntervals(line: String): List<IntRange> {
val ranges: List<String> = line.split(",")
val intervals: List<IntRange> = ranges.map {
val endpoints: List<Int> = it.split("-").map { it.toInt() }
endpoints[0] until endpoints[1] + 1
}
return intervals
}
// returns true if candidateSubInterval is a contained in interval
fun isSubInterval(candidateSubInterval: IntRange, interval: IntRange): Boolean {
return interval.first <= candidateSubInterval.first && candidateSubInterval.last <= interval.last
}
// returns true if the two ranges overlap
fun overlap(range: IntRange, other: IntRange): Boolean {
if (range.first < other.first) {
if (range.last >= other.first) {
return true
}
}
if (other.first < range.first) {
if (other.last >= range.first) {
return true
}
}
return isSubInterval(range, other) || isSubInterval(other, range)
}
| 0 | Kotlin | 0 | 0 | 6940ff5a3a04a29cfa927d0bbc093cd5df15cbcd | 1,882 | kotlin-advent-of-code | Apache License 2.0 |
src/Day08.kt | kmes055 | 577,555,032 | false | {"Kotlin": 35314} | import kotlin.math.max
fun main() {
fun List<Int>.determine(): List<Boolean> {
var curMax = -1
val asc = this.map { (it > curMax).apply { curMax = max(it, curMax) } }
curMax = -1
val desc = this.reversed().map { (it > curMax).apply { curMax = max(it, curMax) } }.reversed()
return (asc zip desc).map { (a, b) -> a or b }
}
fun part1(input: List<String>): Int {
return input.map { it.map { c -> c.digitToInt() } }
.let { matrix ->
val horizonal = matrix.map { it.determine() }
val vertical = matrix.transposed().map { it.determine() }.transposed()
(horizonal zip vertical).map {
(la, lb) -> (la zip lb).map { (a, b) -> a or b }
}
}.sumOf { it.count { b -> b } }
}
fun List<Int>.countTrees(value: Int): Int {
return if (this.isEmpty()) 0
else this.takeWhile { it < value }.size.let { if (it == this.size) it else it + 1 }
}
fun calcDistance(line: List<Int>, position: Int): Int =
(line.take(position).reversed().countTrees(line[position])) * (line.drop(position + 1).countTrees(line[position]))
fun part2(input: List<String>): Int {
val matrix = input.map { it.map { c ->c.digitToInt() } }
val transposed = matrix.transposed()
return (matrix.indices).maxOf { i ->
(matrix[0].indices).maxOf { j ->
calcDistance(matrix[i], j) * calcDistance(transposed[j], i)
}
}
}
val input = readInput("Day08")
part1(input).println()
part2(input).println()
}
| 0 | Kotlin | 0 | 0 | 84c2107fd70305353d953e9d8ba86a1a3d12fe49 | 1,650 | advent-of-code-kotlin | Apache License 2.0 |
src/day11/Code.kt | fcolasuonno | 221,697,249 | false | null | package day11
private val test = false
fun main() {
val parsed = if (test) listOf(
setOf<Portable>(Microchip('H'), Microchip('L')),
setOf<Portable>(Generator('H')),
setOf<Portable>(Generator('L')),
setOf<Portable>()
) else listOf(
setOf<Portable>(Generator('T'), Microchip('T'), Generator('P'), Generator('S')),
setOf<Portable>(Microchip('P'), Microchip('S')),
setOf<Portable>(Generator('p'), Microchip('p'), Generator('R'), Microchip('R')),
setOf<Portable>()
)
println("Part 1 = ${solve(parsed)}")
println("Part 2 = ${solve(parsed.mapIndexed { index, set ->
if (index == 0) (set + setOf(Generator('E'), Microchip('E'), Generator('D'), Microchip('D'))) else set
}
)}")
}
interface Portable {
val element: Char
}
private val Set<Portable>.compatible: Boolean
get() =
if (size <= 1) true
else {
val microchips = filterIsInstance<Microchip>().map { it.element }
val generators = filterIsInstance<Generator>().map { it.element }
generators.isEmpty() || microchips.minus(generators).isEmpty()
}
data class Microchip(override val element: Char) : Portable {
override fun toString() = element + "M"
}
data class Generator(override val element: Char) : Portable {
override fun toString() = element + "G"
}
data class Plan(val elevator: Int, val step: Int, val status: List<Set<Portable>>, val priority: Int) {
override fun toString() = status.toString()
val hash: String
get() {
val elementMap = mutableMapOf<Char, Int>()
val mapIndexed = status.mapIndexed { index: Int, set: Set<Portable> ->
index.toString() + set.map { (if (it is Generator) "G" else "M") + elementMap.getOrPut(it.element) { elementMap.size + 1 } }.sorted()
}.joinToString()
return elevator.toString() + mapIndexed
}
}
fun solve(input: List<Set<Portable>>): Int {
val seen = mutableSetOf<String>()
val totalPortables = input.sumBy { it.size }
val toVisit = mutableListOf(Plan(0, 0, input, 0)).toSortedSet(
compareByDescending<Plan> { it.priority }.thenBy { it.step }.thenBy { it.hash })
while (toVisit.isNotEmpty()) {
val currentPlan = toVisit.first()
toVisit.remove(currentPlan)
seen.add(currentPlan.hash)
if (currentPlan.status[3].size == totalPortables) {
return currentPlan.step
} else {
val currentFloor = currentPlan.elevator
val items = currentPlan.status[currentFloor]
val up2 = items.flatMap { item -> items.filter { it != item }.map { setOf(it, item) } }
.map { carried -> carried to items - carried }
.filter { (_, left) -> left.compatible }.mapNotNull { (carried, left) ->
currentPlan.status.getOrNull(currentFloor + 1)?.let {
(it + carried).takeIf { it.compatible }?.let { new ->
Plan(currentFloor + 1, currentPlan.step + 1, currentPlan.status.mapIndexed { index, set ->
when (index) {
currentFloor -> left
currentFloor + 1 -> new
else -> set
}
}, 3)
}
}
}.filter { it.hash !in seen }
val up = items.map { setOf(it) }
.map { carried -> carried to items - carried }
.filter { (_, left) -> left.compatible }.mapNotNull { (carried, left) ->
currentPlan.status.getOrNull(currentFloor + 1)?.let {
(it + carried).takeIf { it.compatible }?.let { new ->
Plan(currentFloor + 1, currentPlan.step + 1, currentPlan.status.mapIndexed { index, set ->
when (index) {
currentFloor -> left
currentFloor + 1 -> new
else -> set
}
}, 2)
}
}
}.filter { it.hash !in seen }
val down = items.map { setOf(it) }
.map { carried -> carried to items - carried }
.filter { (_, left) -> left.compatible }.mapNotNull { (carried, left) ->
currentPlan.status.getOrNull(currentFloor - 1)?.let {
(it + carried).takeIf { it.compatible }?.let { new ->
Plan(currentFloor - 1, currentPlan.step + 1, currentPlan.status.mapIndexed { index, set ->
when (index) {
currentFloor -> left
currentFloor - 1 -> new
else -> set
}
}, 1)
}
}
}.filter { it.hash !in seen }
val down2 = items.flatMap { item -> items.filter { it != item }.map { setOf(it, item) } }
.map { carried -> carried to items - carried }
.filter { (_, left) -> left.compatible }.mapNotNull { (carried, left) ->
currentPlan.status.getOrNull(currentFloor - 1)?.let {
(it + carried).takeIf { it.compatible }?.let { new ->
Plan(currentFloor - 1, currentPlan.step + 1, currentPlan.status.mapIndexed { index, set ->
when (index) {
currentFloor -> left
currentFloor - 1 -> new
else -> set
}
}, 0)
}
}
}.filter { it.hash !in seen }
toVisit.addAll(up)
toVisit.addAll(up2)
down.takeIf { (0 until currentFloor).any { currentPlan.status[it].isNotEmpty() } }?.let { toVisit.addAll(it) }
down2.takeIf { (0 until currentFloor).any { currentPlan.status[it].isNotEmpty() } }?.let { toVisit.addAll(it) }
}
}
return Int.MAX_VALUE
}
| 0 | Kotlin | 0 | 0 | 73110eb4b40f474e91e53a1569b9a24455984900 | 6,709 | AOC2016 | MIT License |
src/day13/Day13.kt | EdwinChang24 | 572,839,052 | false | {"Kotlin": 20838} | package day13
import readInput
fun main() {
part1()
part2()
}
data class Thing(val isInt: Boolean, val int: Int = -1, val list: List<Thing> = emptyList()) : Comparable<Thing> {
override fun compareTo(other: Thing): Int {
if (isInt && other.isInt) return int - other.int
if (isInt) return Thing(false, list = listOf(Thing(true, int = int))).compareTo(other)
if (other.isInt) return compareTo(Thing(false, list = listOf(Thing(true, int = other.int))))
for (i in 0..minOf(list.lastIndex, other.list.lastIndex)) {
val compared = list[i].compareTo(other.list[i])
if (compared != 0) return compared
}
return list.size - other.list.size
}
}
fun getTheListOfThings(from: String): List<Thing> {
val asList = from.toMutableList()
var bracketCount = 0
for ((i, c) in asList.withIndex()) {
if (c == '[') bracketCount++
if (c == ']') bracketCount--
if (c == ',' && bracketCount == 1) asList[i] = '!'
}
return asList.joinToString("").removeSurrounding("[", "]").split("!").takeIf { !(it.size == 1 && it[0] == "") }
?.map { if (it.startsWith('[')) Thing(false, list = getTheListOfThings(it)) else Thing(true, int = it.toInt()) }
?: emptyList()
}
fun part1() {
val input = readInput(13)
val allTheThings = mutableListOf<List<Thing>>()
for (line in input) if (line.isNotBlank()) allTheThings += getTheListOfThings(line)
var total = 0
for (i in 0 until allTheThings.size / 2) {
val thing1 = allTheThings[i * 2]
val thing2 = allTheThings[i * 2 + 1]
if (Thing(false, list = thing1) < Thing(false, list = thing2)) total += i + 1
}
println(total)
}
fun part2() {
val input = readInput(13)
val allTheThings = mutableListOf(
listOf(Thing(false, list = listOf(Thing(true, int = 2)))),
listOf(Thing(false, list = listOf(Thing(true, int = 6))))
)
for (line in input) if (line.isNotBlank()) allTheThings += getTheListOfThings(line)
var total = 1
allTheThings.map { Thing(false, list = it) }.sorted().forEachIndexed { index, thing ->
if ("$thing" == "${Thing(false, list = listOf(Thing(false, list = listOf(Thing(true, int = 2)))))}" ||
"$thing" == "${Thing(false, list = listOf(Thing(false, list = listOf(Thing(true, int = 6)))))}"
) {
total *= index + 1
}
}
println(total)
}
| 0 | Kotlin | 0 | 0 | e9e187dff7f5aa342eb207dc2473610dd001add3 | 2,450 | advent-of-code-2022 | Apache License 2.0 |
src/Day11.kt | zfz7 | 573,100,794 | false | {"Kotlin": 53499} | fun main() {
println(day11A(parseMonkeys(readFile("Day11"))))
println(day11B(parseMonkeys(readFile("Day11"))))
}
fun parseMonkeys(input: String): List<Monkey>
= input.split("\n\n").map { mk ->
Monkey(
items = mk.split("\n").filter{ it.contains("Starting items: ")}[0].split(" Starting items: ",", ").mapNotNull{it.toLongOrNull()}.toMutableList(),
op = { item: Long ->
val line = mk.split("\n").filter{ it.contains("Operation: new = ")}[0].split(" ")
when(line[6]){
"+" -> item + (line[7].toLongOrNull() ?: item)
"-" -> item - (line[7].toLongOrNull() ?: item)
"/" -> item / (line[7].toLongOrNull() ?: item)
"*" -> item * (line[7].toLongOrNull() ?: item)
else -> throw Exception("help")
}
},
divider = mk.split("\n").filter{ it.contains("Test: divisible by ")}[0].split("Test: divisible by ")[1].toLong(),
pass = mk.split("\n").filter{ it.contains("If true: throw to monkey ")}[0].split("If true: throw to monkey ")[1].toInt(),
fail = mk.split("\n").filter{ it.contains("If false: throw to monkey ")}[0].split("If false: throw to monkey ")[1].toInt(),
)
}
fun day11A(monkeys: List<Monkey>): Long {
repeat(20) {
monkeys.forEach {
it.inspectAll(monkeys)
}
}
// monkeys.forEachIndexed { idx, monkey ->
// println("Round 20 Monkey $idx items ${monkey.items} inspected ${monkey.count}")
// }
return monkeys.map { it.count }.sorted().reversed().take(2).fold(1L) { acc, it -> acc * it }
}
fun day11B(mkys: List<Monkey>): Long {
val monkeys = mkys.map { it.copy(worry = true) }
repeat(10000) {
monkeys.forEach {
it.inspectAll(monkeys)
}
}
// monkeys.forEachIndexed { idx, monkey ->
// println("Monkey $idx inspected ${monkey.count} ${monkey.items}")
// }
return monkeys.map { it.count }.sorted().reversed().take(2).fold(1L) { acc, it -> acc * it }
}
data class Monkey(
val items: MutableList<Long>,
private val op: (item: Long) -> Long,
private val divider: Long,
private val pass: Int,
private val fail: Int,
private val worry: Boolean = false
) {
var count: Long = 0
fun inspectAll(monkeys: List<Monkey>) {
items.forEach { item ->
val x: Long = if (worry) op(item) % monkeys.map { it.divider }.reduce{ acc, crr -> acc * crr } else op(item) / 3L
if (test(x)) {
monkeys[pass].add(x)
} else {
monkeys[fail].add(x)
}
// println("item $item op ${x} test ${test(op(item))} true $pass false $fail")
count++
}
items.clear()
}
private fun add(item: Long) {
items.add(item)
}
private fun test(x: Long): Boolean = ((x % divider) == 0L)
}
| 0 | Kotlin | 0 | 0 | c50a12b52127eba3f5706de775a350b1568127ae | 2,973 | AdventOfCode22 | Apache License 2.0 |
day-09/src/main/kotlin/SmokeBasin2nd.kt | diogomr | 433,940,168 | false | {"Kotlin": 92651} | fun main() {
println("Part One Solution: ${partOne()}")
println("Part Two Solution: ${partTwo()}")
}
private fun partOne(): Int {
val map = readMap()
return map.keys
.filter { it.isLowestOfSurroundingPoints(map) }
.sumOf { map[it]!! + 1 }
}
private fun partTwo(): Long {
val map = readMap()
return map.keys.asSequence()
.filter { it.isLowestOfSurroundingPoints(map) }
.map { computeBasinSize(it, map, mutableSetOf()) }
.sortedDescending()
.take(3)
.reduce { acc, it ->
acc * it
}
}
fun computeBasinSize(point: Point, map: Map<Point, Int>, visited: MutableSet<Point>): Long {
if (!visited.add(point)) return 0
return 1 + point.findPointsInBasin(map).sumOf {
computeBasinSize(it, map, visited)
}
}
private fun readMap(): Map<Point, Int> {
return readInputLines()
.filter { it.isNotBlank() }
.flatMapIndexed { column, line ->
line.split("")
.filter { it.isNotBlank() }
.mapIndexed { row, value ->
Pair(Point(row, column), value.toInt())
}
}
.toMap()
}
data class Point(
val x: Int,
val y: Int,
) {
fun findPointsInBasin(map: Map<Point, Int>): Set<Point> {
val pointValue = map[this]!!
return getValidSurroundingPoints(map)
.filter {
map[it]!! > pointValue && map[it]!! != 9
}
.toSet()
}
fun isLowestOfSurroundingPoints(map: Map<Point, Int>): Boolean {
val pointValue = map[this]!!
return getValidSurroundingPoints(map).all { map[it]!! > pointValue }
}
private fun getValidSurroundingPoints(map: Map<Point, Int>) = getSurroundingPoints()
.filter { it.existsInMap(map) }
.toSet()
private fun existsInMap(map: Map<Point, Int>) = map[this] != null
private fun getSurroundingPoints() = setOf(
this.copy(x = x - 1),
this.copy(x = x + 1),
this.copy(y = y - 1),
this.copy(y = y + 1),
)
}
| 0 | Kotlin | 0 | 0 | 17af21b269739e04480cc2595f706254bc455008 | 2,096 | aoc-2021 | MIT License |
src/Day13.kt | mkfsn | 573,042,358 | false | {"Kotlin": 29625} | import java.util.*
fun main() {
fun decode(input: String): List<Any> {
var groupStack = Stack<Int>()
var numberQueue: Queue<Int> = LinkedList<Int>()
var parts = mutableListOf<String>()
val inner = input.substring(1, input.length - 1)
inner.forEachIndexed { i, ch ->
if (ch == '[') {
groupStack.add(i)
} else if (ch == ']') {
val j = groupStack.pop()
if (groupStack.isEmpty()) {
parts.add(inner.substring(j, i + 1))
return@forEachIndexed
}
}
if (groupStack.isNotEmpty()) return@forEachIndexed
if (ch != ',') numberQueue.add(i)
if (ch == ',' || i == inner.length - 1) {
if (numberQueue.isEmpty()) return@forEachIndexed
val j = numberQueue.first()
parts.add(inner.substring(j, if (ch == ',') i else i + 1))
numberQueue.clear()
}
}
return parts.map { if (it[0] == '[') decode(it) else it.toInt() }
}
fun inRightOrder(pair: Pair<List<Any>, List<Any>>): Int {
pair.first.forEachIndexed { i, left ->
if (i >= pair.second.size) return -1
val right = pair.second[i]
val res = when {
left is Int && right is Int -> if (left < right) 1 else if (left > right) -1 else 0
left is List<*> && right is List<*> -> inRightOrder(Pair(left as List<Any>, right as List<Any>))
left is Int && right is List<*> -> inRightOrder(Pair(listOf(left), right as List<Any>))
left is List<*> && right is Int -> inRightOrder(Pair(left as List<Any>, listOf(right)))
else -> 0
}
if (res != 0) return res
}
return if (pair.first.size < pair.second.size) 1 else 0
}
fun part1(input: List<String>): Int =
input.chunkedBy { it == "" }
.map { inRightOrder(Pair(decode(it[0]), decode(it[1]))) }
.mapIndexed { i, v -> Pair(i + 1, v) }
.filter { it.second == 1 }
.sumOf { it.first }
fun part2(input: List<String>) =
input.filter { it != "" }.run { this + listOf("[[2]]", "[[6]]") }.map { Pair(it, decode(it)) }
.sortedWith { left, right -> inRightOrder(Pair(left.second, right.second)) }
.asReversed()
.run {
val a = this.indexOfFirst { it.first == "[[2]]" } + 1
var b = this.indexOfFirst { it.first == "[[6]]" } + 1
a * b
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day13_test")
check(part1(testInput) == 13)
check(part2(testInput) == 140)
val input = readInput("Day13")
check(part1(input) == 5808)
println(part1(input))
check(part2(input) == 22713)
println(part2(input))
}
| 0 | Kotlin | 0 | 1 | 8c7bdd66f8550a82030127aa36c2a6a4262592cd | 2,991 | advent-of-code-kotlin-2022 | Apache License 2.0 |
src/Day07.kt | timj11dude | 572,900,585 | false | {"Kotlin": 15953} | sealed class Node
sealed class Container : Node()
object Root : Container()
data class Folder(val name: String, val container: Container) : Container()
data class File(val size: Int) : Node()
fun main() {
fun Map<Container, List<Node>>.update(current: Container, node: Node) = (this + (current to ((this[current] ?: emptyList()) + node)))
fun readInput(input: Collection<String>): Map<Container, List<Node>> {
return input.fold(emptyMap<Container, List<Node>>() to emptyList<Container>()) { (reg, stack), entry ->
when {
entry == "$ cd /" -> reg to listOf(Root)
entry.startsWith("$ cd ..") -> reg to (stack.dropLast(1))
entry.startsWith("$ cd") -> reg to (stack + Folder(entry.drop(5), stack.last()))
entry.startsWith("$ ls") -> reg to stack
entry.startsWith("dir ") -> reg.update(stack.last(), Folder(entry.drop(4), stack.last())) to stack
else -> reg.update(stack.last(), File(entry.takeWhile { it.isDigit() }.toInt())) to stack
}
}.first
}
class FS(map: Map<Container, List<Node>>) {
private val computedFolderSize: MutableMap<Container, Int> = mutableMapOf()
init {
var previousDiff = 0
while (computedFolderSize.size != map.size) {
val newDiff = map.size - computedFolderSize.size
if (newDiff == previousDiff) {
throw IllegalStateException("Failed to reduce diff")
}
previousDiff = newDiff
map.forEach { (k, v) ->
if (!computedFolderSize.containsKey(k) && (v.all { it is File } || computedFolderSize.keys.containsAll(v.filterIsInstance<Folder>()))) {
computedFolderSize[k] = v.sumOf {
when (it) {
is File -> it.size
is Folder -> computedFolderSize[it]!!
is Root -> throw IllegalArgumentException("Root is not contained by anything else")
}
}
}
}
}
}
fun getFolderSizes() = computedFolderSize.toMap()
}
fun part1(input: Collection<String>): Int {
val parsedInput = readInput(input)
val fs = FS(parsedInput)
val folderSizes = fs.getFolderSizes()
return folderSizes.values.filter { it <= 100000 }.sum()
}
fun part2(input: Collection<String>): Int {
val folderSizes = FS(readInput(input)).getFolderSizes()
val totalSpace = 70000000
val spaceRequired = 30000000
val remainingSpace = totalSpace - folderSizes[Root]!!
val needAdditional = spaceRequired - remainingSpace
return folderSizes.values.filter { it >= needAdditional }.minOf { it }
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day07_test")
check(part1(testInput) == 95437)
check(part2(testInput) == 24933642)
val input = readInput("Day07")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 28aa4518ea861bd1b60463b23def22e70b1ed481 | 3,212 | advent-of-code-2022 | Apache License 2.0 |
src/main/kotlin/com/anahoret/aoc2022/day12/main.kt | mikhalchenko-alexander | 584,735,440 | false | null | package com.anahoret.aoc2022.day12
import java.io.File
import java.util.PriorityQueue
data class Hill(val row: Int, val col: Int, val height: Int)
class Terrain(private val hills: List<List<Hill>>, val start: Hill, val end: Hill) {
companion object {
fun parse(str: String): Terrain {
lateinit var start: Hill
lateinit var end: Hill
val hills = str.split("\n").mapIndexed { rowIdx, row ->
row.mapIndexed { colIdx, char ->
val heightChar = if (char == 'S') 'a' else if (char == 'E') 'z' else char
val hill = Hill(rowIdx, colIdx, heightMap.getValue(heightChar))
if (char == 'S') start = hill
if (char == 'E') end = hill
hill
}
}
return Terrain(hills, start, end)
}
}
fun possibleNeighbours(hill: Hill): List<Hill> {
val (row, col, height) = hill
return listOf(
row - 1 to col,
row + 1 to col,
row to col - 1,
row to col + 1
).mapNotNull { (r, c) -> hills.getOrNull(r)?.getOrNull(c) }
.filter { it.height <= height + 1 }
}
fun hillsOfHeight(height: Int): List<Hill> {
return hills.flatten().filter { it.height == height }
}
}
val heightMap = ('a'..'z').withIndex().associate { it.value to it.index + 1 }
fun main() {
val hills = File("src/main/kotlin/com/anahoret/aoc2022/day12/input.txt")
.readText()
.trim()
.let(Terrain.Companion::parse)
// Part 1
part1(hills)
// Part 2
part2(hills)
}
private fun part1(terrain: Terrain) {
println(shortestPathLength(terrain, terrain.start, terrain.end))
}
private fun part2(terrain: Terrain) {
terrain.hillsOfHeight(1)
.mapNotNull { hill -> shortestPathLength(terrain, start = hill, end = terrain.end) }
.min()
.let(::println)
}
data class Path(private val hills: List<Hill>, val cost: Int) : Comparable<Path> {
constructor(start: Hill) : this(listOf(start), 0)
val end = hills.last()
operator fun plus(hill: Hill): Path {
return copy(hills = hills + hill, cost = cost + 1)
}
override fun compareTo(other: Path): Int {
return cost.compareTo(other.cost)
}
}
fun shortestPathLength(terrain: Terrain, start: Hill, end: Hill): Int? {
val paths = PriorityQueue<Path>()
paths += Path(start)
val visited = mutableSetOf<Hill>()
var path = paths.poll()
while (path.end != end) {
terrain.possibleNeighbours(path.end)
.filterNot(visited::contains)
.also(visited::addAll)
.forEach { paths += path + it }
if (paths.isEmpty()) break
path = paths.poll()
}
if (path.end != end) return null
return path.cost
}
| 0 | Kotlin | 0 | 0 | b8f30b055f8ca9360faf0baf854e4a3f31615081 | 2,883 | advent-of-code-2022 | Apache License 2.0 |
src/Day08.kt | andrewgadion | 572,927,267 | false | {"Kotlin": 16973} | fun main() {
fun parse(input: List<String>) = input.map { it.map(Char::digitToInt) }
fun List<List<Int>>.top(colRow: Pair<Int, Int>) =
(colRow.first - 1 downTo 0).map { this[it][colRow.second] }
fun List<List<Int>>.bottom(colRow: Pair<Int, Int>) =
(colRow.first + 1 .. lastIndex).map { this[it][colRow.second] }
fun List<List<Int>>.left(colRow: Pair<Int, Int>) =
(colRow.second - 1 downTo 0).map { this[colRow.first][it] }
fun List<List<Int>>.right(colRow: Pair<Int, Int>) =
(colRow.second + 1 .. this[colRow.first].lastIndex).map { this[colRow.first][it] }
fun List<List<Int>>.isVisible(colRow: Pair<Int, Int>): Boolean {
val height = this[colRow.first][colRow.second]
return top(colRow).all { it < height } ||
bottom(colRow).all { it < height } ||
left(colRow).all { it < height } ||
right(colRow).all { it < height }
}
fun maxByDirection(height: Int, direction: List<Int>) =
direction.indexOfFirst { it >= height }.let { if (it == -1) direction.size else it + 1 }
fun List<List<Int>>.viewScore(colRow: Pair<Int, Int>): Int {
val height = this[colRow.first][colRow.second]
return maxByDirection(height, top(colRow)) *
maxByDirection(height, bottom(colRow)) *
maxByDirection(height, left(colRow)) *
maxByDirection(height, right(colRow))
}
fun List<List<Int>>.iterate() =
(0..lastIndex).asSequence().flatMap { col ->
(0..this[col].lastIndex).asSequence().map { row -> col to row }
}
fun part1(input: List<String>) = parse(input).let { trees -> trees.iterate().count(trees::isVisible) }
fun part2(input: List<String>) = parse(input).let { trees -> trees.iterate().maxOf(trees::viewScore) }
val input = readInput("day8")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 4d091e2da5d45a786aee4721624ddcae681664c9 | 1,931 | advent-of-code-2022 | Apache License 2.0 |
src/twentytwo/Day04.kt | Monkey-Matt | 572,710,626 | false | {"Kotlin": 73188} | package twentytwo
fun main() {
// test if implementation meets criteria from the description, like:
val testInput = readInputLines("Day04_test")
println(part1(testInput))
check(part1(testInput) == 2)
println(part2(testInput))
check(part2(testInput) == 4)
println("---")
val input = readInputLines("Day04_input")
println(part1(input))
println(part2(input))
testAlternativeSolutions()
}
private fun part1(input: List<String>): Int {
val pairContains = input.map { elfPair ->
val (firstElf, secondElf) = elfPair.split(',')
val (firstStart, firstEnd) = firstElf.split('-').map { it.toInt() }
val (secondStart, secondEnd) = secondElf.split('-').map { it.toInt() }
(firstStart <= secondStart && firstEnd >= secondEnd) || (secondStart <= firstStart && secondEnd >= firstEnd)
}
return pairContains.count { it }
}
private fun part2(input: List<String>): Int {
val pairContains = input.map { elfPair ->
val (firstElf, secondElf) = elfPair.split(',')
val (firstStart, firstEnd) = firstElf.split('-').map { it.toInt() }
val (secondStart, secondEnd) = secondElf.split('-').map { it.toInt() }
secondStart in firstStart..firstEnd || secondEnd in firstStart .. firstEnd || firstStart in secondStart..secondEnd || firstEnd in secondStart .. secondEnd
}
return pairContains.count { it }
}
// ------------------------------------------------------------------------------------------------
private fun testAlternativeSolutions() {
val testInput = readInputLines("Day04_test")
check(part1AlternativeSolution(testInput) == 2)
check(part2AlternativeSolution(testInput) == 4)
println("Alternative Solutions:")
val input = readInputLines("Day04_input")
println(part1AlternativeSolution(input))
println(part2AlternativeSolution(input))
}
private fun part1AlternativeSolution(input: List<String>): Int {
return input
.map { it.toRanges() }
.map { it.first fullyContains it.second || it.second fullyContains it.first }
.count { it }
}
private fun part2AlternativeSolution(input: List<String>): Int {
return input
.map { it.toRanges() }
.map { it.first overlaps it.second }
.count { it }
}
private fun String.toRanges(): Pair<IntRange, IntRange> {
return this
.let {
it.substringBefore(",") to it.substringAfter(",")
}
.let { pair ->
pair.onEach {
val start = it.substringBefore("-").toInt()
val end = it.substringAfter("-").toInt()
IntRange(start, end)
}
}
}
private fun <T, R> Pair<T, T>.onEach(transform: (T) -> R): Pair<R, R> {
return Pair(transform(this.first), transform(this.second))
}
private infix fun IntRange.fullyContains(other: IntRange): Boolean {
return this.all { it in other }
}
private infix fun IntRange.overlaps(other: IntRange): Boolean {
return this.any { it in other }
}
| 1 | Kotlin | 0 | 0 | 600237b66b8cd3145f103b5fab1978e407b19e4c | 3,030 | advent-of-code-solutions | Apache License 2.0 |
src/main/kotlin/mkuhn/aoc/Day13.kt | mtkuhn | 572,236,871 | false | {"Kotlin": 53161} | package mkuhn.aoc
import mkuhn.aoc.util.readInput
import mkuhn.aoc.util.splitList
fun main() {
val input = readInput("Day13")
println(day13part1(input))
println(day13part2(input))
}
fun day13part1(input: List<String>): Int =
input.splitList("").asSequence()
.map { l -> l.map { parseNestedListsOfInt(it.drop(1).dropLast(1)) } }
.map { p -> p[0].comparePacketOrder(p[1]) == -1 }
.withIndex()
.filter { it.value }
.sumOf { it.index+1 }
fun day13part2(input: List<String>): Int {
val dividerPackets = listOf(listOf(listOf(2)), listOf(listOf(6)))
return input.asSequence()
.filter { it.isNotEmpty() }
.map { l -> parseNestedListsOfInt(l.drop(1).dropLast(1)) }
.plus(dividerPackets)
.sortedWith(Any::comparePacketOrder)
.withIndex()
.filter { it.value in dividerPackets }
.fold(1) { acc, i -> acc*(i.index+1) }
}
fun parseNestedListsOfInt(line: String): List<Any> {
if (line.isEmpty()) return emptyList()
var nestingLevel = 0
val nestingChars = line.map { c ->
if (c == '[') nestingLevel++
else if (c == ']') nestingLevel--
c to nestingLevel
}
return nestingChars.splitList(',' to 0).map { p ->
p.map { it.first }
.joinToString("")
.let { it.toIntOrNull() ?: parseNestedListsOfInt(it.drop(1).dropLast(1)) }
}
}
fun Any.comparePacketOrder(right: Any) =
if(this is Int && right is Int) { compareTo(right) }
else if (this is List<*> && right is List<*>) { comparePacketListOrder(right) }
else { this.listIfNotList().comparePacketListOrder(right.listIfNotList()) }
fun Any.listIfNotList() = if(this is Int) listOf(this) else this as List<*>
fun List<*>.comparePacketListOrder(right: List<*>): Int =
this.zip(right)
.map { it.first!!.comparePacketOrder(it.second!!) } //hold my beer
.firstOrNull { it != 0 }
?:this.size.compareTo(right.size)
| 0 | Kotlin | 0 | 1 | 89138e33bb269f8e0ef99a4be2c029065b69bc5c | 1,982 | advent-of-code-2022 | Apache License 2.0 |
src/main/day15/Part1.kt | ollehagner | 572,141,655 | false | {"Kotlin": 80353} | package day15
import common.Point
import readInput
import kotlin.math.abs
fun main() {
val sensors = parseInput(readInput("day15/input.txt"))
val rowToCheck = 2000000
val beaconsInRow = sensors.map { it.beacon }.filter { it.y == rowToCheck }.distinct().count()
val positionsWithNoBeacon = coveredRowPositions(sensors, rowToCheck)
.sumOf { it.count() } - beaconsInRow
println("Day 15 part 1. Positions with no beacons: $positionsWithNoBeacon")
}
fun coveredRowPositions(sensors: List<Sensor>, rowToCheck: Int): List<IntRange> {
return sensors
.map { it.rowCoverage(rowToCheck) }
.filterNotNull()
.fold(listOf()) { acc, rowCoverage ->
merge(buildList {
addAll(acc)
add(rowCoverage)
})
}
}
fun merge(ranges: List<IntRange>): List<IntRange> {
if(ranges.size == 1) return ranges
val toCheck = ranges.first()
val overlapping = ranges.drop(1).filter { it.overlapsOrAdjoins(toCheck) }
val notOverlapping = ranges.drop(1).filter { !it.overlapsOrAdjoins(toCheck) }
return if(overlapping.isEmpty()) {
listOf(listOf(toCheck), merge(ranges.drop(1))).flatten()
} else {
val merged = overlapping.fold(toCheck) { acc, value -> acc.merge(value) }
return merge(listOf(listOf(merged), notOverlapping).flatten())
}
}
fun parseInput(input: List<String>): List<Sensor> {
val pattern = Regex("""Sensor at x=(-?\d+), y=(-?\d+): closest beacon is at x=(-?\d+), y=(-?\d+)""")
return input
.map{ pattern.find(it)!!.destructured }
.map { (sensorX, sensorY, beaconX, beaconY) -> Sensor(Point(sensorX.toInt(), sensorY.toInt()), Point(beaconX.toInt(), beaconY.toInt())) }
}
data class Sensor(val position: Point, val beacon: Point) {
fun rowCoverage(yValue: Int): IntRange? {
val horizontalReach = position.manhattanDistance(beacon) - abs(position.y - yValue)
return if(horizontalReach > 0) {
IntRange(position.x - horizontalReach, position.x + horizontalReach)
} else {
null
}
}
}
private infix fun IntRange.overlapsOrAdjoins(other: IntRange): Boolean =
(first <= other.last && other.first <= last) || last + 1 == other.first || other.last + 1 == first
private infix fun IntRange.merge(other: IntRange): IntRange {
return IntRange(minOf(first, other.first), maxOf(last, other.last))
} | 0 | Kotlin | 0 | 0 | 6e12af1ff2609f6ef5b1bfb2a970d0e1aec578a1 | 2,433 | aoc2022 | Apache License 2.0 |
src/Day08.kt | WhatDo | 572,393,865 | false | {"Kotlin": 24776} | import kotlin.math.abs
import kotlin.math.sign
fun main() {
val input = readInput("Day08")
val grid = Grid.create(input)
val visibleTrees = grid.map.entries.filter { entry ->
entry.isVisibleIn(grid)
}
println("visible tree count ${visibleTrees.size}")
val bestScenic = grid.map.entries.maxBy { it.scenicScore(grid) }
val score = bestScenic.scenicScore(grid)
println("best scenic tree is $bestScenic with score $score")
}
private fun TreeEntry.lookOut(grid: Grid): Array<List<Vec2>> {
val (x, y) = key
val left = (x - 1) downTo 1
val right = (x + 1)..grid.size.first
val up = (y - 1) downTo 1
val down = (y + 1)..grid.size.second
return arrayOf(left.map { it to y }, right.map { it to y }, up.map { x to it }, down.map { x to it })
}
private fun TreeEntry.scenicScore(grid: Grid): Int {
val directions = lookOut(grid)
return directions.fold(1) { acc, direction ->
var index = direction.indexOfFirst { vec -> grid.map[vec].let { tree -> tree == null || tree >= value } }
if (index == -1) {
index = if (direction.isNotEmpty()) {
val (lastX, lastY) = direction.last()
abs(lastX - key.first) + abs(lastY - key.second)
} else {
0
}
} else {
index++
}
acc * index
}
}
private fun TreeEntry.isVisibleIn(grid: Grid): Boolean {
val directions = lookOut(grid)
val treeHeight = value
return directions.any { trees -> trees.all { tree -> grid.map[tree].let { it == null || key == tree || it < treeHeight } } }
}
typealias TreeMap = Map<Vec2, Int>
typealias TreeEntry = Map.Entry<Vec2, Int>
private class Grid(val map: TreeMap, val size: Vec2) {
companion object {
fun create(input: List<String>): Grid {
val map = input.withIndex().flatMap { row ->
row.value.withIndex().map { col -> (col.index + 1 to row.index + 1) to col.value.digitToInt() }
}.toMap()
val height = input.size
val width = input[0].length
return Grid(map, width to height)
}
}
} | 0 | Kotlin | 0 | 0 | 94abea885a59d0aa3873645d4c5cefc2d36d27cf | 2,173 | aoc-kotlin-2022 | Apache License 2.0 |
src/main/kotlin/com/dr206/2022/Day02.kt | dr206 | 572,377,838 | false | {"Kotlin": 9200} | fun main() {
fun part1(input: List<String>): Int {
val strategyGuide = input
.pairs<String>(" ")
.map { Pair(it.first.toHand(), it.second.toHand()) }
return strategyGuide.sumOf { getTotalPerHand(it) }
}
fun part2(input: List<String>): Int {
val strategyGuide = input
.pairs<String>(" ")
.map { outcomeToHand(it) }
return strategyGuide.sumOf { getTotalPerHand(it) }
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day02_test")
check(part1(testInput).also { println("Test part 1: $it") } == 15)
check(part2(testInput).also { println("Test part 2: $it") } == 12)
val input = readInput("Day02")
println("Part 1 ${part1(input)}")
println("Part 2 ${part2(input)}")
}
enum class Hand(yours: String, val mine: String, val score: Int) {
ROCK("X", "A", 1),
PAPER("Y", "B", 2),
SCISSORS("Z", "C", 3)
}
val beats = mapOf(
Hand.ROCK to Hand.SCISSORS,
Hand.PAPER to Hand.ROCK,
Hand.SCISSORS to Hand.PAPER
)
fun matchOutcome(mine: Hand, yours: Hand) = when (yours) {
mine -> 0
beats[mine] -> 1
else -> -1
}
fun getTotalPerHand(p: Pair<Hand, Hand>) = 3*(1 + matchOutcome(p.second, p.first)) + p.second.score
fun String.toHand() = when(this) {
"X", "A" -> Hand.ROCK
"Y", "B" -> Hand.PAPER
else -> Hand.SCISSORS
}
fun outcomeToHand(p: Pair<String, String>): Pair<Hand, Hand> = when(p.second) {
// Lose
"X" -> Pair(p.first.toHand(), beats[p.first.toHand()]!!)
// Draw
"Y" -> Pair(p.first.toHand(), p.first.toHand())
// Wim
else -> Pair(p.first.toHand(), beats.entries.first { it.value == p.first.toHand() }.key)
}
| 0 | Kotlin | 0 | 0 | 57b2e7227d992de87a51094a971e952b3774fd11 | 1,751 | advent-of-code-in-kotlin | Apache License 2.0 |
src/main/kotlin/days/Day08.kt | Kebaan | 573,069,009 | false | null | package days
import days.Day08.Tree
import utils.Day
import utils.Point
import utils.readInput
import utils.takeUntil
fun main() {
Day08.solve()
}
private typealias Forest = List<List<Tree>>
object Day08 : Day<Int>(2022, 8) {
data class Tree(val location: Point, val height: Int) {
fun visibleThrough(direction: List<Tree>) = direction.all { it.height < height }
}
private fun Forest.leftTrees(tree: Tree) = (tree.location.x - 1 downTo 0).map { x -> this[x][tree.location.y] }
private fun Forest.rightTrees(tree: Tree) =
(tree.location.x + 1 until this.size).map { x -> this[x][tree.location.y] }
private fun Forest.topTrees(tree: Tree) = (tree.location.y - 1 downTo 0).map { y -> this[tree.location.x][y] }
private fun Forest.bottomTrees(tree: Tree) =
(tree.location.y + 1 until this[tree.location.x].size).map { y -> this[tree.location.x][y] }
private fun Forest.isVisible(tree: Tree): Boolean {
return when {
tree.location.x == 0 || tree.location.x == this.size -> true
tree.location.y == 0 || tree.location.y == this[tree.location.x].size -> true
tree.visibleThrough(leftTrees(tree)) -> true
tree.visibleThrough(rightTrees(tree)) -> true
tree.visibleThrough(topTrees(tree)) -> true
tree.visibleThrough(bottomTrees(tree)) -> true
else -> return false
}
}
private fun Forest.scenicScore(tree: Tree): Int {
when {
tree.location.x == 0 || tree.location.x == this.size - 1 -> return 0
tree.location.y == 0 || tree.location.y == this[tree.location.x].size - 1 -> return 0
}
val visibleLeft = leftTrees(tree).takeUntil { it.height >= tree.height }
val visibleRight = rightTrees(tree).takeUntil { it.height >= tree.height }
val visibleUp = topTrees(tree).takeUntil { it.height >= tree.height }
val visibleDown = bottomTrees(tree).takeUntil { it.height >= tree.height }
return visibleLeft.size * visibleRight.size * visibleUp.size * visibleDown.size
}
private fun parseForest(input: List<String>) = input
.mapIndexed { x, row ->
row.mapIndexed { y, tree ->
Tree(Point(x, y), tree.digitToInt())
}
}
override fun part1(input: List<String>): Int {
val forest = parseForest(input)
return forest.sumOf { row ->
row.count { tree ->
forest.isVisible(tree)
}
}
}
override fun part2(input: List<String>): Int {
val forest = parseForest(input)
val scores = forest.flatMap { row ->
row.map { tree ->
forest.scenicScore(tree)
}
}
return scores.max()
}
override fun doSolve() {
val input = readInput(2022, 8)
part1(input).let {
println(it)
check(it == 1763)
}
part2(input).let {
println(it)
check(it == 671160)
}
}
override val testInput = """
30373
25512
65332
33549
35390""".trimIndent().lines()
}
| 0 | Kotlin | 0 | 0 | ef8bba36fedbcc93698f3335fbb5a69074b40da2 | 3,220 | Advent-of-Code-2022 | Apache License 2.0 |
src/Day08.kt | ekgame | 573,100,811 | false | {"Kotlin": 20661} | fun main() {
data class Tree(val size: Int, var visible: Boolean = false)
data class TreeGrid(val trees: Array<Array<Tree>>) {
val height = trees.size
val width = trees.first().size
fun getHorizontalSequence(index: Int) = trees[index].toList()
fun getVerticalSequence(index: Int) = (0 until height).map { trees[it][index] }
fun processLineVisibility(sequence: Iterable<Tree>) {
var currentSize = -1
sequence.forEach {
if (it.size > currentSize) {
it.visible = true
currentSize = it.size
}
}
}
fun processVisibility() {
repeat(height) {
processLineVisibility(getHorizontalSequence(it))
processLineVisibility(getHorizontalSequence(it).reversed())
}
repeat(width) {
processLineVisibility(getVerticalSequence(it))
processLineVisibility(getVerticalSequence(it).reversed())
}
}
fun getScenicScore(tower: Tree, sequence: List<Tree>): Int {
if (sequence.isEmpty()) return 0
val visibleTrees = sequence.takeWhile { it.size < tower.size }.count()
return (visibleTrees + 1).coerceAtMost(sequence.size)
}
fun getScenicScoreAt(x: Int, y: Int): Int {
if (x == 0 || y == 0 || x == width - 1 || y == height - 1) {
return 0
}
val tower = trees[y][x]
val horizontal = getHorizontalSequence(y)
val vertical = getVerticalSequence(x)
val leftScore = getScenicScore(tower, horizontal.subList(0, x).reversed())
val rightScore = getScenicScore(tower, horizontal.subList(x + 1, width))
val upScore = getScenicScore(tower, vertical.subList(0, y).reversed())
val downScore = getScenicScore(tower, vertical.subList(y + 1, height))
return leftScore * rightScore * upScore * downScore
}
}
fun parseTreeGrid(input: List<String>) = TreeGrid(Array(input.size) { line -> input[line].map { Tree(it.digitToInt()) }.toTypedArray() })
fun <T> cartesianSequence(first: List<T>, second: List<T>) = sequence {
first.forEach { x ->
second.forEach { y ->
yield(x to y)
}
}
}
fun part1(input: List<String>): Int {
val grid = parseTreeGrid(input)
grid.processVisibility()
return grid.trees.flatten().count { it.visible }
}
fun part2(input: List<String>): Int {
val grid = parseTreeGrid(input)
return cartesianSequence((0 until grid.width).toList(), (0 until grid.height).toList())
.maxOf { (x, y) -> grid.getScenicScoreAt(x, y) }
}
val testInput = readInput("08.test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("08")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 2 | 0c2a68cedfa5a0579292248aba8c73ad779430cd | 3,029 | advent-of-code-2022 | Apache License 2.0 |
src/Day13.kt | azat-ismagilov | 573,217,326 | false | {"Kotlin": 75114} | sealed interface DistressSignal : Comparable<DistressSignal> {
override operator fun compareTo(other: DistressSignal): Int
companion object {
fun of(string: String): DistressSignal =
if (string.startsWith('[')) DistressList.of(string)
else DistressInt.of(string)
}
}
data class DistressList(val content: List<DistressSignal>) : DistressSignal {
override operator fun compareTo(other: DistressSignal): Int = when (other) {
is DistressInt -> this.compareTo(DistressList(listOf(other)))
is DistressList -> this.content.compareTo(other.content)
}
companion object {
fun of(string: String): DistressList {
val lst = string.removePrefix("[").removeSuffix("]").splitSquares()
return DistressList(lst.map { DistressSignal.of(it) })
}
}
}
private fun String.splitSquares(): List<String> {
val result = mutableListOf<String>()
var currentString = ""
var balance = 0
for (c in this) {
balance += when (c) {
'[' -> 1
']' -> -1
else -> 0
}
if (c == ',' && balance == 0) {
result.add(currentString)
currentString = ""
} else currentString += c
}
if (currentString != "") result.add(currentString)
return result
}
private fun List<DistressSignal>.compareTo(other: List<DistressSignal>): Int {
for ((x, y) in this.zip(other)) {
when (x.compareTo(y)) {
-1 -> return -1
1 -> return 1
}
}
return this.size.compareTo(other.size)
}
data class DistressInt(val content: Int) : DistressSignal {
override operator fun compareTo(other: DistressSignal): Int = when (other) {
is DistressInt -> this.content.compareTo(other.content)
is DistressList -> DistressList(listOf(this)).compareTo(other)
}
companion object {
fun of(string: String): DistressInt = DistressInt(string.toInt())
}
}
fun main() {
val day = 13
fun part1(input: List<String>): Int = input.chunked(3).mapIndexed { index, (first, second, _) ->
if (DistressSignal.of(first) < DistressSignal.of(second)) index + 1
else 0
}.sum()
val dividers = listOf(
DistressSignal.of("[[2]]"), DistressSignal.of("[[6]]")
)
fun part2(input: List<String>): Int =
(dividers + input.filterIndexed { index, _ -> index % 3 < 2 }.map { DistressSignal.of(it) })
.sorted()
.let {
(it.indexOf(dividers[0]) + 1) * (it.indexOf(dividers[1]) + 1)
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day${day}_test")
check(part1(testInput) == 13)
check(part2(testInput) == 140)
val input = readInput("Day${day}")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | abdd1b8d93b8afb3372cfed23547ec5a8b8298aa | 2,893 | advent-of-code-kotlin-2022 | Apache License 2.0 |
src/main/kotlin/com/dmc/advent2022/Day12.kt | dorienmc | 576,916,728 | false | {"Kotlin": 86239} | //--- Day 12: Hill Climbing Algorithm ---
package com.dmc.advent2022
import java.util.*
class Day12 : Day<Int> {
override val index = 12
override fun part1(input: List<String>): Int {
val heightmap = parseInput(input)
return heightmap.shortestPath(heightmap.start, heightmap.end)!!
}
override fun part2(input: List<String>): Int {
val heightmap = parseInput(input)
val startPoints = heightmap.elevations.filter { it.value == 0 }.map { it.key }
return startPoints.map{ heightmap.shortestPath(it, heightmap.end) }.filterNotNull().min()
}
class Heightmap(val elevations : Map<Point2D, Int>, val start: Point2D, val end: Point2D) {
fun shortestPath(begin: Point2D, end: Point2D) : Int? {
val queue = PriorityQueue<Path>().apply { add(Path(begin, 0)) }
val explored = mutableSetOf<Point2D>()
// BFS
while (queue.isNotEmpty()) {
val nextPoint = queue.poll()
if(nextPoint.point !in explored) {
explored.add(nextPoint.point)
val neighbours = nextPoint.point.friendlyNeighbours()
val nextCost = nextPoint.cost + 1
// If neighbour is goal then we are almost there
if (neighbours.any { it == end }) return nextCost
// Otherwise, keep on looking
queue.addAll(neighbours.map { Path(it, nextCost) })
}
}
// No path found
return null
// throw IllegalStateException("No valid path from $start to $end")
}
fun canMove(from: Point2D, to: Point2D) : Boolean {
return (elevations.getValue(to) - elevations.getValue(from)) <= 1
}
private fun Point2D.friendlyNeighbours() : List<Point2D> {
return this.cardinalNeighbors()
.filter { it in elevations }
.filter { canMove(this, it) }
}
fun getFriendlyNeighbours(point: Point2D) : List<Point2D> {
return point.friendlyNeighbours()
}
}
class Path(val point: Point2D, val cost: Int) : Comparable<Path> {
override fun compareTo(other: Path): Int =
this.cost.compareTo(other.cost)
}
fun parseInput(input: List<String>) : Heightmap {
var start: Point2D? = null
var end: Point2D? = null
val elevations = input.flatMapIndexed { x, line ->
line.mapIndexed{ y, elem ->
val here = Point2D(x, y)
here to when (elem) {
'S' -> 0.also { start = here }
'E' -> 25.also { end = here }
else -> elem - 'a'
}
}
}.toMap()
return Heightmap(elevations, start!!, end!!)
}
}
fun main() {
val day = Day12()
// test if implementation meets criteria from the description, like:
val testInput = readInput(day.index, true)
check(day.part1(testInput) == 0)
val input = readInput(day.index)
day.part1(input).println()
day.part2(testInput)
day.part2(input).println()
}
| 0 | Kotlin | 0 | 0 | 207c47b47e743ec7849aea38ac6aab6c4a7d4e79 | 3,220 | aoc-2022-kotlin | Apache License 2.0 |
src/main/day16/day16.kt | rolf-rosenbaum | 572,864,107 | false | {"Kotlin": 80772} | package day16
import kotlin.math.max
import readInput
const val START = "AA"
val flowRegex = """(\d+)""".toRegex()
val valveRegex = """[A-Z]{2}""".toRegex()
var totalTime = 30
var maxPressureRelease = 0
var allValves: Map<String, Valve> = mapOf()
var shortestPaths: MutableMap<String, MutableMap<String, Int>> = mutableMapOf()
fun main() {
val input = readInput("main/day16/Day16_test")
println(part1(input))
println(part2(input))
}
fun part1(input: List<String>): Int {
prepareSearch(input)
checkAllPaths(0, START, emptySet(), 0)
return maxPressureRelease
}
fun part2(input: List<String>): Int {
totalTime = 26
prepareSearch(input)
checkAllPaths(0, START, emptySet(), 0, true)
return maxPressureRelease
}
private fun prepareSearch(input: List<String>) {
maxPressureRelease = 0
val valves = input.map { it.parse() }
allValves = valves.associateBy { it.id }
shortestPaths =
shortestPathsFromEachTunnelToAllOtherTunnels(
valves.associate {
it.id to it.neighbouringValves.associateWith { 1 }
.toMutableMap()
}.toMutableMap()
)
}
private fun checkAllPaths(currentPressureRelease: Int, currentValveId: String, visited: Set<String>, time: Int, withElefant: Boolean = false) {
maxPressureRelease = max(maxPressureRelease, currentPressureRelease)
shortestPaths[currentValveId]!!.forEach { (valveId, distance) ->
if (!visited.contains(valveId) && time + distance + 1 < totalTime) {
checkAllPaths(
currentPressureRelease = currentPressureRelease + (totalTime - time - distance - 1) * allValves[valveId]?.flow!!,
currentValveId = valveId,
visited = visited + valveId,
time = time + distance + 1,
withElefant = withElefant
)
}
}
if (withElefant) {
checkAllPaths(currentPressureRelease, START, visited, 0, false)
}
}
private fun shortestPathsFromEachTunnelToAllOtherTunnels(shortestPaths: MutableMap<String, MutableMap<String, Int>>): MutableMap<String, MutableMap<String, Int>> {
shortestPaths.keys.forEach { a ->
shortestPaths.keys.forEach { b ->
shortestPaths.keys.forEach { c ->
val ab = shortestPaths[b]?.get(a) ?: 100
val ac = shortestPaths[a]?.get(c) ?: 100
val bc = shortestPaths[b]?.get(c) ?: 100
if (ab + ac < bc)
shortestPaths[b]?.set(c, ab + ac)
}
}
}
shortestPaths.values.forEach {
it.keys.mapNotNull { key -> if (allValves[key]?.flow == 0) key else null }
.forEach { uselessValve ->
it.remove(uselessValve)
}
}
return shortestPaths
}
fun String.parse(): Valve {
val valves = valveRegex.findAll(this).map { it.groupValues.first() }.toList()
val flow = flowRegex.findAll(this).first().groupValues.first().toInt()
val tunnels = valves.drop(1)
return Valve(id = valves.first(), flow = flow, neighbouringValves = tunnels)
}
data class Valve(val id: String, val flow: Int, val neighbouringValves: List<String>)
| 0 | Kotlin | 0 | 2 | 59cd4265646e1a011d2a1b744c7b8b2afe482265 | 3,209 | aoc-2022 | Apache License 2.0 |
src/year2023/day07/Solution.kt | TheSunshinator | 572,121,335 | false | {"Kotlin": 144661} | package year2023.day07
import arrow.core.NonEmptyList
import arrow.core.identity
import arrow.core.nonEmptyListOf
import arrow.core.toNonEmptyListOrNull
import utils.ProblemPart
import utils.readInputs
import utils.runAlgorithm
fun main() {
val (realInput, testInputs) = readInputs(2023, 7)
runAlgorithm(
realInput = realInput,
testInputs = testInputs,
part1 = ProblemPart(
expectedResultsForTests = nonEmptyListOf(6440),
algorithm = ::part1,
),
part2 = ProblemPart(
expectedResultsForTests = nonEmptyListOf(5905),
algorithm = ::part2,
),
)
}
private fun parse(
input: List<String>,
jValue: Int,
type: (List<Int>) -> HandType,
): List<PokerHand> = input.map { line ->
val (hand, bid) = line.split(' ')
val cards = hand.map {
when (it) {
in '2'..'9' -> it - '2' + 2
'T' -> 10
'J' -> jValue
'Q' -> 12
'K' -> 13
else -> 14
}
}.toNonEmptyListOrNull()!!
PokerHand(
cards,
type(cards),
bid.toLong(),
)
}
private fun part1(input: List<String>): Long = algorithm(
input = input,
jValue = 11,
parseHandType = {
it.groupingBy(::identity)
.eachCount()
.toHandType()
},
)
private fun algorithm(
input: List<String>,
jValue: Int,
parseHandType: (List<Int>) -> HandType,
): Long {
return parse(
input,
jValue = jValue,
type = parseHandType,
)
.asSequence()
.sortedWith(
compareByDescending<PokerHand> { it.type }
.thenComparator { a, b ->
a.cards.asSequence()
.zip(b.cards.asSequence()) { cardA, cardB -> cardA.compareTo(cardB) }
.first { it != 0 }
}
)
.withIndex()
.sumOf { (index, hand) -> (index + 1) * hand.bid }
}
private fun part2(input: List<String>): Long = algorithm(
input = input,
jValue = 1,
parseHandType = { hand ->
val cardCounts = hand.groupingBy(::identity).eachCount()
val adjustedHand = cardCounts[1]?.let { jokerCount ->
val bestCard = cardCounts.entries
.filterNot { it.key == 1 }
.maxByOrNull { it.value }
?.key
if (bestCard == null) cardCounts
else cardCounts.asSequence()
.filterNot { it.key == 1 }
.associate { (key, count) -> key to if (key == bestCard) count + jokerCount else count }
} ?: cardCounts
adjustedHand.toHandType()
},
)
private fun Map<Int, Int>.toHandType() = when (size) {
1 -> HandType.Five
2 -> if (containsValue(4)) HandType.Four else HandType.FullHouse
3 -> if (containsValue(3)) HandType.Three else HandType.TwoPairs
4 -> HandType.OnePair
else -> HandType.One
}
private data class PokerHand(
val cards: NonEmptyList<Int>,
val type: HandType,
val bid: Long,
)
enum class HandType { Five, Four, FullHouse, Three, TwoPairs, OnePair, One }
| 0 | Kotlin | 0 | 0 | d050e86fa5591447f4dd38816877b475fba512d0 | 3,169 | Advent-of-Code | Apache License 2.0 |
src/main/kotlin/aoc2023/Day13.kt | Ceridan | 725,711,266 | false | {"Kotlin": 110767, "Shell": 1955} | package aoc2023
class Day13 {
fun part1(input: String): Long = parseInput(input)
.map { mirrorPattern ->
calculateReflection(mirrorPattern.rows) to calculateReflection(mirrorPattern.cols)
}
.sumOf { (r, c) -> r * 100L + c }
fun part2(input: String): Long = parseInput(input)
.map { mirrorPattern ->
calculateReflectionWithSmudge(mirrorPattern.rows) to calculateReflectionWithSmudge(mirrorPattern.cols)
}
.sumOf { (r, c) -> r * 100L + c }
private fun calculateReflection(pattern: List<Long>): Int {
val candidateIndexes = pattern.zipWithNext().withIndex()
.filter { (_, pair) -> (pair.first xor pair.second) == 0L }
.map { (idx, _) -> idx }
candidates@ for (idx in candidateIndexes) {
val iRange = idx - 1 downTo 0
val jRange = idx + 2..<pattern.size
for ((i, j) in iRange.zip(jRange)) {
if ((pattern[i] xor pattern[j]) > 0L) continue@candidates
}
return idx + 1
}
return 0
}
private fun calculateReflectionWithSmudge(pattern: List<Long>): Int {
val candidates = pattern.zipWithNext()
.map { (it.first xor it.second).countOneBits() }
.withIndex()
.filter { (_, diff) -> diff <= 1 }
candidates@ for ((idx, diff) in candidates) {
var hasSmudge = diff == 1
val iRange = idx - 1 downTo 0
val jRange = idx + 2..<pattern.size
for ((i, j) in iRange.zip(jRange)) {
val nextDiff = (pattern[i] xor pattern[j]).countOneBits()
if ((nextDiff > 1) || (nextDiff == 1 && hasSmudge)) continue@candidates
if (nextDiff == 1) hasSmudge = true
}
if (hasSmudge) {
return idx + 1
}
}
return 0
}
private fun parseInput(input: String): List<MirrorPattern> {
val lines = (input + "\n").split('\n')
val mirrorPatterns = mutableListOf<MirrorPattern>()
var pattern = mutableListOf<String>()
for (line in lines) {
if (line.isNotEmpty()) {
val binaryLine = line.replace('.', '0').replace('#', '1')
pattern.add(binaryLine)
} else if (pattern.isNotEmpty()) {
mirrorPatterns.add(MirrorPattern(pattern))
pattern = mutableListOf()
}
}
return mirrorPatterns
}
data class MirrorPattern(val pattern: List<String>) {
val rows = pattern.map { it.toLong(2) }
val cols = transpose().map { it.toLong(2) }
private fun transpose(): List<String> {
val rows = pattern.size
val cols = pattern[0].length
return List(cols) { j -> String(CharArray(rows) { i -> pattern[i][j] }) }
}
}
}
fun main() {
val day13 = Day13()
val input = readInputAsString("day13.txt")
println("13, part 1: ${day13.part1(input)}")
println("13, part 2: ${day13.part2(input)}")
}
| 0 | Kotlin | 0 | 0 | 18b97d650f4a90219bd6a81a8cf4d445d56ea9e8 | 3,104 | advent-of-code-2023 | MIT License |
src/day9/d9_2.kt | svorcmar | 720,683,913 | false | {"Kotlin": 49110} | fun main() {
val input = ""
val edges = input.lines().map { parseEdge(it) }.flatMap { e -> listOf(e, Edge(e.to, e.from, e.distance)) }
val nodes = edges.map { e -> e.from }.toSet()
val nodeToIdx = nodes.toList().sorted().mapIndexed { i, n -> n to i }.toMap()
val edgesMap = edges.groupBy { e -> nodeToIdx[e.from]!! }
.mapValues() { (_, v) -> v.groupBy { e -> nodeToIdx[e.to]!!}.mapValues { (_, v2) -> v2[0].distance } }
println(forEachPermutation(nodes.size) { arr -> computeLength(arr, edgesMap) }.min())
}
data class Edge(val from: String, val to: String, val distance: Int)
fun parseEdge(string: String): Edge =
string.split(" ").let { Edge(it[0], it[2], it[4].toInt()) }
fun computeLength(arr: Array<Int>, map: Map<Int, Map<Int, Int>>): Int {
return arr.toList().windowed(2).map { it[0] to it[1] }.fold(0) { acc, (from, to) -> acc + map[from]!![to]!! }
}
fun <T> forEachPermutation(n: Int, f: (Array<Int>) -> T): List<T> {
val arr = Array<Int>(n) { 0 }
return genRecursive(arr, 0, (0 until n).toSet(), f)
}
fun <T> genRecursive(arr: Array<Int>, nextIdx: Int, options: Set<Int>, f: (Array<Int>) -> T): List<T> {
if (nextIdx == arr.size) {
return listOf(f(arr))
}
val result = mutableListOf<T>()
for (opt in options) {
arr[nextIdx] = opt
result.addAll(genRecursive(arr, nextIdx + 1, options - opt, f))
}
return result
}
| 0 | Kotlin | 0 | 0 | cb097b59295b2ec76cc0845ee6674f1683c3c91f | 1,382 | aoc2015 | MIT License |
src/day03/Day03.kt | martinhrvn | 724,678,473 | false | {"Kotlin": 27307, "Jupyter Notebook": 1336} | package day03
import println
import readInput
enum class Direction {
BEFORE,
AFTER
}
fun String.intVal(): Int {
return this.toIntOrNull() ?: 0
}
fun List<String>.sum(): Int {
return this.sumOf { it.intVal() }
}
typealias Coordinates = Pair<Int, Int>
typealias NumberMap = Map<Coordinates, Int>
class PartParser(private val input: List<String>) {
fun part1(): Int {
return input
.flatMapIndexed { x, row ->
row.mapIndexed { y, c ->
if (!c.isDigit() && c != '.') {
getNumbersAround(x, y)
} else {
mapOf()
}
}
}
.sumOf { it.values.sum() }
}
fun part2(): Int {
return input
.flatMapIndexed { x, row ->
row.mapIndexed { y, c ->
if (!c.isDigit() && c != '.') {
val partNumbers = getNumbersAround(x, y)
if (partNumbers.size == 2) {
partNumbers.entries.fold(1) { acc, e -> acc * e.value }
} else {
0
}
} else {
0
}
}
}
.sum()
}
private fun getNumbersAround(x: Int, y: Int): NumberMap {
val before = takeNumberAt(x, y, Direction.BEFORE)
val after = takeNumberAt(x, y, Direction.AFTER)
return mapOf(
Pair(x, y - before.length) to before.intVal(),
Pair(x, y + 1) to after.intVal(),
)
.plus(takeVertically(x - 1, y))
.plus(takeVertically(x + 1, y))
.filter { (_, v) -> v != 0 }
}
private fun takeNumberAt(x: Int, y: Int, direction: Direction): String {
return input[x]
.let { row ->
if (direction == Direction.BEFORE) {
row.slice(0 ..< y).reversed()
} else {
row.slice((y + 1) ..< row.length)
}
}
.takeWhile { ch -> ch.isDigit() }
.let {
if (direction == Direction.BEFORE) {
it.reversed()
} else {
it
}
}
}
private fun takeVertically(x: Int, y: Int): NumberMap {
if (x < 0 || x >= input.size) {
return mapOf()
}
val before = takeNumberAt(x, y, Direction.BEFORE)
val after = takeNumberAt(x, y, Direction.AFTER)
return if (input[x][y].isDigit()) {
mapOf(Pair(x, y - before.length) to before.plus(input.get(x)[y]).plus(after).intVal())
} else {
mapOf(Pair(x, y - before.length) to before.intVal(), Pair(x, y + 1) to after.intVal())
}
}
}
fun main() {
val testInput = readInput("day03/Day03_test")
println(PartParser(testInput).part1())
check(PartParser(testInput).part1() == 4361)
check(PartParser(testInput).part2() == 467835)
val cube = PartParser(readInput("day03/Day03"))
cube.part1().println()
cube.part2().println()
}
| 0 | Kotlin | 0 | 0 | 59119fba430700e7e2f8379a7f8ecd3d6a975ab8 | 2,829 | advent-of-code-2023-kotlin | Apache License 2.0 |
src/main/kotlin/biz/koziolek/adventofcode/year2021/day04/day4.kt | pkoziol | 434,913,366 | false | {"Kotlin": 715025, "Shell": 1892} | package biz.koziolek.adventofcode.year2021.day04
import biz.koziolek.adventofcode.findInput
fun main() {
val inputFile = findInput(object {})
val lines = inputFile.bufferedReader().readLines()
val moves = readMoves(lines)
val boards = readBoards(lines)
val wonBoards = playBingo(moves, boards)
println("First won board score: ${wonBoards.first().score}")
println("Last won board score: ${wonBoards.last().score}")
}
fun playBingo(moves: List<Int>, boards: List<Board>): List<WonBoard> {
val initial = Pair<List<Board>, List<WonBoard>>(boards, emptyList())
return moves.fold(initial) { (currentBoards, winningBoards), move ->
val updatedBoards = currentBoards.map { it.mark(move) }
val (boardsInProgress, boardsThatWon) = updatedBoards.partition { it.getFullyMarkedRowsOrColumns().isEmpty() }
Pair(boardsInProgress, winningBoards + boardsThatWon.map { WonBoard(it, it.score(move)) })
}.second
}
fun readMoves(lines: List<String>): List<Int> = lines[0].split(',').map { it.toInt() }
data class WonBoard(val board: Board,
val score: Int)
data class Board(val size: Int,
val rows: List<BoardCells>) {
val cols: List<BoardCells>
get() = (0 until size).map { i -> BoardCells(cells = rows.map { it[i] }) }
operator fun get(i: Int) = rows[i]
fun mark(value: Int): Board =
copy(rows = rows.map { it.mark(value) })
fun getFullyMarkedRowsOrColumns() =
(rows + cols).filter { it.cells.all { cell -> cell.marked } }
fun score(lastValueMarked: Int): Int {
val unmarkedValues = rows.flatMap { row ->
row.cells
.filter { cell -> !cell.marked }
.map { cell -> cell.value }
}
return unmarkedValues.sum() * lastValueMarked
}
}
data class BoardCells(val cells: List<Cell>) {
operator fun get(i: Int) = cells[i]
fun mark(value: Int): BoardCells =
copy(cells = cells.map { it.copy(marked = it.marked || it.value == value) })
}
data class Cell(val value: Int,
val marked: Boolean)
fun readBoards(lines: List<String>): List<Board> {
val boardSize = parseCells(lines[2]).size
return lines
.asSequence()
.drop(2)
.filter { it.isNotBlank() }
.chunked(boardSize)
.map { Board(size = boardSize, rows = parseRows(it)) }
.toList()
}
private fun parseRows(lines: List<String>): List<BoardCells> =
lines.asSequence()
.map { BoardCells(cells = parseCells(it)) }
.toList()
private fun parseCells(line: String) =
line.trim()
.split(Regex(" +"))
.map { Cell(it.toInt(), false) }
.toList()
| 0 | Kotlin | 0 | 0 | 1b1c6971bf45b89fd76bbcc503444d0d86617e95 | 2,818 | advent-of-code | MIT License |
src/commonMain/kotlin/advent2020/day21/Day21Puzzle.kt | jakubgwozdz | 312,526,719 | false | null | package advent2020.day21
data class Food(val ingredients: List<String>, val allergens: List<String>)
fun part1(input: String): String {
val foods = foods(input)
val ingredients = foods.map { it.ingredients }.flatten()
val unsafe = matches(foods).values.reduce(Set<String>::plus)
val safe = ingredients.filterNot { it in unsafe }.toSet()
val result = ingredients.count { it in safe }
return result.toString()
}
fun part2(input: String): String {
val foods = foods(input)
val matches = matches(foods).mapValues { it.value.toMutableSet() }
var again = true
while (again) {
again = false
val knownUnsafeIngredients = matches
.mapNotNull { (allergen, ingredients) -> ingredients.singleOrNull()?.let { allergen to it } }
knownUnsafeIngredients
.forEach { (allergen, ingredient) ->
matches.forEach { (a2, i2) ->
if (a2 != allergen && ingredient in i2) i2 -= ingredient.also { again = true }
}
}
}
return matches.entries.sortedBy { it.key }.joinToString(",") { it.value.single() }
}
private fun matches(foods: List<Food>) = foods
.map { (ingredients, allergens) ->
allergens.map { it to ingredients.toSet() }.toMap()
}
.reduce { acc, next ->
val keys = acc.keys + next.keys
keys.associateWith {
val s1 = acc[it]
val s2 = next[it]
when {
s1 == null -> s2!!
s2 == null -> s1
else -> s1.intersect(s2)
}
}
}
val regex by lazy { """((\w+ )+)\(contains ((\w+(, )?)+)\)""".toRegex() }
private fun foods(input: String): List<Food> =
input.trim().lines()
.map { regex.matchEntire(it)?.destructured ?: error("`$it` doesn't match") }
.map { (gr1, _, gr3) ->
val ingredients = gr1.split(" ").filter { it.isNotBlank() }
val allergens = gr3.split(", ").filter { it.isNotBlank() }
Food(ingredients, allergens)
}
| 0 | Kotlin | 0 | 2 | e233824109515fc4a667ad03e32de630d936838e | 2,070 | advent-of-code-2020 | MIT License |
src/Day08.kt | thorny-thorny | 573,065,588 | false | {"Kotlin": 57129} | fun main() {
fun part1(input: List<String>): Int {
var visibleTreesInside = (1 until input.lastIndex).sumOf { rowIndex ->
val row = input[rowIndex]
(1 until row.lastIndex).count { columnIndex ->
val tree = row[columnIndex]
when {
(0 until columnIndex).all { tree > row[it] } -> true
((columnIndex + 1)..row.lastIndex).all { tree > row[it] } -> true
(0 until rowIndex).all { tree > input[it][columnIndex] } -> true
((rowIndex + 1)..input.lastIndex).all { tree > input[it][columnIndex] } -> true
else -> false
}
}
}
return visibleTreesInside + (input.size + input.first().length - 2) * 2
}
fun part2(input: List<String>): Int {
val insideWidth = input.size - 2
val insideHeight = input.first().length - 2
val totalTreesInside = insideWidth * insideHeight
return (0 until totalTreesInside).maxOf { index ->
val row = index / insideWidth + 1
val column = index % insideWidth + 1
val tree = input[row][column]
val leftTrees = (1..column).firstNotNullOfOrNull {
if (input[row][column - it] >= tree) it else null
} ?: column
val rightTrees = (1 until (input.first().length - column)).firstNotNullOfOrNull {
if (input[row][column + it] >= tree) it else null
} ?: (input.first().length - column - 1)
val topTrees = (1..row).firstNotNullOfOrNull {
if (input[row - it][column] >= tree) it else null
} ?: row
val bottomTrees = (1 until (input.size - row)).firstNotNullOfOrNull {
if (input[row + it][column] >= tree) it else null
} ?: (input.size - row - 1)
// println("$row:$column $leftTrees, $rightTrees, $topTrees, $bottomTrees")
// println(leftTrees * rightTrees * topTrees * bottomTrees)
leftTrees * rightTrees * topTrees * bottomTrees
}
}
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 843869d19d5457dc972c98a9a4d48b690fa094a6 | 2,334 | aoc-2022 | Apache License 2.0 |
src/main/kotlin/aoc2023/Day12.kt | Ceridan | 725,711,266 | false | {"Kotlin": 110767, "Shell": 1955} | package aoc2023
class Day12 {
fun part1(input: String): Long {
val (rows, groups) = parseInput(input)
return rows.zip(groups).sumOf { (r, c) -> calculateArrangements(r, c) }
}
fun part2(input: String): Long {
val (rows, groups) = parseInput(input)
val expandedRows = rows.map { "$it?".repeat(5).dropLast(1) }
val expandedGroups = groups.map { group ->
group.joinToString(separator = ",", postfix = ",").repeat(5).dropLast(1).split(',').map { it.toInt() }
}
return expandedRows.zip(expandedGroups).sumOf { (r, c) -> calculateArrangements(r, c) }
}
private fun calculateArrangements(
pattern: String,
groups: List<Int>,
rowIdx: Int = 0,
colIdx: Int = 0,
cache: MutableMap<Pair<Int, Int>, Long> = mutableMapOf()
): Long {
val hashIdx = pattern.drop(rowIdx).indexOf('#')
if (colIdx == groups.size) {
return if (hashIdx == -1) 1L else 0L
}
return pattern.drop(rowIdx).windowed(groups[colIdx], 1).withIndex()
.filter { (i, window) ->
if (window.any { it == '.' }) return@filter false
if (hashIdx > -1 && i > hashIdx) return@filter false
val leftIdx = rowIdx + i
val leftDot = leftIdx == 0 || pattern[leftIdx - 1] == '.' || pattern[leftIdx - 1] == '?'
val rightIdx = rowIdx + window.length + i
val rightDot = (rightIdx == pattern.length) || pattern[rightIdx] == '.' || pattern[rightIdx] == '?'
leftDot && rightDot
}
.sumOf { (i, window) ->
val newRowIdx = rowIdx + window.length + i + 1
val newColIdx = colIdx + 1
cache.getOrPut(newRowIdx to newColIdx) {
calculateArrangements(
pattern,
groups,
newRowIdx,
newColIdx,
cache
)
}
}
}
private fun parseInput(input: String): Pair<List<String>, List<List<Int>>> {
val rows = mutableListOf<String>()
val groups = mutableListOf<List<Int>>()
val lines = input.split('\n').filter { it.isNotEmpty() }
for (line in lines) {
val (rowString, groupString) = line.split(' ')
rows.add(rowString)
groups.add(groupString.split(',').map { it.toInt() })
}
return rows to groups
}
}
fun main() {
val day12 = Day12()
val input = readInputAsString("day12.txt")
println("12, part 1: ${day12.part1(input)}")
println("12, part 2: ${day12.part2(input)}")
}
| 0 | Kotlin | 0 | 0 | 18b97d650f4a90219bd6a81a8cf4d445d56ea9e8 | 2,752 | advent-of-code-2023 | MIT License |
src/Day08.kt | JanTie | 573,131,468 | false | {"Kotlin": 31854} | data class Tree(
val height: Int,
val allToTheLeft: List<Int>,
val allToTheTop: List<Int>,
val allToTheRight: List<Int>,
val allToTheBottom: List<Int>,
) {
val isVisible: Boolean
get() = listOf(allToTheLeft, allToTheTop, allToTheRight, allToTheBottom)
.any { direction -> direction.all { it < height } || direction.isEmpty() }
val scenicScore: Int
get() = listOf(allToTheLeft, allToTheTop, allToTheRight, allToTheBottom)
.map { direction ->
direction.indexOfFirst { it >= height }.takeIf { it != -1 }?.let { it + 1 } ?: direction.size
}
.fold(1) { currentScore, direction -> currentScore * direction }
}
fun main() {
fun parseInput(input: List<String>): List<Tree> {
val map = input.map { it.toCharArray().map { it.digitToInt() } }
val mapHeight = map.size
val mapWidth = map[0].size
// A kiss right on the eye
return (0 until mapWidth).map { x ->
(0 until mapHeight).map { y ->
Tree(
map[y][x],
allToTheLeft = (0 until x).reversed().map { readX -> map[y][readX] },
allToTheRight = (x + 1 until mapWidth).map { readX -> map[y][readX] },
allToTheTop = (0 until y).reversed().map { readY -> map[readY][x] },
allToTheBottom = (y + 1 until mapHeight).map { readY -> map[readY][x] },
)
}
}.flatten()
}
fun part1(input: List<String>): Int {
return parseInput(input).filter { it.isVisible }.size
}
fun part2(input: List<String>): Int {
return parseInput(input).maxOf { it.scenicScore }
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 3452e167f7afe291960d41b6fe86d79fd821a545 | 2,015 | advent-of-code-2022 | Apache License 2.0 |
src/main/kotlin/twentytwentytwo/Day8.kt | JanGroot | 317,476,637 | false | {"Kotlin": 80906} | package twentytwentytwo
import twentytwentytwo.Structures.Point2d
import kotlin.math.sqrt
typealias Tree = Pair<Point2d, Int>
fun main() {
val input = {}.javaClass.getResource("input-8.txt")!!.readText().linesFiltered { it.isNotEmpty() };
val day = Day8(input)
val columns = (0 until input[0].length).map { index -> input.map { it[index].digitToInt() } }.also { println(it) }
val rows = (input.indices).map { index -> input[index].map { it.digitToInt() } }.also { println(it) }
val size = sqrt(input.joinToString(separator = "") { it }.length.toDouble()).toInt()
println(size)
val trees = input.joinToString(separator = "") { it }.mapIndexed { index, c ->
val x = index / size
val y = index % size
Tree(Point2d(x, y), c.digitToInt())
}
trees.forEach { println("${it.first.x},${it.first.y} ${it.second}") }
println(size)
println(day.part1())
println(day.part2())
}
class Day8(input: List<String>) {
private val trees = input.mapIndexed { y, row ->
row.mapIndexed { x, s -> Tree(Point2d(x, y), s.digitToInt()) }
}.flatten()
init {
trees.forEach { (point) ->
rows.computeIfAbsent(point.y) { trees.filter { it.first.sameRow(point) } }
columns.computeIfAbsent(point.x) { trees.filter { it.first.sameColumn(point) } }
}
}
fun part1() = trees.filter { it.visible() }.size
fun part2() = trees.maxOf { it.sees() }
companion object {
private val rows = mutableMapOf<Int, List<Tree>>()
private val columns = mutableMapOf<Int, List<Tree>>()
fun Tree.sees(): Int {
val (left, right, above, under) = getLines()
return countVisibleTrees(left.reversed()) * countVisibleTrees(right) * countVisibleTrees(under) * countVisibleTrees(
above.reversed()
)
}
fun Tree.visible() = edge() || getLines().any { isBiggest(it) }
// check if we reached the end otherwise add 1. (should have a takeWhileInclusive or something)
private fun Tree.countVisibleTrees(trees: List<Tree>) = trees.takeWhile { it.second < second }.count()
.let { count -> if (count == trees.size) count else count + 1 }
private fun Tree.getLines() = rows[first.y]!!.split(this.first.x) + columns[first.x]!!.split(this.first.y)
private fun List<Tree>.split(number: Int) = listOf(take(number), takeLast(size - number - 1))
private fun Tree.isBiggest(trees: List<Tree>) = trees.all { it.second < second }
private fun Tree.edge() = first.x == 0 || first.x == columns.size || first.y == 0 || first.y == rows.size
}
}
| 0 | Kotlin | 0 | 0 | 04a9531285e22cc81e6478dc89708bcf6407910b | 2,677 | aoc202xkotlin | The Unlicense |
aoc-2021/src/main/kotlin/nerok/aoc/aoc2021/day08/Day08.kt | nerok | 572,862,875 | false | {"Kotlin": 113337} | package nerok.aoc.aoc2021.day08
import nerok.aoc.utils.Input
import java.util.*
import kotlin.time.DurationUnit
import kotlin.time.measureTime
fun main() {
fun predictPairs(x: List<SortedSet<Char>>): MutableMap<SortedSet<Char>, Int> {
val map = x.associateWith { -1 }.toMutableMap()
map.forEach {
when (it.key.size) {
2 -> {
map[it.key] = 1
}
3 -> {
map[it.key] = 7
}
4 -> {
map[it.key] = 4
}
7 -> {
map[it.key] = 8
}
else -> {
}
}
}
map.filter { it.key.size == 6 }.forEach {
if (it.key.containsAll(map.filterValues { it == 4 }.keys.first())) {
map[it.key] = 9
} else if (it.key.containsAll(map.filterValues { it == 1 }.keys.first())) {
map[it.key] = 0
} else {
map[it.key] = 6
}
}
map.filter { it.value == -1 }.forEach {
if (it.key.containsAll(map.filterValues { it == 7 }.keys.first())) {
map[it.key] = 3
} else if (map.filterValues { it == 9 }.keys.first().containsAll(it.key)) {
map[it.key] = 5
} else {
map[it.key] = 2
}
}
return map
}
fun part1(input: List<String>): Long {
val countArray = IntArray(8) { 0 }
input.map { line ->
line.split(" | ").map { it.split(" ") }.let { it.first() to it.last() }
}.map { entry ->
entry.first.groupBy { it.length } to entry.second.groupBy { it.length }
}.map { it.second }.forEach {
it.forEach {
countArray[it.key] += it.value.size
}
}
val countMap = countArray.mapIndexed { index, i -> index to i }.toMap()
return countMap[2]!!.plus(countMap[3]!!).plus(countMap[4]!!).plus(countMap[7]!!).toLong()
}
fun part2(input: List<String>): Long = input.map { line ->
line.split(" | ").map { it.split(" ") }.let { it.first().map { it.toSortedSet() } to it.last().map { it.toSortedSet() } }
}.sumOf {
val map = predictPairs(it.first)
Integer.parseInt(it.second.map { map[it] }.joinToString(""))
}.toLong()
// test if implementation meets criteria from the description, like:
val testInput = Input.readInput("Day08_test")
check(part1(testInput) == 26L)
check(part2(testInput) == 61229L)
val input = Input.readInput("Day08")
println(measureTime { println(part1(input)) }.toString(DurationUnit.SECONDS, 3))
println(measureTime { println(part2(input)) }.toString(DurationUnit.SECONDS, 3))
}
| 0 | Kotlin | 0 | 0 | 7553c28ac9053a70706c6af98b954fbdda6fb5d2 | 2,867 | AOC | Apache License 2.0 |
src/Day04.kt | george-theocharis | 573,013,076 | false | {"Kotlin": 10656} | fun main() {
fun part1(input: List<String>): Int = input
.splitByLine()
.mapToPairOfRanges()
.sumOfPairsThatOverlapEntirely()
fun part2(input: List<String>): Int = input
.splitByLine()
.mapToPairOfRanges()
.sumOfPairsThatOverlap()
val input = readInput("Day04")
println(part1(input))
println(part2(input))
}
private fun List<String>.splitByLine(): List<List<String>> = map { line ->
line.split(',')
}
private fun List<List<String>>.mapToPairOfRanges(): List<Pair<IntRange, IntRange>> = map { elfGroup ->
val elfARange = elfGroup[0].split('-')
val elfBRange = elfGroup[1].split('-')
(elfARange[0].toInt()..elfARange[1].toInt()) to (elfBRange[0].toInt()..elfBRange[1].toInt())
}
private fun List<Pair<IntRange, IntRange>>.sumOfPairsThatOverlapEntirely() = sumOf { (elfARange, elfBRange) ->
val addition: Int =
if (elfARange.contains(elfBRange.first) && elfARange.contains(elfBRange.last) || elfBRange.contains(
elfARange.first
) && elfBRange.contains(elfARange.last)
) 1 else 0
addition
}
private fun List<Pair<IntRange, IntRange>>.sumOfPairsThatOverlap() = sumOf { (elfARange, elfBRange) ->
val addition: Int = if(elfARange.any { elfBRange.contains(it) } || elfBRange.any { elfARange.contains(it) }) 1 else 0
addition
}
| 0 | Kotlin | 0 | 0 | 7971bea39439b363f230a44e252c7b9f05a9b764 | 1,369 | aoc-2022 | Apache License 2.0 |
Advent-of-Code-2023/src/Day02.kt | Radnar9 | 726,180,837 | false | {"Kotlin": 93593} | private const val AOC_DAY = "Day02"
private const val PART1_TEST_FILE = "${AOC_DAY}_test_part1"
private const val PART2_TEST_FILE = "${AOC_DAY}_test_part2"
private const val INPUT_FILE = AOC_DAY
private const val MAX_COLORS = 3
private data class Cube(val value: Int, val color: String)
private val maxCubes = mapOf("red" to 12, "green" to 13, "blue" to 14)
/**
* Finds the games that use a number of cubes from a specific color that is greater than the maximum cubes of that color
* specified by the maxCubes map.
* @return the gameID of the games that use a possible number of cubes for each color according to the maxCubes map.
*/
private fun part1(input: List<String>): Int {
return input.sumOf { game ->
val (gameId, cubes) = parseCubes(game)
var isImpossible = false
for (cube in cubes) {
if (cube.value > maxCubes[cube.color]!!) {
isImpossible = true
break
}
}
if (isImpossible) 0 else gameId
}
}
private fun part1Improved(input: List<String>): Int {
return input.filter { game ->
val (_, cubes) = parseCubes(game)
cubes.none { cube -> cube.value > maxCubes[cube.color]!! }
// cubes.all { cube -> cube.value <= maxCubes[cube.color]!! } // alternative
}.sumOf { it.split(":")[0].split(" ")[1].toInt() }
}
/**
* Finds the maximum number of cubes by color used in a set of a game, multiplies them, and sums the result with the
* results of the other games.
* Obs: I sorted the array in hope of not needing to iterate through all cubes, an alternative easy approach would be
* to instead of sorting the array, storing the max value and compare each cube value with the previous max
* @return the sum of the product of the number of cubes for each color in each game
*/
private fun part2(input: List<String>): Int {
return input.sumOf { game ->
val (_, cubes) = parseCubes(game)
val sortedCubes = cubes.sortedByDescending { cube -> cube.value }
val cubesValues = HashMap<String, Int>()
for (cube in sortedCubes) {
cubesValues.putIfAbsent(cube.color, cube.value)
if (cubesValues.size == MAX_COLORS) break
}
cubesValues.values.reduce(Int::times)
}
}
private fun part2WithoutOrdering(input: List<String>): Int {
return input.sumOf { game ->
val (_, cubes) = parseCubes(game)
val cubesValues = mutableMapOf("red" to 0, "blue" to 0, "green" to 0)
for (cube in cubes) {
if (cubesValues[cube.color]!! >= cube.value) continue
cubesValues[cube.color] = cube.value
}
cubesValues.values.reduce(Int::times)
}
}
/**
* Auxiliary function to parse the cubes from each game.
* @return a pair with the game id and its cubes.
*/
private fun parseCubes(game: String): Pair<Int, List<Cube>> {
val (gameInfo, sets) = game.split(": ")
return Pair(
gameInfo.split(" ")[1].toInt(),
sets
.split(", ", "; ")
.map {
val cube = it.split(" ")
Cube(cube[0].toInt(), cube[1])
})
}
fun main() {
val part1ExpectedRes = 8
val part1TestInput = readInputToList(PART1_TEST_FILE)
println("---| TEST INPUT |---")
println("* PART 1: ${part1(part1TestInput)}\t== $part1ExpectedRes")
println("+ PART 1: ${part1Improved(part1TestInput)}\t== $part1ExpectedRes")
val part2ExpectedRes = 2286
val part2TestInput = readInputToList(PART2_TEST_FILE)
println("* PART 2: ${part2(part2TestInput)}\t== $part2ExpectedRes\n")
val input = readInputToList(INPUT_FILE)
val improving = true
println("---| FINAL INPUT |---")
println("* PART 1: ${part1(input)}${if (improving) "\t== 2879" else ""}")
println("+ PART 1: ${part1Improved(input)}${if (improving) "\t== 2879" else ""}")
println("* PART 2: ${part2(input)}${if (improving) "\t== 65122" else ""}")
}
| 0 | Kotlin | 0 | 0 | e6b1caa25bcab4cb5eded12c35231c7c795c5506 | 3,981 | Advent-of-Code-2023 | Apache License 2.0 |
src/Day08.kt | Yasenia | 575,276,480 | false | {"Kotlin": 15232} | fun main() {
fun part1(input: List<String>): Int {
val treeMatrix = input.map { line -> line.toCharArray().map { it.digitToInt() } }
var visibleCount = 0
for (i in 1 until treeMatrix.lastIndex) {
for (j in 1 until treeMatrix[i].lastIndex) {
val height = treeMatrix[i][j]
if (
(0 until i).all { treeMatrix[it][j] < height } ||
(i + 1..treeMatrix.lastIndex).all { treeMatrix[it][j] < height } ||
(0 until j).all { treeMatrix[i][it] < height } ||
(j + 1..treeMatrix[i].lastIndex).all { treeMatrix[i][it] < height }
) visibleCount++
}
}
return visibleCount + treeMatrix.size * 2 + treeMatrix.first().size + treeMatrix.last().size - 4
}
fun part2(input: List<String>): Int {
val treeMatrix = input.map { line -> line.toCharArray().map { it.digitToInt() } }
var maxScore = 0
for (i in 1 until treeMatrix.lastIndex) {
for (j in 1 until treeMatrix[i].lastIndex) {
val height = treeMatrix[i][j]
val upScore = ((i - 1 downTo 0).takeWhile { treeMatrix[it][j] < height }.size + 1).coerceAtMost(i)
val downScore = ((i + 1..treeMatrix.lastIndex).takeWhile { treeMatrix[it][j] < height }.size + 1).coerceAtMost(treeMatrix.lastIndex - i)
val leftScore = ((j - 1 downTo 0).takeWhile { treeMatrix[i][it] < height }.size + 1).coerceAtMost(j)
val rightScore = ((j + 1..treeMatrix[i].lastIndex).takeWhile { treeMatrix[i][it] < height }.size + 1).coerceAtMost(treeMatrix[i].lastIndex - j)
maxScore = maxScore.coerceAtLeast(upScore * downScore * leftScore * rightScore)
}
}
return maxScore
}
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 9300236fa8697530a3c234e9cb39acfb81f913ba | 2,041 | advent-of-code-kotlin-2022 | Apache License 2.0 |
src/Day12.kt | kmakma | 574,238,598 | false | null | fun main() {
fun neighborsOf(coord: Coord2D, map: Map<Coord2D, Int>): List<Coord2D> {
val neighbors = mutableListOf<Coord2D>()
if (coord.x > 0) {
val newCoord = coord.moved(-1, 0)
if (map[newCoord]!! - map[coord]!! <= 1) neighbors.add(newCoord)
}
if (coord.y > 0) {
val newCoord = coord.moved(0, -1)
if (map[newCoord]!! - map[coord]!! <= 1) neighbors.add(newCoord)
}
val newCoordX = coord.moved(1, 0)
if (map.containsKey(newCoordX) && map[newCoordX]!! - map[coord]!! <= 1) neighbors.add(newCoordX)
val newCoordY = coord.moved(0, 1)
if (map.containsKey(newCoordY) && map[newCoordY]!! - map[coord]!! <= 1) neighbors.add(newCoordY)
return neighbors
}
fun printDistanceMap(distances: Map<Coord2D, Int>) {
val minX = distances.keys.minOf { it.x }
val maxX = distances.keys.maxOf { it.x }
val minY = distances.keys.minOf { it.y }
val maxY = distances.keys.maxOf { it.y }
for (x in minX..maxX) {
for (y in minY..maxY) {
val dStr = distances.getOrDefault(Coord2D(x, y), -1).toString().padStart(2, ' ')
print("$dStr | ")
}
println()
}
}
fun shortestPath(heights: Map<Coord2D, Int>, start: Coord2D, end: Coord2D): Int {
val distances = mutableMapOf(start to 0)
val queue = mutableListOf(start)
while (queue.isNotEmpty()) {
val current = queue.removeFirst()
val distance = distances[current]!!
if (current == end) {
// printDistanceMap(distances)
return distance
}
val newEntries = neighborsOf(current, heights).filter { !distances.containsKey(it) }
queue.addAll(newEntries)
distances.putAll(newEntries.map { it to distance + 1 })
}
return -1
}
fun buildHeightMap(input: List<String>): Triple<Coord2D, Coord2D, Map<Coord2D, Int>> {
lateinit var start: Coord2D
lateinit var end: Coord2D
val heights = input.flatMapIndexed { x, line ->
line.mapIndexed { y, c ->
Coord2D(x, y) to when (c) {
'E' -> {
end = Coord2D(x, y)
'z'.code - 97
}
'S' -> {
start = Coord2D(x, y)
'a'.code - 97
}
else -> c.code - 97
}
}
}.toMap()
return Triple(start, end, heights)
}
fun part1(input: List<String>): Int {
val (start, end, heights) = buildHeightMap(input)
return shortestPath(heights, start, end)
}
fun part2(input: List<String>): Int {
val (_, end, heights) = buildHeightMap(input)
return heights.filterValues { it == 0 }.keys.map { shortestPath(heights, it, end) }.filter { it > 0 }.min()
}
// val testinput = readInput("Day12_test")
// println(part1(testinput))
val input = readInput("Day12")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 950ffbce2149df9a7df3aac9289c9a5b38e29135 | 3,218 | advent-of-kotlin-2022 | Apache License 2.0 |
src/Day04.kt | hnuttin | 572,601,761 | false | {"Kotlin": 5036} | fun main() {
val pairs = readInput("Day04_test")
.map { rawPair -> rawPair.split(",") }
.map { rawPair -> Pair(toRange(rawPair[0]), toRange(rawPair[1])) };
// part1(pairs)
part2(pairs)
// print(rangeOverlaps(Pair(2, 6), Pair(4, 8)));
}
fun part2(pairs: List<Pair<Pair<Int, Int>, Pair<Int, Int>>>) {
println(pairs
.filter { pair -> rangeOverlaps(pair.first, pair.second) }
.count())
}
fun rangeOverlaps(first: Pair<Int, Int>, second: Pair<Int, Int>):Boolean {
return (first.first >= second.first && first.first <= second.second) ||
(first.second >= second.first && first.second <= second.second) ||
(first.first < second.first && first.second > second.second) ||
(second.first < first.first && second.second > first.second);
}
private fun part1(pairs: List<Pair<Pair<Int, Int>, Pair<Int, Int>>>) {
println(pairs
.filter { pair -> rangeContains(pair.first, pair.second) || rangeContains(pair.second, pair.first) }
.count())
}
fun rangeContains(first: Pair<Int, Int>, second: Pair<Int, Int>): Boolean {
return first.first <= second.first && first.second >= second.second;
}
fun toRange(rawRange: String): Pair<Int, Int> {
val startAndEnd = rawRange.split("-")
return Pair(startAndEnd[0].toInt(), startAndEnd[1].toInt());
}
| 0 | Kotlin | 0 | 0 | 53975ed6acb42858be56c2150e573cdbf3deedc0 | 1,347 | aoc-2022 | Apache License 2.0 |
src/Day15.kt | chbirmes | 572,675,727 | false | {"Kotlin": 32114} | import kotlin.math.absoluteValue
fun main() {
fun part1(input: List<String>, row: Int): Int {
val sensors = input.map { Sensor.parse(it) }
val beaconXs = sensors.map { it.closestBeaconPosition }
.filter { (_, y) -> y == row }
.map { (x, _) -> x }
.toSet()
val ranges = sensors.asSequence()
.map { it.radiusIntersectionWithLine(row) }
.filterNotNull()
.union()
return ranges.sumOf { it.size() } - beaconXs.size
}
fun part2(input: List<String>, max: Int): Long {
val sensors = input.map { Sensor.parse(it) }
val targetRange = 0..max
return targetRange.asSequence()
.map { row ->
val intersections = sensors.asSequence()
.map { it.radiusIntersectionWithLine(row) }
.filterNotNull()
.union()
intersections.asSequence()
.filter { it.last >= 0 && it.first <= max }
.takeIf { it.count() == 2 }
?.minBy { it.first }
?.let { (it.last + 1) to row }
}
.filterNotNull()
.first()
.let { (x, y) -> x.toLong() * 4_000_000L + y }
}
val testInput = readInput("Day15_test")
check(part1(testInput, row = 10) == 26)
check(part2(testInput, max = 20) == 56_000_011L)
val input = readInput("Day15")
println(part1(input, row = 2_000_000))
println(part2(input, max = 4_000_000))
}
fun positionIn(s: String): Pair<Int, Int> =
s.substringAfter("x=").substringBefore(',').toInt() to s.substringAfter("y=").toInt()
private data class Sensor(val ownPosition: Pair<Int, Int>, val closestBeaconPosition: Pair<Int, Int>) {
val radius = ownPosition.distanceTo(closestBeaconPosition)
fun radiusIntersectionWithLine(line: Int): IntRange? {
val distance = (ownPosition.second - line).absoluteValue
val halfIntersectionLength = radius - distance
return if (halfIntersectionLength >= 0) (ownPosition.first - halfIntersectionLength)..(ownPosition.first + halfIntersectionLength) else null
}
companion object {
fun parse(line: String): Sensor =
line.split(":").let { (left, right) -> Sensor(positionIn(left), positionIn(right)) }
}
}
private fun Pair<Int, Int>.distanceTo(other: Pair<Int, Int>) =
(first - other.first).absoluteValue + (second - other.second).absoluteValue
private fun IntRange.union(other: IntRange): List<IntRange> =
if (isEmpty()) {
listOf(other)
} else if (other.isEmpty()) {
listOf(this)
} else if (contains(other.first)) {
if (contains(other.last)) {
listOf(this)
} else {
listOf(first..other.last)
}
} else if (contains(other.last)) {
listOf(other.first..last)
} else if (other.contains(first)) {
listOf(other)
} else if (other.first == last + 1) {
listOf(first..other.last)
} else if (first == other.last + 1) {
listOf(other.first..last)
} else {
listOf(this, other)
}
private fun IntRange.size() = if (isEmpty()) 0 else (last - first + 1)
private fun Sequence<IntRange>.union() =
sortedBy { it.first }.fold(listOf(IntRange.EMPTY)) { rangeList, range ->
rangeList.dropLast(1) + rangeList.last().union(range)
} | 0 | Kotlin | 0 | 0 | db82954ee965238e19c9c917d5c278a274975f26 | 3,435 | aoc-2022 | Apache License 2.0 |
src/Day08.kt | astrofyz | 572,802,282 | false | {"Kotlin": 124466} | fun main() {
infix fun Int.taller(trees: List<Int>): Boolean{
return trees.all{ it < this}
}
infix fun Int.visibleTrees(trees: List<Int>): Int{
if (this taller trees) return trees.size
return trees.indexOfFirst{ it >= this} + 1
}
fun part1(input: List<String>): Int {
val sideSize = input.size
val forest = input.map { it.toList().map { tree -> tree.digitToInt() } }
fun Int.ifVisible(row:Int, col:Int): Int{
if ((row == 0)||(col == 0)||(row == sideSize-1)||(col == sideSize-1)) {
return 1
}
else if ((this taller forest[row].slice(0..col-1))
||(this taller forest[row].slice(col+1..sideSize-1))
||(this taller forest.map { it[col] }.slice(0..row-1))
||(this taller forest.map { it[col] }.slice(row+1..sideSize-1))){
return 1
}
return 0
}
var count = 0
forest.mapIndexed { rowId, row -> row.mapIndexed { colId, tree -> count += tree.ifVisible(rowId, colId) }}
return count
}
fun part2(input: List<String>): Int {
val sideSize = input.size
val forest = input.map { it.toList().map { tree -> tree.digitToInt() } }
fun Int.scenicScore(row:Int, col:Int): Int{
if ((row == 0)||(col == 0)||(row == sideSize-1)||(col == sideSize-1)) {
return 0
}
val left = this visibleTrees forest[row].slice(0..col-1).reversed()
val right = this visibleTrees forest[row].slice(col+1..sideSize-1)
val up = this visibleTrees forest.map { it[col] }.slice(0..row-1).reversed()
val down = this visibleTrees forest.map { it[col] }.slice(row+1..sideSize-1)
return left*right*up*down
}
val res = forest.mapIndexed { rowId, row -> row.mapIndexed { colId, tree -> tree.scenicScore(rowId, colId) }.max()}.max()
return res
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | a0bc190b391585ce3bb6fe2ba092fa1f437491a6 | 2,272 | aoc22 | Apache License 2.0 |
src/Day11.kt | xNakero | 572,621,673 | false | {"Kotlin": 23869} | object Day11 {
fun part1() = solve(20) { level, _ -> level / 3}
fun part2() = solve(10_000) {level, mod -> level % mod}
private fun solve(rounds: Int, worryLevelStrategy: (Long, Long) -> (Long)): Long {
val monkeys = parseInput()
val modulus = monkeys.map { it.test.divisibleBy }.reduce(Long::times)
repeat(rounds) {
monkeys.forEach { monkey ->
val (dividedByZero, notDividedByZero) = monkey.items
.map { worryLevelStrategy(monkey.inspect(it), modulus) }
.partition { (it % monkey.test.divisibleBy == 0L) }
monkeys[monkey.test.monkeyTrue].items.addAll(dividedByZero)
monkeys[monkey.test.monkeyFalse].items.addAll(notDividedByZero)
monkey.items.clear()
}
}
return monkeys.map { it.inspected.toLong() }.sortedDescending().let { it[0] * it[1] }
}
private fun parseInput(): List<Monkey> = readInput("day11")
.windowed(6, 7)
.map { Monkey.from(it) }
}
data class Monkey(
val items: MutableList<Long>,
val operation: Operation,
val test: Test,
var inspected: Int = 0
) {
fun inspect(item: Long): Long {
inspected++
return if (operation.operationType == "+") {
item + (operation.value ?: item)
} else {
item * (operation.value ?: item)
}
}
companion object {
fun from(monkey: List<String>): Monkey =
Monkey(
items = monkey[1].substringAfter(": ").split(", ").map { it.toLong() }.toMutableList(),
operation = monkey[2].substringAfter("= old ").split(" ")
.let { Operation(it[0], it[1].toLongOrNull()) },
test = Test(
monkey[3].substringAfter("Test: divisible by ").toLong(),
monkey[4].substringAfter("If true: throw to monkey ").toInt(),
monkey[5].substringAfter("If false: throw to monkey ").toInt()
)
)
}
}
data class Operation(val operationType: String, val value: Long?)
data class Test(val divisibleBy: Long, val monkeyTrue: Int, val monkeyFalse: Int)
fun main() {
println(Day11.part1())
println(Day11.part2())
}
| 0 | Kotlin | 0 | 0 | c3eff4f4c52ded907f2af6352dd7b3532a2da8c5 | 2,296 | advent-of-code-2022 | Apache License 2.0 |
src/Day12.kt | asm0dey | 572,860,747 | false | {"Kotlin": 61384} | fun main() {
operator fun List<CharArray>.get(point: Pair<Int, Int>) = this[point.first][point.second]
fun neighbors(
current: Pair<Int, Int>,
input: List<CharArray>,
validator: (Char, Char) -> Boolean,
) = listOf(
current.copy(first = current.first - 1),
current.copy(first = current.first + 1),
current.copy(second = current.second - 1),
current.copy(second = current.second + 1)
)
.filter {
val (i, j) = it
if (i < 0 || j < 0 || i >= input.size || j >= input[0].size) false
else validator(input[current], input[it])
}
fun bfs(
input: List<CharArray>,
current: Pair<Int, Int>,
visitor: (first: Char, second: Char) -> Boolean
): HashMap<Pair<Int, Int>, Int> {
val results = hashMapOf(current to 0)
val visit = ArrayDeque(listOf(current))
while (visit.isNotEmpty()) {
val first = visit.removeFirst()
for (neighbor in neighbors(first, input, visitor)) {
if (results.containsKey(neighbor)) continue
results[neighbor] = results[first]!! + 1
visit.add(neighbor)
}
}
return results
}
val visitor = { first: Char, second: Char ->
val end = first in 'y'..'z' && second == 'E'
val start = first == 'S' && second in 'a'..'b'
val validJump = first.isLowerCase() && second.isLowerCase() && first.code - second.code >= -1
end || start || validJump
}
fun part1(input: List<String>): Int {
val x = input.filter(String::isNotBlank).map(String::toCharArray)
val start = x.mapIndexed { index, c -> index to c.indexOf('S') }.first { (a, b) -> (a >= 0) and (b >= 0) }
val finish = x.mapIndexed { index, c -> index to c.indexOf('E') }.first { (a, b) -> (a >= 0) and (b >= 0) }
return bfs(x, start, visitor)[finish]!!
}
fun part2(input: List<String>): Int {
val coords = arrayListOf<Pair<Int, Int>>()
val x = input.filter(String::isNotBlank).map { it.replace('S', 'a').toCharArray() }
for ((index, line) in x.withIndex()) {
for ((charIndex, char) in line.withIndex()) {
if (char == 'a') {
coords.add(index to charIndex)
}
}
}
val finish = x.mapIndexed { index, c -> index to c.indexOf('E') }.first { (a, b) -> (a >= 0) and (b >= 0) }
return coords.minOf { bfs(x, it, visitor)[finish] ?: Int.MAX_VALUE }
}
val testInput = readInput("Day12_test")
val testPart1 = part1(testInput)
check(testPart1 == 31) { "Actual result: $testPart1" }
val input = readInput("Day12")
println(part1(input))
val testPart2 = part2(testInput)
check(testPart2 == 29) { "Actual result: $testPart2" }
println(part2(input))
}
| 1 | Kotlin | 0 | 1 | f49aea1755c8b2d479d730d9653603421c355b60 | 2,916 | aoc-2022 | Apache License 2.0 |
src/Day08.kt | Cryosleeper | 572,977,188 | false | {"Kotlin": 43613} | import kotlin.math.max
import kotlin.math.min
fun main() {
fun part1(input: List<String>): Int {
val numbers = input.toIntMatrix()
return countTrees(numbers)
}
fun part2(input: List<String>): Int {
val numbers = input.toIntMatrix()
return countScenic(numbers)
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
private fun List<String>.toIntMatrix(): List<List<Int>> = this.map { line -> line.toList().map { tree -> tree.digitToInt() } }
private fun countTrees(input: List<List<Int>>): Int {
var result = 0
input.forEachIndexed { lineIndex, line ->
line.forEachIndexed { columnIndex, tree ->
if (input[lineIndex].subList(0, columnIndex+1).filter { it >= tree }.size == 1) result++
else if (input[lineIndex].subList(columnIndex, input[lineIndex].size).filter { it >= tree }.size == 1) result++
else if (input.subList(0, lineIndex+1).map { it[columnIndex] }.filter { it >= tree }.size == 1) result++
else if (input.subList(lineIndex, input.size).map { it[columnIndex] }.filter { it >= tree }.size == 1) result++
}
}
return result
}
private fun countScenic(input: List<List<Int>>): Int {
fun viewDistance(distanceToHighTree: Int, distanceToEdge: Int) = if (distanceToHighTree == 0) distanceToEdge else min(distanceToHighTree, distanceToEdge)
fun List<Int>.distanceToFirstAsHigh(height: Int) = indexOfFirst { it >= height } + 1
var maxScenic = 0
input.forEachIndexed { lineIndex, line ->
line.forEachIndexed { columnIndex, tree ->
val toLeft = input[lineIndex].subList(0, columnIndex).asReversed()
val leftViewDistance = viewDistance(toLeft.distanceToFirstAsHigh(tree), toLeft.size)
val toRight = input[lineIndex].subList(columnIndex+1, input[lineIndex].size)
val rightViewDistance = viewDistance(toRight.distanceToFirstAsHigh(tree), toRight.size)
val toTop = input.subList(0, lineIndex).asReversed().map { it[columnIndex] }
val topViewDistance = viewDistance(toTop.distanceToFirstAsHigh(tree), toTop.size)
val toBottom = input.subList(lineIndex+1, input.size).map { it[columnIndex] }
val bottomViewDistance = viewDistance(toBottom.distanceToFirstAsHigh(tree), toBottom.size)
maxScenic = max(maxScenic, leftViewDistance * rightViewDistance * topViewDistance * bottomViewDistance)
}
}
return maxScenic
}
| 0 | Kotlin | 0 | 0 | a638356cda864b9e1799d72fa07d3482a5f2128e | 2,717 | aoc-2022 | Apache License 2.0 |
src/Day08.kt | timhillgit | 572,354,733 | false | {"Kotlin": 69577} | fun Iterable<Int>.product() = fold(1) { acc, elt -> acc * elt }
inline fun <T> Iterable<T>.productOf(selector: (T) -> Int) = fold(1) { acc, elt -> acc * selector(elt) }
fun <T : List<U>, U> Iterable<T>.column(index: Int) = map { it[index] }
inline fun <T : List<U>, U> Iterable<T>.columnOrElse(index: Int, defaultValue: (Int) -> U) =
map { it.getOrElse(index, defaultValue) }
private data class VantagePoint(
val height: Int,
val north: List<Int>,
val east: List<Int>,
val south: List<Int>,
val west: List<Int>,
) {
val directions = listOf(north, east, south, west)
val isVisible = directions.any { it.isEmpty() || it.max() < height }
private fun viewDistance(treeLine: List<Int>): Int {
val idx = treeLine.indexOfFirst { it >= height }
return if (idx == -1) {
treeLine.size
} else {
idx + 1
}
}
val scenicScore = directions.productOf(::viewDistance)
}
fun main() {
val trees = readInput("Day08").map {
it.map(Char::digitToInt)
}
val vantagePoints = buildList {
trees.forEachIndexed { i, row ->
row.forEachIndexed { j, height ->
val column = trees.column(j)
val north = column.take(i).reversed()
val east = row.drop(j + 1)
val south = column.drop(i + 1)
val west = row.take(j).reversed()
add(VantagePoint(height, north, east, south, west))
}
}
}
println(vantagePoints.count(VantagePoint::isVisible))
println(vantagePoints.maxOf(VantagePoint::scenicScore))
}
| 0 | Kotlin | 0 | 1 | 76c6e8dc7b206fb8bc07d8b85ff18606f5232039 | 1,631 | advent-of-code-2022 | Apache License 2.0 |
src/poyea/aoc/mmxxii/day24/Day24.kt | poyea | 572,895,010 | false | {"Kotlin": 68491} | package poyea.aoc.mmxxii.day24
import poyea.aoc.utils.readInput
data class Point(val x: Int, val y: Int) {
operator fun plus(other: Point) = Point(x + other.x, y + other.y)
fun neighbours(): List<Point> {
return listOf(1, 0, -1, 0, 1).zipWithNext().map { (dx, dy) -> Point(x + dx, y + dy) }
}
}
data class Blizzard(val point: Point, val dir: Point) {
fun moved(boundary: Point): Blizzard {
val next = point + dir
return copy(
point =
when {
next.x == 0 -> Point(boundary.x - 1, next.y)
next.y == 0 -> Point(next.x, boundary.y - 1)
next.x == boundary.x -> Point(1, next.y)
next.y == boundary.y -> Point(next.x, 1)
else -> next
}
)
}
}
data class Valley(val blizzards: List<Blizzard>, val boundary: Point) {
val unsafePoints = blizzards.map { it.point }.toSet()
fun moved() = copy(blizzards = blizzards.map { it.moved(boundary) })
fun isSafe(point: Point): Boolean {
return point !in unsafePoints &&
point.x >= 1 &&
point.x < boundary.x &&
point.y >= 1 &&
point.y < boundary.y
}
companion object {
fun from(input: List<String>): Valley {
return Valley(
blizzards =
input.flatMapIndexed { y, line ->
line.mapIndexedNotNull { x, char ->
when (char) {
'^' -> Blizzard(Point(x, y), Point(0, -1))
'v' -> Blizzard(Point(x, y), Point(0, 1))
'<' -> Blizzard(Point(x, y), Point(-1, 0))
'>' -> Blizzard(Point(x, y), Point(1, 0))
else -> null
}
}
},
boundary = Point(input.last().lastIndex, input.lastIndex)
)
}
}
}
fun go(newValley: Valley, start: Point, end: Point): Pair<Int, Valley> {
var minutes = 0
var valley = newValley
var batch = setOf(start)
while (true) {
++minutes
valley = valley.moved()
batch = buildSet {
batch.forEach { current ->
addAll(
current
.neighbours()
.onEach { if (it == end) return minutes to valley }
.filter(valley::isSafe)
)
if (valley.isSafe(current) || current == start) add(current)
}
}
}
}
fun part1(input: String): Int {
val lines = input.lines()
val valley = Valley.from(lines)
val start = Point(lines.first().indexOf('.'), 0)
val end = Point(lines.last().indexOf('.'), lines.lastIndex)
return go(valley, start, end).first
}
fun part2(input: String): Int {
val lines = input.lines()
val valley = Valley.from(lines)
val start = Point(lines.first().indexOf('.'), 0)
val end = Point(lines.last().indexOf('.'), lines.lastIndex)
val first = go(valley, start, end)
val second = go(first.second, end, start)
val third = go(second.second, start, end)
return first.first + second.first + third.first
}
fun main() {
println(part1(readInput("Day24")))
println(part2(readInput("Day24")))
}
| 0 | Kotlin | 0 | 1 | fd3c96e99e3e786d358d807368c2a4a6085edb2e | 3,443 | aoc-mmxxii | MIT License |
src/year_2023/day_11/Day11.kt | scottschmitz | 572,656,097 | false | {"Kotlin": 240069} | package year_2023.day_11
import readInput
import util.Point
data class Universe(
val galaxies: List<Point>,
val horizontalExpansions: List<Int>,
val verticalExpansions: List<Int>
)
object Day11 {
/**
*
*/
fun distances(text: List<String>, age: Int): Long {
val distances = mutableMapOf<Pair<Point, Point>, Long>()
val universe = parseUniverse(text)
universe.galaxies.forEach { galaxy ->
universe.galaxies.filter { it != galaxy }.forEach { otherGalaxy ->
if (!distances.containsKey(galaxy to otherGalaxy) && !distances.containsKey(otherGalaxy to galaxy)) {
distances[galaxy to otherGalaxy] = calculateDistance(galaxy, otherGalaxy, universe, age)
}
}
}
return distances.values.sum()
}
private fun parseUniverse(text: List<String>): Universe {
val galaxies = mutableListOf<Point>()
val horizontalExpansions = mutableListOf<Int>()
val verticalExpansions = mutableListOf<Int>()
text.forEachIndexed { y, line ->
line.forEachIndexed { x, char ->
if (char == '#') {
galaxies.add(x to y)
}
}
}
text.forEachIndexed { y, line ->
if (line.all { it == '.' }) {
verticalExpansions.add(y)
}
}
for (x in text.first().indices) {
if (text.all { it[x] == '.'} ) {
horizontalExpansions.add(x)
}
}
return Universe(
galaxies = galaxies,
horizontalExpansions = horizontalExpansions,
verticalExpansions = verticalExpansions
)
}
private fun calculateDistance(pointA: Point, pointB: Point, universe: Universe, age: Int): Long {
var hDiff = 0L
val left = if (pointA.first < pointB.first) pointA.first else pointB.first
val right = if (pointA.first > pointB.first) pointA.first else pointB.first
for (x in left until right) {
hDiff += 1
if (x in universe.horizontalExpansions) {
hDiff += age - 1
}
}
var vDiff = 0L
val top = if (pointA.second < pointB.second) pointA.second else pointB.second
val bottom = if (pointA.second > pointB.second) pointA.second else pointB.second
for (y in top until bottom) {
vDiff += 1
if (y in universe.verticalExpansions) {
vDiff += age - 1
}
}
return hDiff + vDiff
}
}
fun main() {
val text = readInput("year_2023/day_11/Day11.txt")
val solutionOne = Day11.distances(text, 2)
println("Solution 1: $solutionOne")
val solutionTwo = Day11.distances(text, 1_000_000)
println("Solution 2: $solutionTwo")
}
| 0 | Kotlin | 0 | 0 | 70efc56e68771aa98eea6920eb35c8c17d0fc7ac | 2,883 | advent_of_code | Apache License 2.0 |
2021/src/day13/Day13.kt | Bridouille | 433,940,923 | false | {"Kotlin": 171124, "Go": 37047} | package day13
import readInput
data class Point(val x: Int, val y: Int)
sealed class Fold {
data class Up(val y: Int) : Fold()
data class Left(val x: Int) : Fold()
}
fun List<String>.toPoints() = filter { !it.contains("fold") }.map {
val x = it.split(",")[0]
val y = it.split(",")[1]
Point(x.toInt(), y.toInt())
}
fun List<String>.toFolds() = filter { it.contains("fold") }.map {
when {
it.contains("y=") -> Fold.Up(it.substringAfter("y=").toInt())
it.contains("x=") -> Fold.Left(it.substringAfter("x=").toInt())
else -> null
}
}.filterNotNull()
// transform the list of coordonnates to an Array<CharArray> containing '.' or '#'
fun List<String>.toTable(): Array<CharArray>? {
val points = this.toPoints()
val maxX = points.maxByOrNull { it.x } ?: return null
val maxY = points.maxByOrNull { it.y } ?: return null
val table = Array(maxY.y + 1) { CharArray(maxX.x + 1) { '.' } }
points.forEach { table[it.y][it.x] = '#' }
return table
}
fun applyFold(table: Array<CharArray>, fold: Fold) : Array<CharArray> {
val newMaxY = if (fold is Fold.Up) { fold.y } else { table.size }
val newMaxX = if (fold is Fold.Left) { fold.x } else { table[0].size }
val newTable = Array(newMaxY) { CharArray(newMaxX) { '.' } }
// Apply folding
for (y in 0 until table.size) {
for (x in 0 until table[0].size) {
if (y < newMaxY && x < newMaxX) {
newTable[y][x] = table[y][x]
} else if (y > newMaxY || x > newMaxX) {
// if maxSize == 7, then 8 -> 6, 9 -> 5, 10 -> 4, 14 -> 0
val foldedY = if (y > newMaxY) {
newMaxY - (((y / newMaxY - 1) * newMaxY) + y % newMaxY)
} else { y }
val foldedX = if (x > newMaxX) {
newMaxX - (((x / newMaxX - 1) * newMaxX) + x % newMaxX)
} else { x }
if (table[y][x] == '#') {
newTable[foldedY][foldedX] = table[y][x]
}
}
}
}
return newTable
}
fun part1(lines: List<String>) : Int {
val table = lines.toTable() ?: return -1
return applyFold(table, lines.toFolds().first()).toList().map {
it.toList().count { it == '#' }
}.sum()
}
fun part2(lines: List<String>) : Int {
var table = lines.toTable() ?: return -1
for (fold in lines.toFolds()) {
table = applyFold(table, fold)
}
for (l in table) println(l) // Just read the output in terminal :)
return table.toList().map { it.toList().count { it == '#' } }.sum()
}
fun main() {
val testInput = readInput("day13/test")
println("part1(testInput) => " + part1(testInput))
println("part2(testInput) => " + part2(testInput))
val input = readInput("day13/input")
println("part1(input) => " + part1(input))
println("part1(input) => " + part2(input))
}
| 0 | Kotlin | 0 | 2 | 8ccdcce24cecca6e1d90c500423607d411c9fee2 | 2,932 | advent-of-code | Apache License 2.0 |
src/Day08.kt | SimoneStefani | 572,915,832 | false | {"Kotlin": 33918} | fun main() {
class Forest(private val rows: List<List<Int>>) {
private fun isVisible(r: Int, c: Int): Boolean =
(0 until c).all { rows[r][it] < rows[r][c] }
|| (c + 1 until rows[0].size).all { rows[r][it] < rows[r][c] }
|| (0 until r).all { rows[it][c] < rows[r][c] }
|| (r + 1 until rows.size).all { rows[it][c] < rows[r][c] }
private fun score(r: Int, c: Int): Int =
(c - 1 downTo 0).takeWhile { rows[r][it] >= rows[r][c] }.size *
(c + 1 until rows[0].size).takeWhile { rows[r][it] >= rows[r][c] }.size *
(r - 1 downTo 0).takeWhile { rows[it][c] >= rows[r][c] }.size *
(r + 1 until rows.size).takeWhile { rows[it][c] >= rows[r][c] }.size
fun maxScenicScore(): Int =
(1 until rows.size - 1).maxOf { r -> (1 until rows[0].size - 1).maxOf { c -> score(r, c) } }
fun countVisible(): Int =
(rows.indices).sumOf { r -> (0 until rows[r].size).count { c -> isVisible(r, c) } }
}
fun loadForest(lines: List<String>): Forest =
Forest(lines.map { line -> line.map { it.code - '0'.code }.toList() }.toList())
fun part1(input: List<String>): Int {
return loadForest(input).countVisible()
}
fun part2(input: List<String>): Int {
return loadForest(input).maxScenicScore()
}
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | b3244a6dfb8a1f0f4b47db2788cbb3d55426d018 | 1,622 | aoc-2022 | Apache License 2.0 |
advent-of-code-2023/src/main/kotlin/eu/janvdb/aoc2023/day19/day19.kt | janvdbergh | 318,992,922 | false | {"Java": 1000798, "Kotlin": 284065, "Shell": 452, "C": 335} | package eu.janvdb.aoc2023.day19
import eu.janvdb.aocutil.kotlin.readGroupedLines
//const val FILENAME = "input19-test.txt"
const val FILENAME = "input19.txt"
val VARIABLES = listOf("x", "m", "a", "s")
const val MIN_VALUE = 1
const val MAX_VALUE = 4000
fun main() {
val lines = readGroupedLines(2023, FILENAME)
val rules = Rules.parse(lines[0])
val parts = lines[1].map(Part::parse)
part1(parts, rules)
part2(rules)
}
private fun part1(parts: List<Part>, rules: Rules) {
val acceptedParts = parts.filter(rules::evaluate)
println(acceptedParts.sumOf { it.rating })
}
private fun part2(rules: Rules) {
val ranges = VARIABLES.associateWith { MIN_VALUE..MAX_VALUE }
val result = rules.countAccepted("in", ranges)
println(result)
}
data class Rules(val rules: Map<String, Rule>) {
fun evaluate(part: Part): Boolean {
var current = "in"
while (!current.isAccepted() && !current.isRejected()) {
val rule = rules[current]!!
current = rule.evaluate(part)
}
return current.isAccepted()
}
fun countAccepted(outcome: String, ranges: Map<String, IntRange>, index: Int = 0): Long {
val spaces = (0..<index).joinToString("", "", "+-") { "| " }
println("$spaces$ranges -> $outcome")
if (outcome.isAccepted())
return 1L * ranges.values.fold(1L) { acc, range -> acc * (range.last - range.first + 1) }
if (outcome.isRejected())
return 0L
if (ranges.values.any { it.last < it.first })
return 0L
val rule = rules[outcome]!!
var currentRanges = ranges
var sum = 0L
rule.conditions.forEach { condition ->
val currentRange = currentRanges[condition.variable]!!
val newRange1 =
if (condition.operation == Operation.LT) currentRange.first..<condition.value else condition.value + 1..currentRange.last
val newRange2 =
if (condition.operation == Operation.LT) condition.value..currentRange.last else currentRange.first..condition.value
val newRanges = currentRanges + Pair(condition.variable, newRange1)
sum += countAccepted(condition.outcome, newRanges, index + 1)
currentRanges = currentRanges + Pair(condition.variable, newRange2)
}
sum += countAccepted(rule.defaultOutcome, currentRanges, index + 1)
return sum
}
companion object {
fun parse(lines: List<String>): Rules {
val rules = lines.map(Rule::parse).associateBy { it.name }
return Rules(rules)
}
}
}
data class Rule(val name: String, val conditions: List<Condition>, val defaultOutcome: String) {
fun evaluate(part: Part): String {
return conditions.find { it.matches(part) }?.outcome ?: defaultOutcome
}
companion object {
fun parse(line: String): Rule {
val parts = line.split("{")
val name = parts[0]
val parts2 = parts[1].substring(0, parts[1].length - 1).split(",")
val conditions = parts2.subList(0, parts2.size - 1).map(Condition::parse)
val defaultOutcome = parts2.last()
return Rule(name, conditions, defaultOutcome)
}
}
}
data class Condition(val variable: String, val operation: Operation, val value: Int, val outcome: String) {
fun matches(part: Part): Boolean {
val partValue = part.values[variable]!!
return operation.evaluate(partValue, value)
}
companion object {
private val REGEX = Regex("(\\w+)([<>])(\\d+):(\\w+)")
fun parse(value: String): Condition {
val matchResult = REGEX.matchEntire(value)!!
return Condition(
matchResult.groupValues[1],
Operation.parse(matchResult.groupValues[2]),
matchResult.groupValues[3].toInt(),
matchResult.groupValues[4]
)
}
}
}
enum class Operation(val text: String) {
GT(">"), LT("<");
fun evaluate(x: Int, y: Int) = when (this) {
LT -> x < y
GT -> x > y
}
companion object {
fun parse(value: String) = entries.find { it.text == value }!!
}
}
fun String.isAccepted() = equals("A")
fun String.isRejected() = equals("R")
data class Part(val values: Map<String, Int>) {
val rating = VARIABLES.sumOf { values.getOrDefault(it, 0) }
companion object {
private val REGEX = Regex("(\\w+)=(\\d+)")
fun parse(value: String): Part {
val values = REGEX.findAll(value).associate { Pair(it.groupValues[1], it.groupValues[2].toInt()) }
return Part(values)
}
}
} | 0 | Java | 0 | 0 | 78ce266dbc41d1821342edca484768167f261752 | 4,730 | advent-of-code | Apache License 2.0 |
src/twentytwentythree/day07/Day07.kt | colinmarsch | 571,723,956 | false | {"Kotlin": 65403, "Python": 6148} | package twentytwentythree.day07
import readInput
import kotlin.math.max
enum class HandType(val value: Int) {
FIVE_OF_A_KIND(7),
FOUR_OF_A_KIND(6),
FULL_HOUSE(5),
THREE_OF_A_KIND(4),
TWO_PAIR(3),
ONE_PAIR(2),
HIGH_CARD(1),
}
class Card(private val value: Char) : Comparable<Card> {
override fun compareTo(other: Card): Int {
return ORDER.indexOf(this.value) - ORDER.indexOf(other.value)
}
companion object {
// Define the order of cards from highest to lowest
private val ORDER = listOf('A', 'K', 'Q', 'J', 'T', '9', '8', '7', '6', '5', '4', '3', '2')
}
}
fun main() {
class Hand(val value: String) : Comparable<Hand> {
val cardsMap = value.toList().groupBy { it }
override fun compareTo(other: Hand): Int {
val thisType = determineHandType(this)
val otherType = determineHandType(other)
val typeComparison = thisType.compareTo(otherType)
if (typeComparison != 0) {
return typeComparison
}
// If both hands have the same type, compare them card by card
for (i in value.indices) {
val thisCard = Card(value[i])
val otherCard = Card(other.value[i])
val cardComparison = thisCard.compareTo(otherCard)
if (cardComparison != 0) {
return cardComparison
}
}
return 0 // Both hands are equal
}
private fun determineHandType(hand: Hand): HandType {
val maxCount = hand.cardsMap.values.maxOfOrNull {
it.size
} ?: 0
val maxCard = hand.cardsMap.entries.maxByOrNull { it.value.size }!!.key
val tempHand = hand.cardsMap.toMutableMap()
tempHand.remove(maxCard)
val secondMaxCount =
tempHand.values.maxOfOrNull { if (it.size <= maxCount) it.size else 0 } ?: 0
return when {
maxCount == 5 -> HandType.FIVE_OF_A_KIND
maxCount == 4 -> HandType.FOUR_OF_A_KIND
maxCount == 3 && secondMaxCount == 2 -> HandType.FULL_HOUSE
maxCount == 3 -> HandType.THREE_OF_A_KIND
maxCount == 2 && secondMaxCount == 2 -> HandType.TWO_PAIR
maxCount == 2 -> HandType.ONE_PAIR
else -> HandType.HIGH_CARD
}
}
}
fun part1(input: List<String>): Long {
var index = 1
val sorted = input.sortedByDescending { line ->
Hand(line.split(" ")[0])
}
return sorted.sumOf { line ->
line.split(" ")[1].toLong() * index++
}
}
fun part2(input: List<String>): Int {
return 0
}
val input = readInput("twentytwentythree/day07", "Day07_input")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | bcd7a08494e6db8140478b5f0a5f26ac1585ad76 | 2,583 | advent-of-code | Apache License 2.0 |
src/day13/Day13_functional.kt | seastco | 574,758,881 | false | {"Kotlin": 72220} | package day13
import readLines
/**
* Credit goes to tginsberg (https://github.com/tginsberg/advent-2022-kotlin)
* I'm experimenting with his solutions to better learn functional programming in Kotlin.
* Files without the _functional suffix are my original solutions.
*/
sealed class PacketV2 : Comparable<PacketV2> {
companion object {
fun of(input: String): PacketV2 =
of(
input.split("""((?<=[\[\],])|(?=[\[\],]))""".toRegex()) // split the string on any of "[" or "]" or "," but keep them in the output
.filter { it.isNotBlank() } // filter out ""
.filter { it != "," } // filter out ","
.iterator() // "[1,1,3,1,1]" is now ["[", "1", "1", "3", "1", "1", "]"]
)
private fun of(input: Iterator<String>): PacketV2 {
val packets = mutableListOf<PacketV2>()
while (input.hasNext()) {
when (val symbol = input.next()) {
"]" -> return ListPacket(packets)
"[" -> packets.add(of(input))
else -> packets.add(IntPacket(symbol.toInt()))
}
}
return ListPacket(packets)
}
}
}
private class IntPacket(val amount: Int) : PacketV2() {
fun asList(): PacketV2 = ListPacket(listOf(this))
override fun compareTo(other: PacketV2): Int =
when (other) {
is IntPacket -> amount.compareTo(other.amount)
is ListPacket -> asList().compareTo(other)
}
}
private class ListPacket(val subPackets: List<PacketV2>) : PacketV2() {
override fun compareTo(other: PacketV2): Int =
when (other) {
is IntPacket -> compareTo(other.asList())
is ListPacket -> subPackets.zip(other.subPackets) // zip will pair together what it can, if list length isn't even those elements are left out
.map { it.first.compareTo(it.second) } // compare values within pairs
.firstOrNull { it != 0 } ?: subPackets.size.compareTo(other.subPackets.size) // if condition isn't found, compare list length
}
}
private fun part1(input: List<String>): Int {
val packets = input.filter { it.isNotBlank() }.map { PacketV2.of(it) }
return packets.chunked(2).mapIndexed { index, pair -> // compare two packets at a time
if (pair.first() < pair.last()) index + 1 else 0 // if first < second, add index+1 to sum result
}.sum()
}
private fun part2(input: List<String>): Int {
val packets = input.filter { it.isNotBlank() }.map { PacketV2.of(it) }
val dividerPacket1 = PacketV2.of("[[2]]")
val dividerPacket2 = PacketV2.of("[[6]]")
val ordered = (packets + dividerPacket1 + dividerPacket2).sorted()
return (ordered.indexOf(dividerPacket1) + 1) * (ordered.indexOf(dividerPacket2) + 1)
}
fun main() {
println(part1(readLines("day13/test")))
println(part2(readLines("day13/test")))
println(part1(readLines("day13/input")))
println(part2(readLines("day13/input")))
} | 0 | Kotlin | 0 | 0 | 2d8f796089cd53afc6b575d4b4279e70d99875f5 | 3,055 | aoc2022 | Apache License 2.0 |
src/Day08.kt | dmarcato | 576,511,169 | false | {"Kotlin": 36664} | data class Pos(val x: Int, val y: Int)
fun main() {
fun List<String>.atPos(pos: Pos): Int = this[pos.y][pos.x].digitToInt()
fun visible(input: List<String>, pos: Pos, maxX: Int, maxY: Int): Boolean {
val tree = input.atPos(pos)
return (pos.x - 1 downTo 0).all { tree > input.atPos(Pos(it, pos.y)) }
|| (pos.x + 1 until maxX).all { tree > input.atPos(Pos(it, pos.y)) }
|| (pos.y - 1 downTo 0).all { tree > input.atPos(Pos(pos.x, it)) }
|| (pos.y + 1 until maxY).all { tree > input.atPos(Pos(pos.x, it)) }
}
fun Iterable<Int>.countWhileMatchOrEnd(condition: (Int) -> Boolean): Int {
var count = 0
this.asSequence().forEach { i ->
count++
if (!condition(i)) {
return count
}
}
return count
}
fun scenicScore(input: List<String>, pos: Pos, maxX: Int, maxY: Int): Int {
val tree = input.atPos(pos)
val left = (pos.x - 1 downTo 0).countWhileMatchOrEnd { tree > input.atPos(Pos(it, pos.y)) }
val right = (pos.x + 1 until maxX).countWhileMatchOrEnd { tree > input.atPos(Pos(it, pos.y)) }
val top = (pos.y - 1 downTo 0).countWhileMatchOrEnd { tree > input.atPos(Pos(pos.x, it)) }
val bottom = (pos.y + 1 until maxY).countWhileMatchOrEnd { tree > input.atPos(Pos(pos.x, it)) }
return left * right * top * bottom
}
fun part1(input: List<String>): Int {
val maxX = input.first().length
val maxY = input.size
val extras = (1 until maxY - 1).sumOf { y ->
(1 until maxX - 1).count { x -> visible(input, Pos(x, y), maxX, maxY) }
}
return (maxX * 2 + maxY * 2 - 4) + extras
}
fun part2(input: List<String>): Int {
val maxX = input.first().length
val maxY = input.size
val max = (1 until maxY - 1).maxOf { y ->
(1 until maxX - 1).maxOf { x -> scenicScore(input, Pos(x, y), maxX, maxY) }
}
return max
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day08_test")
check(part1(testInput) == 21) { "part1 check failed" }
check(part2(testInput) == 8) { "part2 check failed" }
val input = readInput("Day08")
part1(input).println()
part2(input).println()
}
| 0 | Kotlin | 0 | 0 | 6abd8ca89a1acce49ecc0ca8a51acd3969979464 | 2,362 | aoc2022 | Apache License 2.0 |
advent-of-code-2023/src/Day08.kt | osipxd | 572,825,805 | false | {"Kotlin": 141640, "Shell": 4083, "Scala": 693} | private const val DAY = "Day08"
fun main() {
fun input() = readInput(DAY)
"Part 1" {
fun testInput0() = readInput("${DAY}_test0")
fun testInput1() = readInput("${DAY}_test1")
part1(testInput0()) shouldBe 2
part1(testInput1()) shouldBe 6
measureAnswer { part1(input()) }
}
"Part 2" {
fun testInput() = readInput("${DAY}_test2")
part2(testInput()) shouldBe 6
measureAnswer { part2(input()) }
}
}
private fun part1(input: DessertMap): Int = input.countCycles(fromNode = "AAA") { it == "ZZZ" } * input.stepsInCycle
private fun part2(input: DessertMap): Long {
// Assumption is that number of cycles for each node is a prime number.
return input.nodes.keys.filter { it.endsWith("A") }
.map { startNode -> input.countCycles(startNode) { it.endsWith("Z") }.toLong() }
.reduce(Long::times) * input.stepsInCycle
}
private fun readInput(name: String): DessertMap {
val (instructions, rawNodes) = readText(name).split("\n\n")
return DessertMap(
instructions = instructions,
nodes = rawNodes.lineSequence().associate { line ->
val (nodeId, directions) = line.split(" = ")
val (leftNode, rightNode) = directions.trim('(', ')').split(", ")
nodeId to MapNode(leftNode, rightNode)
},
)
}
private data class DessertMap(
val instructions: String,
val nodes: Map<String, MapNode>
) {
val stepsInCycle = instructions.length
fun countCycles(fromNode: String, predicate: (String) -> Boolean): Int {
var steps = 0
var currentNode = fromNode
fun instruction() = instructions[(steps - 1) % stepsInCycle]
while (steps % stepsInCycle != 0 || !predicate(currentNode)) {
steps++
currentNode = nodes.getValue(currentNode).nextNode(instruction())
}
return steps / stepsInCycle
}
}
private data class MapNode(val leftNode: String, val rightNode: String) {
fun nextNode(instruction: Char) = when (instruction) {
'L' -> leftNode
'R' -> rightNode
else -> error("Unexpected instruction: $instruction")
}
}
| 0 | Kotlin | 0 | 5 | 6a67946122abb759fddf33dae408db662213a072 | 2,189 | advent-of-code | Apache License 2.0 |
src/day15/Day15.kt | martin3398 | 572,166,179 | false | {"Kotlin": 76153} | package day15
import readInput
import kotlin.math.abs
fun dist(fst: Pair<Int, Int>, snd: Pair<Int, Int>): Int = abs(fst.first - snd.first) + abs(fst.second - snd.second)
fun Pair<Int, Int>.add(x: Pair<Int, Int>) = Pair(this.first + x.first, this.second + x.second)
fun Pair<Int, Int>.multiplyPairwise(x: Pair<Int, Int>) = Pair(this.first * x.first, this.second * x.second)
fun main() {
fun getBeaconsAtRow(
input: List<Pair<Pair<Int, Int>, Pair<Int, Int>>>,
row: Int,
): Set<Pair<Int, Int>> {
val reachable = mutableSetOf<Pair<Int, Int>>()
input.forEach {
val dist = dist(it.first, it.second)
var offset = 0
var added = true
while (added) {
added = false
val p1 = Pair(it.first.first + offset, row)
val p2 = Pair(it.first.first - offset, row)
if (dist(it.first, p1) <= dist) {
reachable.add(p1)
added = true
}
if (dist(it.first, p2) <= dist) {
reachable.add(p2)
added = true
}
offset++
}
}
reachable.removeAll(input.map { it.second }.toSet())
return reachable
}
fun part1(input: List<Pair<Pair<Int, Int>, Pair<Int, Int>>>, row: Int): Int {
val reachable = getBeaconsAtRow(input, row)
return reachable.size
}
fun part2(input: List<Pair<Pair<Int, Int>, Pair<Int, Int>>>, maxCoordinate: Int): Long {
input.forEach { inputEntry ->
val (sensor, beacon) = inputEntry
val dist = dist(sensor, beacon)
for (xOffset in 0..dist) {
val yOffset = dist - xOffset + 1
val candidates = listOf(Pair(1, 1), Pair(1, -1), Pair(-1, 1), Pair(-1, -1))
.map { it.multiplyPairwise(Pair(xOffset, yOffset)).add(sensor) }
.filter { it.first in 0..maxCoordinate && it.second in 0..maxCoordinate }
for (candidate in candidates) {
if (input.all { dist(it.first, candidate) > dist(it.first, it.second) }) {
return candidate.first.toLong() * 4000000L + candidate.second.toLong()
}
}
}
}
throw IllegalStateException("No Solution")
}
fun preprocess(input: List<String>): List<Pair<Pair<Int, Int>, Pair<Int, Int>>> = input.map {
val split = it.split(" ")
Pair(
Pair(
split[2].removePrefix("x=").removeSuffix(",").toInt(),
split[3].removePrefix("y=").removeSuffix(":").toInt()
),
Pair(
split[8].removePrefix("x=").removeSuffix(",").toInt(),
split[9].removePrefix("y=").toInt()
)
)
}
// test if implementation meets criteria from the description, like:
val testInput = readInput(15, true)
check(part1(preprocess(testInput), 10) == 26)
val input = readInput(15)
println(part1(preprocess(input), 2000000))
check(part2(preprocess(testInput), 20) == 56000011L)
println(part2(preprocess(input), 4000000))
}
| 0 | Kotlin | 0 | 0 | 4277dfc11212a997877329ac6df387c64be9529e | 3,262 | advent-of-code-2022 | Apache License 2.0 |
2021/src/day14/Day14.kt | Bridouille | 433,940,923 | false | {"Kotlin": 171124, "Go": 37047} | package day14
import readInput
fun List<String>.toPairInsertions() : Map<String, String> {
val map = mutableMapOf<String, String>()
filter { it.contains("->") }.forEach {
map[it.substringBefore("->").trim()] = it.substringAfter("->").trim()
}
return map
}
fun applyStep(start: String, pairs: Map<String, String>) : String {
val newStr = StringBuilder()
for (i in start.indices) {
newStr.append(start[i])
if (i + 1 < start.length) {
val key = "${start[i]}${start[i + 1]}"
if (pairs.contains(key)) {
newStr.append(pairs[key])
}
}
}
return newStr.toString()
}
fun part1(lines: List<String>) : Int {
var polymerTemplate = lines.first()
val pairInsertions = lines.toPairInsertions()
val numberOfSteps = 10
for (i in 0 until numberOfSteps) {
polymerTemplate = applyStep(polymerTemplate, pairInsertions)
}
val lettersToOccurrences = polymerTemplate.toList().groupingBy { it }.eachCount()
val maxLetter = lettersToOccurrences.maxOfOrNull { it.value } ?: return -1
val minLetter = lettersToOccurrences.minOfOrNull { it.value } ?: return -1
return maxLetter - minLetter
}
fun part2(lines: List<String>) : Long {
val polymerTemplate = lines.first()
val pairInsertions = lines.toPairInsertions()
val numberOfSteps = 40
val pairs = mutableMapOf<String, Long>()
for (i in polymerTemplate.indices) { // NNCB => {NN=1, NC=1, CB=1}
if (i + 1 < polymerTemplate.length) {
val key = "${polymerTemplate[i]}${polymerTemplate[i + 1]}"
pairs[key] = pairs.getOrDefault(key, 0) + 1
}
}
// Applying the steps by pairs => [NN] becomes [NC] & [CN]
for (i in 0 until numberOfSteps) {
val tmp = mutableMapOf<String, Long>()
for ((key, value) in pairs) {
pairInsertions[key]?.let { replacement ->
val firstKey = ""+key.first() + replacement.first()
val secondKey = ""+replacement.first() + key.last()
tmp[firstKey] = tmp.getOrDefault(firstKey, 0) + value
tmp[secondKey] = tmp.getOrDefault(secondKey, 0) + value
}
}
pairs.clear()
pairs.putAll(tmp)
}
// Calculate the totals
val totals = mutableMapOf<Char, Long>()
totals[polymerTemplate.first()] = 1
for ((k, v) in pairs) {
totals[k.last()] = totals.getOrDefault(k.last(), 0) + v
}
val sorted = totals.toList().map { it.second }.sortedDescending()
return sorted.first() - sorted.last()
}
fun main() {
val testInput = readInput("day14/test")
println("part1(testInput) => " + part1(testInput))
println("part2(testInput) => " + part2(testInput))
val input = readInput("day14/input")
println("part1(input) => " + part1(input))
println("part2(input) => " + part2(input))
}
| 0 | Kotlin | 0 | 2 | 8ccdcce24cecca6e1d90c500423607d411c9fee2 | 2,924 | advent-of-code | Apache License 2.0 |
src/main/kotlin/com/hopkins/aoc/day2/main.kt | edenrox | 726,934,488 | false | {"Kotlin": 88215} | package com.hopkins.aoc.day2
import java.io.File
const val debug = false
const val part = 2
val maxCubes = CubeInfo(red = 12, green = 13, blue = 14)
/** Advent of Code 2023: Day 2 */
fun main() {
val inputFile = File("input/input2.txt")
if (debug) {
println("Max Cubes: $maxCubes")
}
// Extract the GameInfo from each line
val gameInfoList: List<GameInfo> = inputFile.readLines().map { line -> parseGame(line) }
if (debug) {
gameInfoList.take(5).map { println("Game: ${it.id} isValid: ${it.isValid(maxCubes)}") }
}
if (part == 1) {
// Sum the Game IDs where the game is valid given the max number of cubes
val gameIdSum: Int = gameInfoList.filter { it.isValid(maxCubes) }.map { it.id }.sum()
println("gameIdSum: $gameIdSum") // 2771
} else {
val powerSum: Int = gameInfoList.sumOf { game ->
val minCubes = findMinCubes(game.cubes)
minCubes.red * minCubes.green * minCubes.blue
}
println("Power Sum: $powerSum") // 70924
}
}
/** Returns the minimum number of cubes of each color required to play the specified set of games. */
fun findMinCubes(cubes: List<CubeInfo>): CubeInfo =
CubeInfo(
cubes.maxOf { it.red },
cubes.maxOf { it.green },
cubes.maxOf { it.blue }
)
/** Parse a [GameInfo] from a line of input. */
fun parseGame(line: String): GameInfo {
// Example line:
// Game <Id>: <CubeInfo>; <CubeInfo>; ...
val parts = line.split(":", ";")
val id = parts[0].substring(startIndex = 5).toInt()
return GameInfo(id, parts.drop(1).map { parseCubeInfo(it) })
}
/** Parse a [CubeInfo] from a single draw. */
fun parseCubeInfo(cubeInfo: String): CubeInfo {
// Example draw:
// <X> red, <Y> green, <Z> blue
val parts = cubeInfo.split(",")
var (red, green, blue) = listOf(0, 0, 0)
parts.map { parseCube(it) }.forEach { (color, num) ->
when (color) {
"red" -> red += num
"green" -> green += num
"blue" -> blue += num
}
}
return CubeInfo(red, green, blue)
}
/** Parse the color and count of cubes drawn. */
fun parseCube(cube: String): Pair<String, Int> {
// Example cube
val parts = cube.trim().split(" ")
return Pair(parts[1], parts[0].toInt())
}
class GameInfo(val id: Int, val cubes: List<CubeInfo>) {
/** Returns `true` if the cube draws of this game are valid given the specifed [maxCubes]. */
fun isValid(maxCubes: CubeInfo): Boolean = !cubes.any { it.isAnyGreaterThan(maxCubes) }
override fun toString(): String = "GameInfo id=${id} cubes=${cubes}"
}
class CubeInfo(val red: Int, val green: Int, val blue: Int) {
/** Returns `true` if any of the draws are greater than the specified max number of cubes. */
fun isAnyGreaterThan(max: CubeInfo): Boolean =
red > max.red || green > max.green || blue > max.blue
override fun toString(): String = "r=${red} g=${green} b=${blue}"
}
| 0 | Kotlin | 0 | 0 | 45dce3d76bf3bf140d7336c4767e74971e827c35 | 2,995 | aoc2023 | MIT License |
src/main/kotlin/solutions/day24/Day24.kt | Dr-Horv | 112,381,975 | false | null |
package solutions.day24
import solutions.Solver
data class Component(val port1: Int, val port2: Int) {
override fun toString(): String {
return "$port1/$port2"
}
}
fun List<Component>.strength(): Int = this.sumBy { it.port1 + it.port2 }
class Day24: Solver {
override fun solve(input: List<String>, partTwo: Boolean): String {
val components = input.map {
val (port1, port2) = it.split("/")
Component(port1.toInt(), port2.toInt())
}
var maxStrength = Int.MIN_VALUE
var strongestLongest = listOf<Component>()
components.filter { it.port1 == 0 || it.port2 == 0 }
.forEach {
val isPort1 = it.port1 == 0
val bridges = doBridge(it, isPort1, components.filter { c -> c != it })
bridges.forEach {
val strength = it.strength()
if(strength > maxStrength) {
maxStrength = strength
}
}
if(partTwo) {
val sortedBy = bridges.sortedBy(List<Component>::size).reversed()
println(sortedBy.first().size)
val candidate = sortedBy.filter { it.size == sortedBy.first().size }
.reduce { acc, list ->
if (list.strength() > acc.strength()) {
list
} else {
acc
}
}
when {
candidate.size > strongestLongest.size -> strongestLongest = candidate
candidate.size == strongestLongest.size
&& candidate.strength() > strongestLongest.strength() -> strongestLongest = candidate
}
}
}
return if(!partTwo) {
maxStrength.toString()
} else {
strongestLongest.strength().toString()
}
}
private fun doBridge(start: Component, isPort1: Boolean, rest: List<Component>, currentBridge: List<Component> = listOf()): List<List<Component>> {
val bridges = mutableListOf<List<Component>>()
val newCurrentBridge = currentBridge.toMutableList()
newCurrentBridge.add(start)
bridges.add(newCurrentBridge)
val filterRule = if(isPort1) {
{c: Component -> c.port1 == start.port2 || c.port2 == start.port2 }
} else {
{c: Component -> c.port1 == start.port1 || c.port2 == start.port1 }
}
val possibleComponents = rest.filter(filterRule)
possibleComponents.forEach {
val newIsPort1 = if(isPort1) { it.port1 == start.port2 } else { it.port1 == start.port1 }
val newBridges = doBridge(it, newIsPort1, rest.filter { c -> c != it }, newCurrentBridge)
bridges.addAll(newBridges)
}
return bridges
}
}
| 0 | Kotlin | 0 | 2 | 975695cc49f19a42c0407f41355abbfe0cb3cc59 | 3,167 | Advent-of-Code-2017 | MIT License |
lib/src/main/kotlin/com/bloidonia/advent/day12/Day12.kt | timyates | 433,372,884 | false | {"Kotlin": 48604, "Groovy": 33934} | package com.bloidonia.advent.day12
import com.bloidonia.advent.readList
fun String.isUpper() = this.first().isUpperCase()
fun String.isLower() = this.first().isLowerCase()
class CaveSystem(private val routes: Map<String, List<String>>) {
fun next(path: List<String>, check: (List<String>, String) -> Boolean) =
routes[path.last()]
?.filter { cave -> check(path, cave) }
?.filter { cave -> cave != "start" }
?.map { path + it }
?: listOf()
val part1Check = { path: List<String>, cave: String -> cave.isUpper() || path.count { it == cave } < 1 }
val part2Check = { path: List<String>, cave: String ->
part1Check(path, cave) || !path.filter { it.isLower() }.groupingBy { it }.eachCount().any { it.value > 1 }
}
fun allRoutes(check: (List<String>, String) -> Boolean): List<List<String>> {
var listRoutes = listOf(listOf("start"))
val result = mutableListOf<List<String>>()
while (listRoutes.isNotEmpty()) {
listRoutes = listRoutes.flatMap {
next(it, check)
}
result += listRoutes.filter { it.contains("end") }
listRoutes = listRoutes.filter { !it.contains("end") }
}
return result.distinct()
}
private fun mustPassASmallCave(route: List<String>) = route.any { it.isLower() && it != "end" }
fun part1(): Int = allRoutes(part1Check).filter(::mustPassASmallCave).size
fun part2() = allRoutes(part2Check).filter(::mustPassASmallCave).size
}
fun List<String>.parseCaves() = CaveSystem(this.map { it.split("-", limit = 2) }.let { splits ->
splits.flatten().distinct().fold(mutableMapOf()) { acc, s ->
acc[s] = splits.filter { it.contains(s) }.flatten().distinct().minus(s); acc
}
})
fun main() {
println(readList("/day12input.txt").parseCaves().part1())
println(readList("/day12input.txt").parseCaves().part2())
} | 0 | Kotlin | 0 | 1 | 9714e5b2c6a57db1b06e5ee6526eb30d587b94b4 | 1,941 | advent-of-kotlin-2021 | MIT License |
src/Day04.kt | astrofyz | 572,802,282 | false | {"Kotlin": 124466} | fun main() {
fun part1(input: List<String>): Int {
return input.map {elves -> elves.replace(',', '-').split('-').map { it.toInt() } }
.count{edges -> (((edges[2] >= edges[0]) and (edges[1] >= edges[3] ))
or ((edges[0] >= edges[2]) and (edges[3] >= edges[1] )))} // learned about .count in stream
// .sumOf { edges ->
// (((edges[2] >= edges[0]) and (edges[1] >= edges[3] ))
// or ((edges[0] >= edges[2]) and (edges[3] >= edges[1] ))).compareTo(false) }
}
fun part2(input: List<String>): Int {
return input.map {elves -> elves.replace(',', '-').split('-').map { it.toInt() } }
.count { edges -> ((edges[2] <= edges[1]) and (edges[0] <= edges[3]))}
// learned short way to compare, felt a bit ashamed and amazed
// (((edges[2] >= edges[0]) and (edges[3] >= edges[1] ) and (edges[1] >= edges[2]))
// or ((edges[0] >= edges[2]) and (edges[1] >= edges[3]) and (edges[3] >= edges[0]))
// or ((edges[2] >= edges[0]) and (edges[1] >= edges[3] ))
// or ((edges[0] >= edges[2]) and (edges[3] >= edges[1] )))
// .compareTo(false) }
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day04_test")
check(part1(testInput) == 2)
check(part2(testInput) == 4)
val input = readInput("Day04")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | a0bc190b391585ce3bb6fe2ba092fa1f437491a6 | 1,532 | aoc22 | Apache License 2.0 |
src/main/kotlin/dev/tasso/adventofcode/_2021/day09/Day09.kt | AndrewTasso | 433,656,563 | false | {"Kotlin": 75030} | package dev.tasso.adventofcode._2021.day09
import dev.tasso.adventofcode.Solution
class Day09 : Solution<Int> {
override fun part1(input: List<String>): Int {
val heightMap = input.map{ row -> row.toCharArray().map { it.digitToInt() }.toTypedArray() }.toTypedArray()
return getLowPointCoordinates(heightMap).sumOf {
(rowIndex, colIndex) -> heightMap[rowIndex][colIndex] + 1
}
}
override fun part2(input: List<String>): Int {
val heightMap = input.map{ row -> row.toCharArray().map { it.digitToInt() }.toTypedArray() }.toTypedArray()
return getLowPointCoordinates(heightMap).map{ lowPointCoords -> getBasinSize(heightMap, lowPointCoords) }
.sorted()
.takeLast(3)
.reduce { acc, i -> acc * i }
}
}
fun getLowPointCoordinates(heightMap : Array<Array<Int>>): List<Pair<Int, Int>> {
val lowPointCoordinates = mutableListOf<Pair<Int,Int>>()
heightMap.forEachIndexed { rowIndex, row ->
row.forEachIndexed { colIndex, height ->
val adjacentCoordinate = getAdjacentCoordinates(heightMap, rowIndex, colIndex)
if(adjacentCoordinate.all{ (col,row) -> heightMap[col][row] > height}) {
lowPointCoordinates.add(Pair(rowIndex,colIndex))
}
}
}
return lowPointCoordinates.toList()
}
fun getAdjacentCoordinates(heightMap : Array<Array<Int>>, rowIndex : Int, colIndex : Int): List<Pair<Int,Int>> {
return listOfNotNull(
//North
if(rowIndex > 0) Pair(rowIndex-1,colIndex) else null,
//South
if(rowIndex < heightMap.size-1) Pair(rowIndex+1,colIndex) else null,
//West
if(colIndex > 0) Pair(rowIndex,colIndex-1) else null,
//East
if(colIndex < heightMap[0].size-1) Pair(rowIndex, colIndex+1) else null
)
}
fun getBasinSize(heightMap : Array<Array<Int>>,
coords : Pair<Int,Int>,
visitedSet : MutableSet<Pair<Int, Int>> = mutableSetOf()) :
Int {
return if(heightMap[coords.first][coords.second] == 9 || visitedSet.contains(coords)) {
0
}
else {
visitedSet.add(coords)
1 + getAdjacentCoordinates(heightMap, coords.first, coords.second).sumOf {
adjacentCoordinate -> getBasinSize(heightMap, adjacentCoordinate, visitedSet)}
}
}
| 0 | Kotlin | 0 | 0 | daee918ba3df94dc2a3d6dd55a69366363b4d46c | 2,499 | advent-of-code | MIT License |
src/Day07.kt | schoi80 | 726,076,340 | false | {"Kotlin": 83778} | fun main() {
val input = readInput("Day07")
fun String.parse(): Triple<Map<Char, Int>, Long, String> {
val (hand, bid) = split(" ").let {
it[0] to it[1].toLong()
}
val h = mutableMapOf<Char, Int>()
for (c in hand) {
h[c] = 1 + (h[c] ?: 0)
}
return Triple(h, bid, this)
}
fun List<Int>.rank(): Int {
return when (this) {
listOf(5) -> 1
listOf(1, 4) -> 2
listOf(2, 3) -> 3
listOf(1, 1, 3) -> 4
listOf(1, 2, 2) -> 5
listOf(1, 1, 1, 2) -> 6
else -> 7
}
}
fun Map<Char, Int>.score() = this.values.sorted().rank()
fun Char.score(): Int {
return when (this) {
'A' -> 1
'K' -> 2
'Q' -> 3
'J' -> 4
'T' -> 5
else -> 10 - this.digitToInt() + 5
}
}
val compareHands = Comparator<Triple<Map<Char, Int>, Long, String>> { h1, h2 ->
if (h1.first.score() != h2.first.score())
return@Comparator h1.first.score() - h2.first.score()
(0..4).forEach {
val p1 = h1.third[it]
val p2 = h2.third[it]
if (p1 != p2)
return@Comparator p1.score() - p2.score()
}
error("this should never happen")
}
fun Map<Char, Int>.score2(): Int {
val h = this.values.sorted().toMutableList() //.also { it.println() }
val countJ = this['J'] ?: 0
val i = h.lastIndexOf(countJ)
if (i >= 0)
h.removeAt(i)
if (h.size == 0)
h.add(5)
else
h[h.size - 1] += countJ
return h.rank()
}
fun Char.score2(): Int {
return when (this) {
'A' -> 1
'K' -> 2
'Q' -> 3
'J' -> 15 // J gets dwarfed
'T' -> 5
else -> 10 - this.digitToInt() + 5
}
}
val compareHands2 = Comparator<Triple<Map<Char, Int>, Long, String>> { h1, h2 ->
if (h1.first.score2() != h2.first.score2())
return@Comparator h1.first.score2() - h2.first.score2()
(0..4).forEach {
val p1 = h1.third[it]
val p2 = h2.third[it]
if (p1 != p2)
return@Comparator p1.score2() - p2.score2()
}
error("this should never happen")
}
fun part1(input: List<String>): Long {
return input.map { it.parse() }
.sortedWith(compareHands)
.reversed()
.mapIndexed { i, v -> (i + 1) * v.second }
.sum()
}
fun part2(input: List<String>): Long {
return input.map { it.parse() }
.sortedWith(compareHands2)
.reversed()
.mapIndexed { i, v -> (i + 1) * v.second }
.sum()
}
part1(input).println()
part2(input).println()
}
| 0 | Kotlin | 0 | 0 | ee9fb20d0ed2471496185b6f5f2ee665803b7393 | 3,051 | aoc-2023 | Apache License 2.0 |
src/day13/Day13.kt | bartoszm | 572,719,007 | false | {"Kotlin": 39186} | package day13
import readInput
fun main() {
println(solve1(parse(readInput("day13/test"))))
println(solve1(parse(readInput("day13/input"))))
println(solve2(parse(readInput("day13/test"))))
println(solve2(parse(readInput("day13/input"))))
}
fun compare(left: Element, right: Element): Int {
fun compareComp(left: Composite, right: Composite): Int {
val lc = left.children
val rc = right.children
for (i in lc.indices) {
if (i >= rc.size) return 1
val r = compare(lc[i], rc[i])
if (r != 0) return r
}
return if (lc.size == rc.size) 0 else -1
}
return if (left is Leaf) {
if (right is Leaf) left.v - right.v else compare(Composite(left), right)
} else {
if (right is Leaf) compare(left, Composite(right)) else compareComp(
left as Composite,
right as Composite
)
}
}
fun solve2(input: List<Element>): Int {
val toSort = (input + parse(listOf("[[2]]", "[[6]]")))
val sorted = toSort.sortedWith { a, b -> compare(a, b) }
val f = sorted.indexOfFirst { it.toString() == "[[2]]" } + 1
val s = sorted.indexOfFirst { it.toString() == "[[6]]" } + 1
return f * s
}
fun solve1(input: List<Element>): Int {
val results = input.chunked(2).mapIndexed { idx, (l, r) ->
idx + 1 to (compare(l, r) < 0)
}
return results.filter { it.second }.sumOf { it.first }
}
sealed class Element()
class Leaf(val v: Int) : Element() {
override fun toString(): String {
return "$v"
}
}
class Composite(val children: List<Element>) : Element() {
constructor(e: Element) : this(listOf(e))
override fun toString(): String {
return children.joinToString(",", "[", "]")
}
}
fun List<Char>.toInt() = this.joinToString("").toInt()
fun parse(i: Iterator<Char>): Element {
val elem = mutableListOf<Element>()
val number = mutableListOf<Char>()
while (i.hasNext()) {
val c = i.next()
when (c) {
']' -> {
if (number.isNotEmpty()) {
val t = number.joinToString(separator = "")
elem.add(Leaf(t.toInt()))
number.clear()
}
return Composite(elem)
}
'[' -> elem.add(parse(i))
else -> if (c.isDigit()) {
number += c
} else {
if (number.isNotEmpty()) {
elem.add(Leaf(number.toInt()))
number.clear()
}
}
}
}
return elem[0]
}
fun parse(input: List<String>): List<Element> {
return input
.filter { it.isNotBlank() }
.map { parse(it.iterator()) }
}
| 0 | Kotlin | 0 | 0 | f1ac6838de23beb71a5636976d6c157a5be344ac | 2,787 | aoc-2022 | Apache License 2.0 |
src/main/kotlin/com/chriswk/aoc/advent2018/Day7.kt | chriswk | 317,863,220 | false | {"Kotlin": 481061} | package com.chriswk.aoc.advent2018
object Day7 {
val dependency = """Step (\w) must be finished before step (\w) can begin\.""".toRegex()
data class Requirement(val prereq: Char, val downstream: Char)
fun part1(requirements: List<String>): String {
val reqAsMap = parseReq(requirements)
return findPath(reqAsMap)
}
fun part2(workers: Int = 5, requirements: List<String>): Int {
val allPairs = allPairs(requirements)
val dependedOn = generateDependencies(allPairs.map { it.second to it.first })
val dependedBy = generateDependencies(allPairs)
val allKeys = dependedBy.keys.union(dependedOn.keys)
val ready = allKeys.filterNot { it in dependedOn }.map { it to it.toTime() }.toMutableList()
val done = mutableListOf<Char>()
var time = 0
while (ready.isNotEmpty()) {
ready.take(workers).forEachIndexed { idx, work ->
ready[idx] = Pair(work.first, work.second - 1)
}
ready.filter { it.second == 0 }.forEach { workItem ->
done.add(workItem.first)
dependedBy[workItem.first]?.let { maybeReadyS ->
ready.addAll(
maybeReadyS.filter { maybeReady ->
dependedOn.getValue(maybeReady).all { it in done || it == workItem.first }
}.map {
it to it.toTime()
}.sortedBy { it.first }
)
}
}
ready.removeIf { it.second == 0 }
time++
}
return time
}
fun findNext(requirements: Map<Char, Set<Char>>, soFar: String): List<Char> {
return requirements.filterNot {
soFar.contains(it.key)
}.filter {
it.value.all { v -> soFar.contains(v) }
}.map {
it.key
}
}
fun Char.toTime(): Int {
return this.code - 4
}
tailrec fun findPath(requirements: Map<Char, Set<Char>>, soFar: String = ""): String {
val next = nextStep(requirements, soFar)
return if (next == null) soFar else findPath(requirements, soFar + next)
}
private fun nextStep(requirements: Map<Char, Set<Char>>, soFar: String): Char? {
return findNext(requirements, soFar).minOrNull()
}
private fun allPairs(requirements: List<String>): List<Pair<Char, Char>> = requirements.map { row ->
row.split(" ").run { this[1].first() to this[7].first() }
}
private fun generateDependencies(input: List<Pair<Char, Char>>): Map<Char, Set<Char>> {
return input.groupBy { it.first }.mapValues { (_, value) -> value.map { it.second }.toSet() }
}
private fun parseReq(requirements: List<String>): Map<Char, Set<Char>> {
val dependencies = requirements.asSequence().mapNotNull(dependency::matchEntire)
.map { it.groupValues }
.map { Requirement(it[1][0], it[2][0]) }
.groupBy { it.downstream }
.mapValues { it.value.fold(setOf<Char>()) { acc, dep -> acc + dep.prereq } }
val steps = dependencies.values.flatten().union(dependencies.keys)
return steps.map { Pair(it, dependencies[it] ?: emptySet()) }.toMap()
}
}
| 116 | Kotlin | 0 | 0 | 69fa3dfed62d5cb7d961fe16924066cb7f9f5985 | 3,344 | adventofcode | MIT License |
src/day16/Day16.kt | EndzeitBegins | 573,569,126 | false | {"Kotlin": 111428} | package day16
import readInput
import readTestInput
private data class Valve(
val flowRate: Long,
val tunnelsTo: Set<String>,
)
private typealias Valves = Map<String, Valve>
private fun List<String>.toValves(): Valves {
val regex = """Valve (\w+) has flow rate=(\d+);.*valves? (\w+(, \w+)*)""".toRegex()
return associate { line ->
val (name, rate, tunnels) = checkNotNull(regex.matchEntire(line)).destructured
name to Valve(flowRate = rate.toLong(), tunnelsTo = tunnels.split(", ").toSet())
}
}
private fun Valves.findShortestRoutes(): Map<String, Map<String, Int>> {
val valves = this
var shortestRoutes: Map<String, Map<String, Int>> = mapValues { (_, valve) ->
valve.tunnelsTo.associateWith { 1 }
}
repeat(valves.size) {
shortestRoutes = shortestRoutes.mapValues { (_, routesFromValve) ->
val allRoutes = routesFromValve
.flatMap { existingRoute ->
val (middleTarget, cost) = existingRoute
shortestRoutes.getValue(middleTarget).map { (subTarget, subCost) ->
subTarget to cost + subCost
}
} + routesFromValve.map { it.key to it.value }
allRoutes
.groupBy { it.first }
.mapValues { (_, costs) -> costs.minOf { it.second } }
.toMap()
}
if (shortestRoutes.all { routes -> routes.value.size == valves.size }) {
return shortestRoutes
}
}
return shortestRoutes
}
private data class PossibleMove(
val position: String,
val valvesOpened: Set<String>,
val releasedPressureAtEnd: Long,
val timeLeft: Int,
)
private fun findPossibleTargets(
shortestRoutes: Map<String, Map<String, Int>>,
valves: Valves,
position: String,
timeLeft: Int,
valvesOpened: Set<String>
) = shortestRoutes.getValue(position)
.filterNot { (valveName, moveCost) ->
val possibleTargetValve = valves.getValue(valveName)
val cannotOpen = timeLeft < (moveCost + 2)
valveName in valvesOpened || possibleTargetValve.flowRate == 0L || cannotOpen
}
private fun PossibleMove.availableMoves(
valves: Valves,
shortestRoutes: Map<String, Map<String, Int>>
): List<PossibleMove> {
val move = this
val possibleTargets = findPossibleTargets(
shortestRoutes = shortestRoutes,
valves = valves,
position = move.position,
timeLeft = move.timeLeft,
valvesOpened = move.valvesOpened
)
if (move.timeLeft <= 0 || possibleTargets.isEmpty()) {
return listOf(move)
}
return possibleTargets.flatMap { (targetValveName, moveCost) ->
val targetValve = valves.getValue(targetValveName)
val openCost = moveCost + 1
val releasedPressureFromValveAtEnd = (move.timeLeft - openCost) * targetValve.flowRate
PossibleMove(
position = targetValveName,
valvesOpened = move.valvesOpened + targetValveName,
releasedPressureAtEnd = move.releasedPressureAtEnd + releasedPressureFromValveAtEnd,
timeLeft = move.timeLeft - openCost
).availableMoves(valves, shortestRoutes)
} + move
}
private fun part1(input: List<String>): Long {
val valves = input.toValves()
val shortestRoutes = valves.findShortestRoutes()
.filterKeys { valveName -> valveName == "AA" || valves.getValue(valveName).flowRate > 0 }
val initialMove = PossibleMove(
position = "AA",
valvesOpened = emptySet(),
releasedPressureAtEnd = 0L,
timeLeft = 30,
)
val possibleMoves: List<PossibleMove> = listOf(initialMove)
.flatMap { move -> move.availableMoves(valves, shortestRoutes) }
return possibleMoves.maxOf { move -> move.releasedPressureAtEnd }
}
private fun part2(input: List<String>): Long {
val valves = input.toValves()
val shortestRoutes = valves.findShortestRoutes()
.filterKeys { valveName -> valveName == "AA" || valves.getValue(valveName).flowRate > 0 }
val initialMove = PossibleMove(
position = "AA",
valvesOpened = emptySet(),
releasedPressureAtEnd = 0L,
timeLeft = 26,
)
val possibleMoves: List<PossibleMove> = listOf(initialMove)
.flatMap { move -> move.availableMoves(valves, shortestRoutes) }
var maximumPressureRelease = 0L
for (i in possibleMoves.indices) {
val myMove = possibleMoves[i]
val myOpenedValves = myMove.valvesOpened
val myPressureRelease = myMove.releasedPressureAtEnd
for (j in i..possibleMoves.lastIndex) {
val elephantMove = possibleMoves[j]
val elephantOpenedValves = elephantMove.valvesOpened
val elephantPressureRelease = elephantMove.releasedPressureAtEnd
val combinedPressureRelease = myPressureRelease + elephantPressureRelease
if (maximumPressureRelease < combinedPressureRelease &&
myOpenedValves.none { myValve -> myValve in elephantOpenedValves }) {
maximumPressureRelease = combinedPressureRelease
}
}
}
return maximumPressureRelease
}
fun main() {
// test if implementation meets criteria from the description, like:
val testInput = readTestInput("Day16")
check(part1(testInput) == 1651L)
check(part2(testInput) == 1707L)
val input = readInput("Day16")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | ebebdf13cfe58ae3e01c52686f2a715ace069dab | 5,533 | advent-of-code-kotlin-2022 | Apache License 2.0 |
src/day8/Day08.kt | francoisadam | 573,453,961 | false | {"Kotlin": 20236} | package day8
import readInput
fun main() {
fun part1(input: List<String>): Int {
val matrix = input.toMatrix()
var visibleTreesCount = 0
val visibleTrees = mutableListOf<String>()
matrix.forEachIndexed { i, line ->
line.forEachIndexed { j, tree ->
val column = matrix.getColumnAtIndex(j)
val visible = line.subList(0, j).all { it < tree }
|| line.subList(j + 1, line.size).all { it < tree }
|| column.subList(0, i).all { it < tree }
|| column.subList(i + 1, column.size).all { it < tree }
if (visible) {
visibleTreesCount++
visibleTrees.add("tree ligne $i & colonne $j")
}
}
}
return visibleTreesCount
}
fun part2(input: List<String>): Int {
val matrix = input.toMatrix()
val treesMap = mutableListOf<TreeView>()
matrix.forEachIndexed { i, line ->
line.forEachIndexed { j, tree ->
val column = matrix.getColumnAtIndex(j)
treesMap.add(
TreeView(
upTrees = column.subList(0, i).reversed().countVisibleTrees(tree),
downTrees = column.subList(i + 1, column.size).countVisibleTrees(tree),
leftTrees = line.subList(0, j).reversed().countVisibleTrees(tree),
rightTrees = line.subList(j + 1, line.size).countVisibleTrees(tree),
)
)
}
}
return treesMap.maxOfOrNull { it.scenicScore() } ?: 0
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("day8/Day08_test")
val testPart1 = part1(testInput)
println("testPart1: $testPart1")
val testPart2 = part2(testInput)
println("testPart2: $testPart2")
check(testPart1 == 21)
check(testPart2 == 8)
val input = readInput("day8/Day08")
println("part1 : ${part1(input)}")
println("part2 : ${part2(input)}")
}
private fun List<String>.toMatrix(): List<List<Int>> = this.map { line ->
line.toCharArray().map { it.digitToInt() }
}
private fun List<List<Int>>.getColumnAtIndex(index: Int): List<Int> = this.map { line ->
line[index]
}
private data class TreeView(
val upTrees: Int,
val downTrees: Int,
val leftTrees: Int,
val rightTrees: Int,
) {
fun scenicScore(): Int = upTrees * downTrees * leftTrees * rightTrees
}
private fun Iterable<Int>.countVisibleTrees(maxHeight: Int): Int = this.withIndex().takeWhile {
it.index == 0 || this.toList()[it.index - 1] < maxHeight
}.count() | 0 | Kotlin | 0 | 0 | e400c2410db4a8343c056252e8c8a93ce19564e7 | 2,748 | AdventOfCode2022 | Apache License 2.0 |
src/year2022/day15/Solution.kt | TheSunshinator | 572,121,335 | false | {"Kotlin": 144661} | package year2022.day15
import io.kotest.matchers.shouldBe
import kotlin.math.max
import utils.Point
import utils.manhattanDistanceTo
import utils.plusOrMinus
import utils.readInput
import utils.size
fun main() {
val testEmptySpots = readInput("15", "test_input").toSensors().computeEmptySpots()
val emptySpots = readInput("15", "input").toSensors().computeEmptySpots()
testEmptySpots.getValue(10)
.sumOf { it.size }
.also(::println) shouldBe 26
emptySpots.getValue(2000000)
.sumOf { it.size }
.let(::println)
testEmptySpots.asSequence()
.first { it.key in 0..20 && it.value.size > 1 }
.let { (y, confirmedX) -> Point(confirmedX.first().last + 1, y) }
.let { it.x * 4000000 + it.y }
.also(::println) shouldBe 56000011
emptySpots.asSequence()
.first { it.key in 0..4000000 && it.value.size > 1 }
.let { (y, confirmedX) -> Point(confirmedX.first().last + 1, y) }
.let { it.x * 4000000L + it.y }
.let(::println)
}
private fun List<String>.toSensors(): List<Sensor> {
return asSequence()
.mapNotNull(parsingRegex::matchEntire)
.map { it.groupValues }
.mapTo(mutableListOf()) { (_, sensorX, sensorY, beaconX, beaconY) ->
Sensor(
Point(sensorX.toInt(), sensorY.toInt()),
Point(beaconX.toInt(), beaconY.toInt()),
)
}
}
private val parsingRegex = "Sensor at x=(\\d+), y=(\\d+): closest beacon is at x=(-?\\d+), y=(-?\\d+)".toRegex()
private data class Sensor(
val position: Point,
val closestBeacon: Point,
) {
val distance = position manhattanDistanceTo closestBeacon
val emptySpotsConfirmed: Map<Int, IntRange> = (0..2 * distance).associate { row ->
Pair(
position.y - distance + row,
if (row <= distance) position.x plusOrMinus row
else position.x.plusOrMinus(2 * distance - row)
)
}
}
private fun List<Sensor>.computeEmptySpots(): Map<Int, List<IntRange>> {
return asSequence()
.map { it.emptySpotsConfirmed }
.flatMap { it.entries }
.groupBy { it.key }
.mapValues { (_, ranges) ->
ranges.asSequence()
.map { it.value }
.simplifyRanges()
}
}
private fun Sequence<IntRange>.simplifyRanges(): List<IntRange> = sortedBy { it.first }.fold(mutableListOf()) { rangeAccumulator, range ->
val lastRange = rangeAccumulator.lastOrNull()
when {
lastRange == null || lastRange.last < range.first - 1 -> rangeAccumulator.add(range)
else -> rangeAccumulator[rangeAccumulator.lastIndex] = IntRange(
lastRange.first,
max(range.last, lastRange.last)
)
}
rangeAccumulator
}
| 0 | Kotlin | 0 | 0 | d050e86fa5591447f4dd38816877b475fba512d0 | 2,798 | Advent-of-Code | Apache License 2.0 |
src/year2023/Day13.kt | drademacher | 725,945,859 | false | {"Kotlin": 76037} | package year2023
import Grid
import readLines
fun main() {
val input = parseInput(readLines("2023", "day13"))
val testInput = parseInput(readLines("2023", "day13_test"))
check(part1(testInput) == 405)
println("Part 1:" + part1(input))
check(part2(testInput) == 400)
println("Part 2:" + part2(input))
}
private fun parseInput(input: List<String>): List<Grid<Char>> {
var input = input
val patterns = mutableListOf<Grid<Char>>()
while (input.isNotEmpty()) {
val patternLength = input.takeWhile { it != "" }.size
patterns.add(Grid(input.take(patternLength).map { it.toCharArray().toList() }))
input = input.drop(patternLength + 1)
}
return patterns
}
private fun part1(patterns: List<Grid<Char>>): Int {
val x =
patterns.map {
pattern ->
(isHorizontallyMirrored(pattern).firstOrNull()?.let { it * 100 }) ?: isVerticallyMirrored(pattern).first()
}
return x.sum()
}
private fun part2(patterns: List<Grid<Char>>): Int {
return patterns.map { pattern ->
val initialHorizontalMirrors = isHorizontallyMirrored(pattern).toSet()
val initialVerticalMirrors = isVerticallyMirrored(pattern).toSet()
pattern.allFlips().mapNotNull { flippedPattern ->
val horizontalMirrors = isHorizontallyMirrored(flippedPattern).minus(initialHorizontalMirrors)
val verticalMirrors = isVerticallyMirrored(flippedPattern).minus(initialVerticalMirrors)
if (horizontalMirrors.isNotEmpty() || verticalMirrors.isNotEmpty()) {
horizontalMirrors.firstOrNull()?.let { it * 100 } ?: verticalMirrors.first()
} else {
null
}
}.first()
}.sum()
return 0
}
private fun isHorizontallyMirrored(pattern: Grid<Char>): List<Int> {
return (1..<pattern.rows).filter { mirror ->
(1..mirror).all { row ->
val mirroredRow = 2 * mirror - row + 1
mirroredRow > pattern.rows || pattern.nthRow(row - 1) == pattern.nthRow(mirroredRow - 1)
}
}
}
private fun isVerticallyMirrored(pattern: Grid<Char>): List<Int> {
return (1..<pattern.cols).filter { mirror ->
(1..mirror).all { col ->
val mirroredCol = 2 * mirror - col + 1
mirroredCol > pattern.cols || pattern.nthCol(col - 1) == pattern.nthCol(mirroredCol - 1)
}
}
}
private fun Grid<Char>.allFlips(): List<Grid<Char>> {
return (1..rows).map { row ->
(1..cols).map { col ->
this.flip(row, col)
}
}.flatten()
}
private fun Grid<Char>.flip(
col: Int,
row: Int,
): Grid<Char> {
val newData =
data.mapIndexed { y, chars ->
if (y == row - 1) {
chars.mapIndexed { x, char ->
if (x == col - 1) {
if (char == '.') '#' else '.'
} else {
char
}
}
} else {
chars
}
}
return Grid(newData)
}
| 0 | Kotlin | 0 | 0 | 4c4cbf677d97cfe96264b922af6ae332b9044ba8 | 3,098 | advent_of_code | MIT License |
src/day24/d24_1.kt | svorcmar | 720,683,913 | false | {"Kotlin": 49110} | fun main() {
val input = ""
val list = input.lines().map { it.toInt() }
val groupSize = list.sum() / 3
val firstGroup = solve(list, groupSize)
// order by quantum entanglement and find smallest one for which
// the rest of packages can be divided in two groups of the same weight
val candidates = firstGroup.map { it.map(Int::toLong).reduce(Long::times) to it }.sortedBy { it.first }
for (candidate in candidates) {
if (solve(list - candidate.second, groupSize).isNotEmpty()) {
println(candidate.first)
break
}
}
}
fun solve(packages: List<Int>, target: Int): List<List<Int>> {
// dp[i][j] == set of the smallest subsets of the first i elements that sum to j
val dp = Array(packages.size + 1) { Array(target + 1) {
if (it == 0)
0 to listOf(emptyList<Int>())
else
packages.size to emptyList<List<Int>>()
}
}
packages.forEachIndexed { i0, n ->
val i = i0 + 1
for (j in 1 .. target) {
dp[i][j] = dp[i - 1][j]
if (j >= n) {
val prevRow = dp[i - 1][j - n]
if (prevRow.first + 1 < dp[i][j].first) {
dp[i][j] = prevRow.first + 1 to prevRow.second.map { it -> it + n }
} else if (prevRow.first + 1 == dp[i][j].first) {
dp[i][j] = dp[i][j].first to dp[i][j].second + prevRow.second.map { it -> it + n }
}
}
}
}
return dp[packages.size][target].second
}
| 0 | Kotlin | 0 | 0 | cb097b59295b2ec76cc0845ee6674f1683c3c91f | 1,416 | aoc2015 | MIT License |
src/Day12.kt | JanTie | 573,131,468 | false | {"Kotlin": 31854} | fun main() {
fun parseInput(input: List<String>): List<List<Tile>> = input
.map { line -> line.map { it } }
.let { map ->
map.mapIndexed { rowIndex, row ->
row.mapIndexed { index, char ->
Tile(
x = index,
y = rowIndex,
char = char,
isStart = char == 'S',
isEnd = char == 'E',
)
}
}
}
fun grow(
initialTile: Tile,
grid: List<List<Tile>>,
): Pair<Int, Boolean> {
var currentPaths = listOf(initialTile)
var iteration = 0
val seenTiles = mutableSetOf<Tile>()
while (!currentPaths.any { it.isEnd } && currentPaths.isNotEmpty()) {
currentPaths = currentPaths
.flatMap { visited ->
seenTiles.add(visited)
val tileToLeft = if (visited.x != 0) grid[visited.y][visited.x - 1] else null
val tileToTop = if (visited.y != 0) grid[visited.y - 1][visited.x] else null
val tileToRight = if (visited.x != grid[0].lastIndex) grid[visited.y][visited.x + 1] else null
val tileToBottom = if (visited.y != grid.lastIndex) grid[visited.y + 1][visited.x] else null
return@flatMap listOfNotNull(tileToLeft, tileToTop, tileToRight, tileToBottom)
.filter { (it.height - visited.height) <= 1 } // legit to go there
}
.distinct()
.filter { it !in seenTiles }
iteration++
}
return iteration to currentPaths.any { it.isEnd }
}
fun part1(input: List<String>): Int {
val grid = parseInput(input)
return grow(grid.flatten().first { it.isStart }, grid).first
}
fun part2(input: List<String>): Int {
val grid = parseInput(input)
return grid.flatten().filter { it.char == 'a' }
.map { grow(it, grid) }
.filter { it.second }
.minOf { it.first }
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day12_test")
val input = readInput("Day12")
check(part1(testInput) == 31)
println(part1(input))
check(part2(testInput) == 29)
println(part2(input))
}
private data class Tile(
val x: Int,
val y: Int,
val char: Char,
val isStart: Boolean,
val isEnd: Boolean,
) {
val height = when (char) {
'S' -> 'a'
'E' -> 'z'
else -> char
}.code
}
| 0 | Kotlin | 0 | 0 | 3452e167f7afe291960d41b6fe86d79fd821a545 | 2,665 | advent-of-code-2022 | Apache License 2.0 |
src/day15/Day15.kt | dkoval | 572,138,985 | false | {"Kotlin": 86889} | package day15
import readInput
import kotlin.math.abs
private const val DAY_ID = "15"
private data class Point(
val x: Int,
val y: Int
) {
companion object {
fun fromString(s: String): Point {
// example: x=-2, y=15
val (x, y) = s.split(", ").map { it.substringAfter("=").toInt() }
return Point(x, y)
}
}
}
private data class Data(
val sensor: Point,
val beacon: Point
)
private data class Interval(
var start: Int,
var end: Int
) {
fun overlapsWith(that: Interval): Boolean = that.end >= start && that.start <= end
operator fun contains(x: Int): Boolean = x in start..end
}
fun main() {
fun parseInput(input: List<String>): List<Data> =
input.map { line ->
val (sensor, closestBeacon) = line.split(": ").asSequence()
.map { it.substringAfter("at ") }
.map { Point.fromString(it) }
.toList()
Data(sensor, closestBeacon)
}
fun part1(input: List<String>, y: Int): Int {
val data = parseInput(input)
val beacons = mutableSetOf<Point>()
val intervals = mutableListOf<Interval>()
for ((sensor, beacon) in data) {
if (beacon.y == y) {
beacons += beacon
}
val dx = abs(sensor.x - beacon.x)
val dy = abs(sensor.y - beacon.y)
val dist = dx + dy
// (S, B) pair defines a square with S being in the middle, where other beacons can't possibly exist
// for each such (S, B) pair, find an intersection with row Y:
// |x - S[i].x| + |Y - S[i].y| = dist
// |x - S[i].x| = dist - |Y - S[i].y|
// let D = dist - |Y - S[i].y|, then
// x - S[i].x = ±D
// <=>
// x = S[i].x - D <- start of the interval
// x = S[i].x + D <- end of the interval
val d = dist - abs(y - sensor.y)
if (d <= 0) {
continue
}
intervals += Interval(sensor.x - d, sensor.x + d)
}
// merge potentially overlapping intervals
intervals.sortBy { it.start }
val union = mutableListOf<Interval>()
for (interval in intervals) {
if (union.isEmpty() || !union.last().overlapsWith(interval)) {
union += interval
} else {
val last = union.last()
last.end = maxOf(last.end, interval.end)
}
}
return union.fold(0) { acc, interval ->
var total = interval.end - interval.start + 1
for (beacon in beacons) {
if (beacon.x in interval) {
total--
}
}
acc + total
}
}
fun part2(input: List<String>): Int {
TODO()
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("day${DAY_ID}/Day${DAY_ID}_test")
check(part1(testInput, 10).also { println(it) } == 26)
//check(part2(testInput) == 42)
val input = readInput("day${DAY_ID}/Day$DAY_ID")
println(part1(input, 2000000))
//println(part2(input))
}
| 0 | Kotlin | 1 | 0 | 791dd54a4e23f937d5fc16d46d85577d91b1507a | 3,251 | aoc-2022-in-kotlin | Apache License 2.0 |
src/Day12.kt | jordan-thirus | 573,476,470 | false | {"Kotlin": 41711} | import java.util.PriorityQueue
fun main() {
val startChar = 'S'
val endChar = 'E'
fun getHeight(height: Char) = when(height){
endChar -> 'z'
startChar -> 'a'
else -> height
}
fun shortestPathToEnd(priorityQueue: PriorityQueue<Step>, input: List<String>): Int {
val visited = mutableSetOf<Point>()
while (priorityQueue.any()) {
val step = priorityQueue.remove()
//if we've been here, don't process again
if (!visited.contains(step.point)) {
//if it's the end, return
if (step.height == endChar) {
return step.distanceTraveled
}
//mark as visited
visited.add(step.point)
val nextDistance = step.distanceTraveled + 1
for (n in step.neighbors().filter { it.isInBounds(input.indices, input[0].indices) }) {
val nextHeight = input[n.y][n.x]
if (getHeight(step.height) - getHeight(nextHeight) >= -1) {
priorityQueue.add(Step(n, nextHeight, nextDistance))
}
}
}
}
return Int.MAX_VALUE
}
fun part1(input: List<String>): Int {
val priorityQueue = PriorityQueue<Step>()
input.forEachIndexed { index, chars ->
if (chars.contains(startChar)){
priorityQueue.add(Step.build(index, chars.indexOf(startChar), startChar, 0))
}
}
return shortestPathToEnd(priorityQueue, input)
}
fun part2(input: List<String>): Int {
val priorityQueue = PriorityQueue<Step>()
input.forEachIndexed { index, chars ->
chars.forEachIndexed { i, c ->
if(getHeight(c) == 'a'){
priorityQueue.add(Step.build(index, i, c, 0))
}
}
}
return shortestPathToEnd(priorityQueue, input)
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day12_test")
check(part1(testInput) == 31)
check(part2(testInput) == 29)
val input = readInput("Day12")
println(part1(input))
println(part2(input))
}
data class Step(val point: Point, val height: Char, val distanceTraveled: Int): Comparable<Step> {
fun neighbors(): Set<Point> = point.neighbors()
companion object {
fun build(y: Int, x: Int, height: Char, distanceTraveled: Int): Step =
Step(Point(y, x), height, distanceTraveled)
}
override fun compareTo(other: Step): Int {
return distanceTraveled - other.distanceTraveled
}
}
| 0 | Kotlin | 0 | 0 | 59b0054fe4d3a9aecb1c9ccebd7d5daa7a98362e | 2,709 | advent-of-code-2022 | Apache License 2.0 |
src/Day08.kt | ShuffleZZZ | 572,630,279 | false | {"Kotlin": 29686} | private fun getGrid(input: List<String>) = input.map { it.map(Char::digitToInt).toTypedArray() }.toTypedArray()
private fun observeLines(grid: Array<Array<Int>>, res: Array<BooleanArray>, lineInds: IntRange, rowInds: IntProgression) {
val maxRowInd = if (rowInds.isRange()) 0 else grid.first().size - 1
for (i in lineInds) {
var max = grid[i + 1][maxRowInd]
for (j in rowInds) {
if (grid[i + 1][j + 1] > max) {
res[i][j] = true
max = grid[i + 1][j + 1]
}
}
}
if (rowInds.isRange()) observeLines(grid, res, lineInds, rowInds.reversed())
}
private fun observeRows(grid: Array<Array<Int>>, res: Array<BooleanArray>, lineInds: IntProgression, rowInds: IntRange) {
val maxLineInd = if (lineInds.isRange()) 0 else grid.size - 1
for (j in rowInds) {
var max = grid[maxLineInd][j + 1]
for (i in lineInds) {
if (grid[i + 1][j + 1] > max) {
res[i][j] = true
max = grid[i + 1][j + 1]
}
}
}
if (lineInds.isRange()) observeRows(grid, res, lineInds.reversed(), rowInds)
}
private fun scenicScore(grid: Array<Array<Int>>, spot: Pair<Int, Int>) =
neighbours().map { observeTree(grid, spot, it) }.reduce(Int::times)
private fun observeTree(grid: Array<Array<Int>>, spot: Pair<Int, Int>, shift: Pair<Int, Int>): Int {
var dist = 0
var indexes = spot + shift
while (indexes.first in grid.indices && indexes.second in grid.first().indices) {
dist++
if (grid[indexes.first][indexes.second] >= grid[spot.first][spot.second]) break
indexes += shift
}
return dist
}
fun main() {
fun part1(input: List<String>): Int {
val grid = getGrid(input)
val n = grid.size
val m = grid.first().size
val res = Array(n - 2) { BooleanArray(m - 2) { false } }
observeLines(grid, res, res.indices, res.first().indices)
observeRows(grid, res, res.indices, res.first().indices)
return res.sumOf { it.count { e -> e } } + 2 * (n + m - 2)
}
fun part2(input: List<String>): Int {
val grid = getGrid(input)
val res = Array(grid.size - 2) { IntArray(grid.first().size - 2) { 0 } }
for (i in res.indices) {
for (j in res.indices) {
res[i][j] = scenicScore(grid, i + 1 to j + 1)
}
}
return res.maxOf { it.max() }
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 5a3cff1b7cfb1497a65bdfb41a2fe384ae4cf82e | 2,750 | advent-of-code-kotlin | Apache License 2.0 |
src/Day15.kt | djleeds | 572,720,298 | false | {"Kotlin": 43505} | import lib.Coordinates
import kotlin.math.absoluteValue
import kotlin.math.max
import kotlin.math.min
fun IntRange.clamp(minimum: Int, maximum: Int) = max(minimum, first)..min(maximum, last)
fun Set<IntRange>.consolidate(): Set<IntRange> {
var result = this
var lastCount: Int
do {
lastCount = result.size
result = result.fold(setOf()) { acc, incoming ->
if (acc.isEmpty()) {
setOf(incoming)
} else {
buildSet {
var hasConsolidated = false
for (range in acc) {
val isIncomingInThis = incoming.first - 1 in range || incoming.last + 1 in range
val isThisInIncoming = range.first - 1 in incoming || range.last + 1 in incoming
if (isIncomingInThis || isThisInIncoming) {
add(IntRange(min(range.first, incoming.first), max(range.last, incoming.last)))
hasConsolidated = true
} else {
add(range)
}
}
if (!hasConsolidated) add(incoming)
}
}
}
} while (result.size != lastCount && result.size > 1)
return result
}
data class Sensor(val coordinates: Coordinates, val closestBeacon: Coordinates) {
private val distance = coordinates.manhattanDistanceTo(closestBeacon)
fun positionsWithNoBeacon(y: Int): IntRange? {
val yDistanceFromSensor = (coordinates.y - y).absoluteValue
if (yDistanceFromSensor > distance) return null
val xDistance = (distance - yDistanceFromSensor).absoluteValue
val left = coordinates.x - xDistance
val right = coordinates.x + xDistance
return if (right - left > 0) left..right else null
}
}
private fun parse(input: List<String>): Set<Sensor> {
val pattern = Regex("Sensor at x=(-?\\d+), y=(-?\\d+): closest beacon is at x=(-?\\d+), y=(-?\\d+)")
return buildSet {
input.forEach { line ->
pattern.find(line)?.run {
add(Sensor(Coordinates(groupValues[1].toInt(), groupValues[2].toInt()), Coordinates(groupValues[3].toInt(), groupValues[4].toInt())))
}
}
}
}
fun main() {
fun part1(input: List<String>, row: Int): Int {
val sensors = parse(input)
val reports = sensors.mapNotNull { it.positionsWithNoBeacon(row) }
val merged = reports.toSet().consolidate()
val noBeaconPositionCount = merged.sumOf { it.count() }
val sensorsAndBeaconsOnRow = sensors
.flatMap { listOf(it.coordinates, it.closestBeacon) }
.distinct()
.filter { it.y == row }
.filter { occupiedCoordinate -> merged.any { occupiedCoordinate.x in it } }
return noBeaconPositionCount - sensorsAndBeaconsOnRow.count()
}
fun part2(input: List<String>, range: IntRange): Long {
val sensors = parse(input)
val coordinates = range
.map { y ->
sensors
.mapNotNull { it.positionsWithNoBeacon(y) }
.map { it.clamp(range.first, range.last) }
.toSet()
.consolidate()
}
.mapIndexedNotNull { index, ranges ->
if (ranges.count() == 2) {
Coordinates(ranges.toList().first().last + 1, index)
} else null
}
.single()
return (coordinates.x * 4000000L) + coordinates.y
}
val testInput = readInput("Day15_test")
println(part1(testInput, 10))
println(part2(testInput, 0..20))
val input = readInput("Day15")
println(part1(input, 2_000_000))
println(part2(input, 0..4_000_000))
}
| 0 | Kotlin | 0 | 4 | 98946a517c5ab8cbb337439565f9eb35e0ce1c72 | 3,857 | advent-of-code-in-kotlin-2022 | Apache License 2.0 |
src/day15/Day15.kt | davidcurrie | 579,636,994 | false | {"Kotlin": 52697} | package day15
import java.io.File
import kotlin.math.abs
fun main() {
val regexp = Regex("Sensor at x=(-?\\d*), y=(-?\\d*): closest beacon is at x=(-?\\d*), y=(-?\\d*)")
val sensors = File("src/day15/input.txt").readLines()
.map { regexp.matchEntire(it)!!.groupValues }
.map { values ->
Sensor(Pair(values[1].toInt(), values[2].toInt()), Pair(values[3].toInt(), values[4].toInt()))
}.toSet()
val row = 2000000 // 10
println(sensors.map { it.excludes(row) }.reduce().sumOf { it.last - it.first })
val max = 4000000 // 20
// Part 2 using the fact everything must be excluded by a single range in every other row
for (row in 0 .. max) {
val exclusions = sensors.map { sensor -> sensor.excludes(row) }.reduce()
if (exclusions.size > 1) {
val column = (0..max).firstOrNull { exclusions.none { exclusion -> exclusion.contains(it) } } ?: continue
println(column * 4000000L + row)
break
}
}
// Part 2 using the fact that the beacon must be just outside a sensor's exclusion range
for (row in 0 .. max) {
val exclusions = sensors.map { sensor -> sensor.excludes(row) }
val options = exclusions.map { range -> listOf(range.first - 1, range.last + 1) }.flatten().filter { it in 0..max }
val column = options.firstOrNull { option -> exclusions.none { exclusion -> exclusion.contains(option) } }
if (column != null) {
println(column * 4000000L + row)
break
}
}
}
fun List<IntRange>.reduce(): List<IntRange> {
if (size < 2) return this
for (i in 0 until size - 1) {
for (j in i + 1 until size) {
if (this[i].overlap(this[j]) || this[i].adjacent(this[j])) {
val result = this.subList(0, i).toMutableList()
result.addAll(this.subList(i + 1, j))
result.addAll(this.subList(j + 1, size))
result.addAll(this[i].merge(this[j]))
return result.reduce()
}
}
}
return this
}
fun IntRange.overlap(other: IntRange): Boolean {
return first <= other.last && last >= other.first
}
fun IntRange.adjacent(other: IntRange): Boolean {
return first == other.last + 1 || last == other.first - 1
}
fun IntRange.merge(other: IntRange): List<IntRange> {
return if (overlap(other) || adjacent(other)) listOf(IntRange(kotlin.math.min(first, other.first), kotlin.math.max(last, other.last))) else listOf(this, other)
}
data class Sensor(val sensor: Pair<Int, Int>, val beacon: Pair<Int, Int>) {
private val distance = abs(sensor.first - beacon.first) + abs(sensor.second - beacon.second)
fun excludes(row: Int): IntRange {
val distanceFromRow = abs(sensor.second - row)
val difference = distance - distanceFromRow
if (difference < 0) return IntRange.EMPTY
return (sensor.first - difference .. sensor.first + difference)
}
} | 0 | Kotlin | 0 | 0 | 0e0cae3b9a97c6019c219563621b43b0eb0fc9db | 2,989 | advent-of-code-2022 | MIT License |
src/year2020/day05/Day05.kt | fadi426 | 433,496,346 | false | {"Kotlin": 44622} | package year2020.day05
import util.assertTrue
import util.read2020DayInput
import kotlin.math.roundToInt
fun main() {
val input = read2020DayInput("Day05")
assertTrue(task01(input) == 801)
assertTrue(task02(input) == 597)
}
private fun task02(input: List<String>): Int {
val sortedSeats =
input.map { calculateRow(it, Range(0, 127), 0) * 8 + calculateColumn(it, Range(0, 7), 7) }.sorted()
sortedSeats.forEachIndexed { i, s ->
if (sortedSeats[i + 1] - s != 1) return s + 1
}
return 0
}
private fun task01(input: List<String>): Int {
return input.maxOf { calculateRow(it, Range(0, 127), 0) * 8 + calculateColumn(it, Range(0, 7), 7) }
}
private fun calculateRow(characters: String, range: Range, count: Int): Int {
return if (count == 7) {
val half = ((range.max.toDouble() - range.min.toDouble()) / 2) + range.min
if (characters[count] == 'B') half.roundToInt() else half.toInt()
} else {
val half = ((range.max.toDouble() - range.min.toDouble()) / 2) + range.min
if (characters[count] == 'B') calculateRow(characters, Range(half.roundToInt(), range.max), count + 1)
else calculateRow(characters, Range(range.min, half.toInt()), count + 1)
}
}
private fun calculateColumn(characters: String, range: Range, count: Int): Int {
return if (count == 9) {
val half = ((range.max.toDouble() - range.min.toDouble()) / 2) + range.min
if (characters[count] == 'R') half.roundToInt() else half.toInt()
} else {
val half = ((range.max.toDouble() - range.min.toDouble()) / 2) + range.min
if (characters[count] == 'R') calculateColumn(characters, Range(half.roundToInt(), range.max), count + 1)
else calculateColumn(characters, Range(range.min, half.toInt()), count + 1)
}
}
private data class Range(val min: Int, val max: Int)
| 0 | Kotlin | 0 | 0 | acf8b6db03edd5ff72ee8cbde0372113824833b6 | 1,871 | advent-of-code-kotlin-template | Apache License 2.0 |
src/Day08.kt | flex3r | 572,653,526 | false | {"Kotlin": 63192} | import kotlin.math.max
fun main() {
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input))
println(part2(input))
}
private fun part1(input: List<String>): Int {
val trees = parseTrees(input)
val runningMaxSides = listOf(
trees.runningMaxStart(),
trees.runningMaxEnd(),
trees.runningMaxTop(),
trees.runningMaxBottom(),
)
return trees.withIndex().sumOf { (i, row) ->
row.withIndex().count { (j, tree) -> runningMaxSides.any { it[i][j] < tree } }
}
}
private fun part2(input: List<String>): Int {
val trees = parseTrees(input)
val scenicValues = listOf(
trees.scenicValuesStart(),
trees.scenicValuesEnd(),
trees.scenicValuesTop(),
trees.scenicValuesBottom(),
)
return trees.withIndex().flatMap { (i, row) ->
row.withIndex().map { (j, _) ->
scenicValues
.map { it[i][j] }
.reduce { acc, it -> acc * it }
}
}.max()
}
private fun parseTrees(input: List<String>): List<List<Int>> = input.map { row -> row.map { it.digitToInt() } }
private fun List<List<Int>>.runningMaxStart(): List<List<Int>> = map { row ->
row.dropLast(1)
.runningFold(-1) { acc, tree -> max(acc, tree) }
}
private fun List<List<Int>>.runningMaxEnd(): List<List<Int>> = map { row ->
row.drop(1)
.reversed()
.runningFold(-1) { acc, tree -> max(acc, tree) }
.reversed()
}
private fun List<List<Int>>.runningMaxTop(): List<List<Int>> = transpose().runningMaxStart().transpose()
private fun List<List<Int>>.runningMaxBottom(): List<List<Int>> = transpose().runningMaxEnd().transpose()
private fun List<List<Int>>.scenicValuesStart(): List<List<Int>> = map { it.scenicDistances() }
private fun List<List<Int>>.scenicValuesEnd(): List<List<Int>> = map { it.reversed().scenicDistances().reversed() }
private fun List<List<Int>>.scenicValuesTop(): List<List<Int>> = transpose().scenicValuesStart().transpose()
private fun List<List<Int>>.scenicValuesBottom(): List<List<Int>> = transpose().scenicValuesEnd().transpose()
private fun List<Int>.scenicDistances(): List<Int> {
return mapIndexed { idx, tree ->
slice(idx + 1..lastIndex)
.indexOfFirst { it >= tree }
.takeIf { it != -1 }
?.inc()
?: (lastIndex - idx)
}
} | 0 | Kotlin | 0 | 0 | 8604ce3c0c3b56e2e49df641d5bf1e498f445ff9 | 2,474 | aoc-22 | Apache License 2.0 |
src/Day13.kt | jinie | 572,223,871 | false | {"Kotlin": 76283} | class Day13 {
private fun ordered(l: MutableList<Char>, r: MutableList<Char>): Boolean {
fun MutableList<Char>.addBrackets(len: Int) = apply { add(len, ']'); add(0, '[') }
fun List<Char>.num(): Int? =
if (!this.first().isDigit()) null else this.takeWhile { it.isDigit() }.joinToString("").toInt()
if (l.first() == '[' && r.num() != null) r.addBrackets(r.num().toString().length)
if (r.first() == '[' && l.num() != null) l.addBrackets(l.num().toString().length)
return when {
l[0] == ']' && r[0] != ']' -> true
l[0] != ']' && r[0] == ']' -> false
l.num() == (r.num() ?: -1) -> ordered(
l.subList(l.num().toString().length, l.size),
r.subList(r.num().toString().length, r.size)
)
l.num() != null && r.num() != null -> l.num()!! < r.num()!!
else -> ordered(l.subList(1, l.size), r.subList(1, r.size))
}
}
val comparePackets: (String, String) -> Int =
{ s1: String, s2: String -> if (ordered(s1.toMutableList(), s2.toMutableList())) -1 else 1 }
fun part1(input: List<String>): Int {
return (input.windowed(2, 3)
.mapIndexed { i, packets -> if (comparePackets(packets.first(), packets.last()) != 1) i + 1 else 0 }.sum())
}
fun part2(input: List<String>): Int {
val sorted = (input.windowed(2, 3).flatten() + "[[2]]" + "[[6]]").sortedWith(comparePackets)
return ((1 + sorted.indexOf("[[2]]")) * (1 + sorted.indexOf("[[6]]")))
}
}
fun main() {
val testInput = readInput("Day13_test")
check(Day13().part1(testInput) == 13)
check(Day13().part2(testInput) == 140)
measureTimeMillisPrint {
val input = readInput("Day13")
println(Day13().part1(input))
println(Day13().part2(input))
}
} | 0 | Kotlin | 0 | 0 | 4b994515004705505ac63152835249b4bc7b601a | 1,862 | aoc-22-kotlin | Apache License 2.0 |
src/main/kotlin/advent/of/code/day06/Solution.kt | brunorene | 160,263,437 | false | null | package advent.of.code.day06
import java.io.File
import kotlin.math.abs
data class Point(val x: Int, val y: Int) {
fun distance(b: Point) = abs(x - b.x) + abs(y - b.y)
}
val input: List<Point> = File("day06.txt").readLines().map {
val parts = it.split(",")
Point(parts[0].trim().toInt(), parts[1].trim().toInt())
}
fun part1(): Int {
val topLeftBig = Point(
input.map { it.x }.min()!! - 10,
input.map { it.y }.min()!! - 10
)
val topLeft = Point(
input.map { it.x }.min()!!,
input.map { it.y }.min()!!
)
val bottomRightBig = Point(
input.map { it.x }.max()!! + 10,
input.map { it.y }.max()!! + 10
)
val bottomRight = Point(
input.map { it.x }.max()!!,
input.map { it.y }.max()!!
)
val areas = mutableMapOf<Point, Int>()
for (x in (topLeft.x..bottomRight.x))
for (y in (topLeft.y..bottomRight.y)) {
val current = Point(x, y)
val distances = input.sortedBy { current.distance(it) }.map { Pair(it, it.distance(current)) }
if (distances[0].second != distances[1].second)
areas.compute(distances[0].first) { _, a -> (a ?: 0) + 1 }
}
val areasBig = mutableMapOf<Point, Int>()
for (x in (topLeftBig.x..bottomRightBig.x))
for (y in (topLeftBig.y..bottomRightBig.y)) {
val current = Point(x, y)
val distances = input.sortedBy { current.distance(it) }.map { Pair(it, it.distance(current)) }
if (distances[0].second != distances[1].second)
areasBig.compute(distances[0].first) { _, a -> (a ?: 0) + 1 }
}
return areas.filter { areasBig[it.key] == it.value }.values.max()!!
}
fun part2(): Int {
val topLeft = Point(
input.map { it.x }.min()!!,
input.map { it.y }.min()!!
)
val bottomRight = Point(
input.map { it.x }.max()!!,
input.map { it.y }.max()!!
)
var area = 0
for (x in (topLeft.x..bottomRight.x))
for (y in (topLeft.y..bottomRight.y)) {
val current = Point(x, y)
val allDists = input.map { it.distance(current) }.sum()
if (allDists <= 10000)
area++
}
return area
}
| 0 | Kotlin | 0 | 0 | 0cb6814b91038a1ab99c276a33bf248157a88939 | 2,267 | advent_of_code_2018 | The Unlicense |
src/Day08.kt | aneroid | 572,802,061 | false | {"Kotlin": 27313} | class Day08(private val input: List<String>) {
private val forest = parseInput(input)
private fun isVisible(x: Int, y: Int, height: Int): Boolean =
requiredIndices(x, y)
.any { pairs ->
pairs.all { (cx, cy) -> forest[cy][cx] < height }
}
private fun scenicScore(x: Int, y: Int, height: Int): Int =
requiredIndices(x, y)
.map { pairs ->
val treesInPath = pairs.map { (cx, cy) -> forest[cy][cx] }
val shorter = treesInPath.takeWhile { it < height }
shorter.size + if (shorter.size < treesInPath.size) 1 else 0
}.reduce { acc, i -> acc * i }
private fun requiredIndices(x: Int, y: Int): Sequence<List<Pair<Int, Int>>> {
return sequenceOf(
(0 until x).reversed().map { it to y },
(x + 1 until forest[0].size).map { it to y },
(0 until y).reversed().map { x to it },
(y + 1 until forest.size).map { x to it },
)
}
private fun treesVisibleAtEdge(): Int =
forest.size * 2 + forest[0].size * 2 - 4
private fun isAtEdge(x: Int, y: Int) =
x == 0 || y == 0 || x == forest[0].indices.last || y == forest.indices.last
fun partOne(): Int =
treesVisibleAtEdge() + forest.flatMapIndexed { y: Int, rows: List<Int> ->
rows.mapIndexed { x: Int, height: Int ->
!isAtEdge(x, y) && isVisible(x, y, height)
}
}.count { it }
fun partTwo(): Int =
forest.flatMapIndexed { y: Int, rows: List<Int> ->
rows.mapIndexed { x: Int, height: Int ->
if (isAtEdge(x, y)) 0 else scenicScore(x, y, height)
}
}.max()
private companion object {
fun parseInput(input: List<String>) = input
.map { line -> line.map { char -> char.toString().toInt() } }
}
}
fun main() {
val testInput = readInput("Day08_test")
val input = readInput("Day08")
println("part One:")
assertThat(Day08(testInput).partOne()).isEqualTo(21)
println("actual: ${Day08(input).partOne()}\n")
println("part Two:")
// uncomment when ready
assertThat(Day08(testInput).partTwo()).isEqualTo(8)
println("actual: ${Day08(input).partTwo()}\n")
}
| 0 | Kotlin | 0 | 0 | cf4b2d8903e2fd5a4585d7dabbc379776c3b5fbd | 2,341 | advent-of-code-2022-kotlin | Apache License 2.0 |
src/Day12.kt | Excape | 572,551,865 | false | {"Kotlin": 36421} | import util.UnweightedGraph
fun main() {
val directions = listOf(Pair(1, 0), Pair(-1, 0), Pair(0, 1), Pair(0, -1))
fun inBounds(input: List<String>, p: Point) =
p.x >= 0 && p.y >= 0 && p.y <= input.lastIndex && p.x <= input[p.y].lastIndex
fun getElevation(input: List<String>, point: Point): Char {
return when (val elevation = input[point.y][point.x]) {
'S' -> 'a'
'E' -> 'z'
else -> elevation
}
}
fun parseGraph(input: List<String>): UnweightedGraph<Point> {
val vertices = input.indices.flatMap { y ->
input[y].indices.map { x -> Point(x, y) }
}
val edges = vertices.associateWith { v ->
val elevation = getElevation(input, v)
directions
.map { Point(v.x + it.first, v.y + it.second) }
.filter { inBounds(input, it) }
.filter { getElevation(input, it) <= elevation.inc() }.toSet()
}
return UnweightedGraph(vertices, edges)
}
fun getStartPoint(graph: UnweightedGraph<Point>, input: List<String>) =
graph.vertices.find { p -> input[p.y][p.x] == 'S' } ?: throw IllegalStateException("start point not found")
fun getEndPoint(graph: UnweightedGraph<Point>, input: List<String>) =
graph.vertices.find { p -> input[p.y][p.x] == 'E' } ?: throw IllegalStateException("end point not found")
fun part1(input: List<String>): Int {
val graph = parseGraph(input)
val startPoint = getStartPoint(graph, input)
val endPoint = getEndPoint(graph, input)
return graph.findShortestPathLength(startPoint, endPoint)
?: throw IllegalStateException("no shortest path found")
}
fun part2(input: List<String>): Int {
val graph = parseGraph(input)
val endPoint = getEndPoint(graph, input)
val startPoints = graph.vertices.filter { getElevation(input, it) == 'a' }
return startPoints.mapNotNull { startPoint -> graph.findShortestPathLength(startPoint, endPoint) }.min()
}
val testInput = readInput("Day12_test")
check(part1(testInput) == 31)
check(part2(testInput) == 29)
val input = readInput("Day12")
val part1Answer = part1(input)
val part2Answer = part2(input)
println("part 1: $part1Answer")
println("part 2: $part2Answer")
}
| 0 | Kotlin | 0 | 0 | a9d7fa1e463306ad9ea211f9c037c6637c168e2f | 2,376 | advent-of-code-2022 | Apache License 2.0 |
src/Day13.kt | EdoFanuel | 575,561,680 | false | {"Kotlin": 80963} | import utils.Tree
import java.util.Stack
import kotlin.math.min
import kotlin.math.sign
fun buildTree(input: String): Tree<Int> {
val stack = Stack<Tree<Int>>()
val root = Tree<Int>()
var currentValue = 0
var hasValue = false
var currentNode = root
for (c in input) {
when (c) {
'[' -> {
stack.push(currentNode)
currentNode = Tree() // first children
}
']' -> {
currentNode.value = if (hasValue) currentValue else null
stack.peek().children += currentNode
currentNode = stack.pop() // go back to parent
currentValue = 0
hasValue = false
}
',' -> {
currentNode.value = if (hasValue) currentValue else null
stack.peek().children += currentNode
currentNode = Tree() // next children
currentValue = 0
hasValue = false
}
in '0'..'9' -> {
currentValue = currentValue * 10 + c.digitToInt()
hasValue = true
}
}
}
return root
}
fun compare(a: Tree<Int>, b: Tree<Int>): Int {
if (a.isLeaf() && a.hasValue() && b.isLeaf() && b.hasValue()) return (a.value!! - b.value!!).sign
val childrenA = if (a.isLeaf() && a.hasValue()) mutableListOf(Tree(a.value)) else a.children
val childrenB = if (b.isLeaf() && b.hasValue()) mutableListOf(Tree(b.value)) else b.children
for(i in 0 until min(childrenA.size, childrenB.size)) {
when (compare(childrenA[i], childrenB[i])) {
-1 -> return -1
1 -> return 1
0 -> {} //do nothing
}
}
return (childrenA.size - childrenB.size).sign
}
fun main() {
fun part1(input: List<String>): Int {
var result = 0
var counter = 1
for (i in input.indices step 3) {
val leftTree = buildTree(input[i])
val rightTree = buildTree(input[i + 1])
val sign = compare(leftTree, rightTree)
if (sign <= 0) {
result += counter
}
counter++
}
return result
}
fun part2(input: List<String>): Int {
val decoders = arrayOf(
Tree<Int>(),
Tree()
)
decoders[0].children += Tree(2)
decoders[1].children += Tree(6)
val trees = mutableListOf(*decoders)
for (line in input) {
if (line.isEmpty()) continue
trees += buildTree(line)
}
trees.sortWith { a, b -> compare(a, b) }
return decoders.map { trees.indexOf(it) + 1 }.reduce { acc, i -> acc * i }
}
val test = readInput("Day13_test")
println(part1(test))
println(part2(test))
val input = readInput("Day13")
println(part1(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 46a776181e5c9ade0b5e88aa3c918f29b1659b4c | 2,941 | Advent-Of-Code-2022 | Apache License 2.0 |
src/aoc2018/kot/Day18.kt | Tandrial | 47,354,790 | false | null | package aoc2018.kot
import java.io.File
object Day18 {
fun partOne(input: List<String>): Int {
var grid = parse(input)
repeat(10) {
grid = nextGeneration(grid)
}
return grid.sumBy { it.count { it == '|' } } * grid.sumBy { it.count { it == '#' } }
}
fun partTwo(input: List<String>): Int {
var current = parse(input)
val old = mutableListOf(current)
repeat(1000000000) {
current = nextGeneration(current)
val find = old.withIndex().filter { (_, arr) -> arr contentDeepEquals current }
if (find.isNotEmpty()) {
val idxCycle = (1000000000 - it) % (old.size - find.first().index)
current = old[idxCycle + find.first().index - 1]
return current.sumBy { it.count { it == '|' } } * current.sumBy { it.count { it == '#' } }
}
old.add(current)
}
return current.sumBy { it.count { it == '|' } } * current.sumBy { it.count { it == '#' } }
}
private fun parse(input: List<String>) = input.map { it.toCharArray() }.toTypedArray()
private fun nextGeneration(current: Array<CharArray>): Array<CharArray> {
val next = Array(current.size) { CharArray(current[0].size) }
current.forEachIndexed { y, line ->
line.forEachIndexed { x, c ->
val surroudings = countNeighbours(x, y, current)
next[y][x] = when (c) {
'.' -> if (surroudings['|']!! >= 3) '|' else c
'|' -> if (surroudings['#']!! >= 3) '#' else c
'#' -> if (surroudings['#']!! >= 1 && surroudings['|']!! >= 1) '#' else '.'
else -> c
}
}
}
return next
}
private fun countNeighbours(x: Int, y: Int, grid: Array<CharArray>): MutableMap<Char, Int> {
val counts = mutableMapOf('.' to 0, '|' to 0, '#' to 0)
for (currX in (x - 1..x + 1)) {
for (currY in (y - 1..y + 1)) {
if (currX != x || currY != y) {
if (currX in (0 until grid[0].size) && currY in (0 until grid.size))
counts.replace(grid[currY][currX], counts[grid[currY][currX]]!! + 1)
}
}
}
return counts
}
}
fun main(args: Array<String>) {
val input = File("./input/2018/Day18_input.txt").readLines()
println("Part One = ${Day18.partOne(input)}")
println("Part Two = ${Day18.partTwo(input)}")
}
| 0 | Kotlin | 1 | 1 | 9294b2cbbb13944d586449f6a20d49f03391991e | 2,272 | Advent_of_Code | MIT License |
src/Day08.kt | paulbonugli | 574,065,510 | false | {"Kotlin": 13681} | class Forest(private val trees : List<List<Int>>) {
private val maxX : Int = trees.first().size-1
private val maxY : Int = trees.size-1
private fun getSurroundings(x : Int, y : Int) : Array<List<Int>> {
val left = trees[y].slice(0 until x).reversed()
val right = trees[y].slice((x + 1)..maxX)
val up = trees.map { it[x] }.slice(0 until y).reversed()
val below = trees.map { it[x] }.slice((y+1) .. maxY)
return arrayOf(left,right,up,below)
}
private fun isPositionVisible(x : Int, y : Int) : Boolean {
val tree = trees[y][x]
return getSurroundings(x,y).any{ direction -> direction.all { it < tree }}
}
private fun getScenicScore(x : Int, y : Int) : Int {
val tree = trees[y][x]
return getSurroundings(x, y)
.map { direction -> direction.takeWhileInclusive { it < tree }.count() }
.reduce { multiple, item -> multiple * item }
}
fun getMostScenicScore() : Int {
return allPositions().map { (x,y) -> getScenicScore(x, y) }.max()
}
private fun allPositions() : List<Pair<Int,Int>> {
return (0..maxY).flatMap { y ->
(0..maxX).map { x -> x to y }
}
}
fun countVisible() : Int {
return allPositions().map { (x,y) -> isPositionVisible(x, y)}.count { (it) }
}
fun printVisible() {
print((0..maxY).joinToString("") { y ->
(0..maxX).map { x -> isPositionVisible(x, y) }.joinToString("") { if (it) "🎄" else "🟦" } + "\n"
})
}
}
fun main() {
val input = readInput("Day08").map {
it.toList().map(Char::digitToInt)
}
val forest = Forest(input)
println()
forest.printVisible()
println("${forest.countVisible()} trees visible \uD83C\uDF84")
println("Most scenic score: ${forest.getMostScenicScore()}")
}
fun <T> Iterable<T>.takeWhileInclusive(predicate: (T) -> Boolean): List<T> {
val list = ArrayList<T>()
for (item in this) {
list.add(item)
// moved below list.add vs. takeWhile implementation
if (!predicate(item))
break
}
return list
}
| 0 | Kotlin | 0 | 0 | d2d7952c75001632da6fd95b8463a1d8e5c34880 | 2,162 | aoc-2022-kotlin | Apache License 2.0 |
advent-of-code-2022/src/Day15.kt | osipxd | 572,825,805 | false | {"Kotlin": 141640, "Shell": 4083, "Scala": 693} | import kotlin.math.abs
fun main() {
val testInput = readInput("Day15_test")
val input = readInput("Day15")
"Part 1" {
part1(testInput, targetY = 10) shouldBe 26
answer(part1(input, targetY = 2_000_000))
}
"Part 2" {
part2(testInput, max = 20) shouldBe 56000011
answer(part2(input, max = 4_000_000))
}
}
private fun part1(input: List<List<Int>>, targetY: Int): Int {
val notABeacon = mutableListOf<IntRange>()
val beacons = mutableSetOf<Int>()
for ((sensorX, sensorY, beaconX, beaconY) in input) {
val beaconDistance = abs(beaconX - sensorX) + abs((beaconY - sensorY))
val targetDistance = abs(sensorY - targetY)
if (beaconY == targetY) beacons += beaconX
if (targetDistance < beaconDistance) {
val diff = beaconDistance - targetDistance
notABeacon += (sensorX - diff)..(sensorX + diff)
}
}
return notABeacon.flatten().distinct().filterNot { it in beacons }.count()
}
private const val TUNING_X = 4_000_000L
private fun part2(input: List<List<Int>>, max: Int): Long {
fun checkSolution(x: Int, y: Int): Boolean {
if (x !in 0..max || y !in 0..max) return false
return input.all { (sensorX, sensorY, beaconX, beaconY) ->
val beaconDistance = abs(beaconX - sensorX) + abs(beaconY - sensorY)
val pointDistance = abs(x - sensorX) + abs(y - sensorY)
pointDistance > beaconDistance
}
}
var counter = 0
for ((sensorX, sensorY, beaconX, beaconY) in input) {
println(counter++)
val targetDistance = abs(beaconX - sensorX) + abs(beaconY - sensorY) + 1
for (yDiff in 0..targetDistance) {
val xDiff = targetDistance - yDiff
if (checkSolution(sensorX + xDiff, sensorY + yDiff)) return (sensorX + xDiff) * TUNING_X + (sensorY + yDiff)
if (checkSolution(sensorX - xDiff, sensorY + yDiff)) return (sensorX - xDiff) * TUNING_X + (sensorY + yDiff)
if (checkSolution(sensorX + xDiff, sensorY - yDiff)) return (sensorX + xDiff) * TUNING_X + (sensorY - yDiff)
if (checkSolution(sensorX - xDiff, sensorY - yDiff)) return (sensorX - xDiff) * TUNING_X + (sensorY - yDiff)
}
}
error("There no answer?")
}
private fun readInput(name: String) = readLines(name).map { line ->
line.replace(Regex("[^\\d-]+"), " ").trim().splitInts(" ")
}
| 0 | Kotlin | 0 | 5 | 6a67946122abb759fddf33dae408db662213a072 | 2,440 | advent-of-code | Apache License 2.0 |
src/year2023/day05/Day.kt | tiagoabrito | 573,609,974 | false | {"Kotlin": 73752} | package year2023.day05
import java.util.stream.LongStream
import year2023.solveIt
fun main() {
val day = "05"
val expectedTest1 = 35L
val expectedTest2 = 46L
fun part1(input: List<String>): Long {
val map = input.joinToString("\n").split("\n\n").map { it.split("\n") }
val seeds = Regex("\\d+").findAll(map[0][0]).map { it.value.toLong() }
val map1 = map.stream().skip(1).map {
it.stream().skip(1).map { line ->
val (dest, src, sz) = line.split(" ").map { it.toLong() }
LongRange(src,src + sz-1) to dest-src
}.toList()
}.toList()
val map2 = seeds.map { seed -> map1.fold(seed) { curr,
m -> curr + (m.firstOrNull { it.first.contains(curr) }?.second?:0)
}
}.toList()
return map2.min()
}
fun part2(input: List<String>): Long {
val items = input.joinToString("\n").split("\n\n").map { it.split("\n") }
val seeds = Regex("\\d+").findAll(items[0][0]).map { it.value.toLong() }.chunked(2).sortedBy { it[0] }.map { LongStream.range(it[0], it[0] + it[1] - 1) }
val ranges = items.drop(1).map {
it.drop(1).map { line ->
val (dest, src, sz) = line.split(" ").map { it.toLong() }
LongRange(src, src + sz - 1) to dest - src
}.sortedBy { it.first.first }.toList()
}.toList()
val map2 = Regex("\\d+").findAll(items[0][0]).map { it.value.toLong() }.chunked(2).sortedBy { it[0] }
.mapNotNull { LongStream.range(it[0], it[0] + it[1] - 1).parallel().map { seed -> ranges.fold(seed) { curr, range -> curr + (range.firstOrNull { it.first.contains(curr) }?.second ?: 0) } }.min() }.map{it.asLong }.min()
return map2
}
solveIt(day, ::part1, expectedTest1, ::part2, expectedTest2)
}
| 0 | Kotlin | 0 | 0 | 1f9becde3cbf5dcb345659a23cf9ff52718bbaf9 | 1,902 | adventOfCode | Apache License 2.0 |
src/day02/Day02.kt | martinhrvn | 724,678,473 | false | {"Kotlin": 27307, "Jupyter Notebook": 1336} | package day02
import kotlin.math.max
import println
import readInput
data class Colors(val red: Int, val green: Int, val blue: Int) {
fun product(): Int {
return red * green * blue
}
}
data class Game(val id: Int, val rounds: List<Colors>)
val limit = Colors(12, 13, 14)
class CubeConundrum(val input: List<String>) {
fun part1(): Int {
return input
.map(::readGame)
.filter { game ->
game.rounds.all { round ->
limit.red >= round.red && limit.blue >= round.blue && limit.green >= round.green
}
}
.sumOf { it.id }
}
fun part2(): Int {
return input.sumOf { row ->
val game = readGame(row)
game.rounds
.fold(Colors(0, 0, 0)) { acc, round ->
Colors(max(acc.red, round.red), max(acc.green, round.green), max(acc.blue, round.blue))
}
.product()
}
}
private fun readGame(row: String): Game {
val (gameLabel, rounds) = row.split(": ", limit = 2)
val gameId = gameLabel.replace("Game ", "").toInt()
val gameRounds =
rounds.split(";").map { round ->
val rs =
round
.trim()
.split(", ")
.map { cube ->
val (num, color) = cube.split(" ")
color to num.toInt()
}
.groupBy { it.first }
.mapValues { (_, nums) -> nums.sumOf { it.second } }
Colors(rs.getOrDefault("red", 0), rs.getOrDefault("green", 0), rs.getOrDefault("blue", 0))
}
return Game(gameId, gameRounds)
}
}
fun main() {
val testInput = readInput("day02/Day02_test")
check(CubeConundrum(testInput).part1() == 8)
check(CubeConundrum(testInput).part2() == 2286)
val cube = CubeConundrum(readInput("day02/Day02"))
cube.part1().println()
cube.part2().println()
}
| 0 | Kotlin | 0 | 0 | 59119fba430700e7e2f8379a7f8ecd3d6a975ab8 | 1,890 | advent-of-code-2023-kotlin | Apache License 2.0 |
src/Day16.kt | timhillgit | 572,354,733 | false | {"Kotlin": 69577} | import java.util.PriorityQueue
interface Graph<T> {
fun neighbors(node: T): List<Pair<Int, T>>
}
interface FiniteGraph<V> : Graph<V> {
val nodes: Set<V>
}
fun <T> dijkstra(
graph: Graph<T>,
start: Collection<T>,
goal: (T) -> Boolean,
): Pair<Int, List<T>>? {
val visited = mutableSetOf<T>()
val frontier = PriorityQueue<Pair<Int, List<T>>>(start.size) { a, b ->
compareValuesBy(a, b) { it.first }
}
frontier.addAll(start.map { 0 to listOf(it) })
while(frontier.isNotEmpty()) {
val (cost, path) = frontier.remove()
val next = path.last()
if (goal(next)) {
return cost to path
}
if (!visited.add(next)) {
continue
}
graph.neighbors(next).forEach { (edgeCost, neighbor) ->
val newCost = cost + edgeCost
val newPath = path + neighbor
frontier.add(newCost to newPath)
}
}
return null
}
class MapGraph<T>(private val map: Map<T, List<Pair<Int, T>>>) : FiniteGraph<T> {
override val nodes = map.keys
override fun neighbors(node: T): List<Pair<Int, T>> = map[node] ?: emptyList()
}
fun <T> floydWarshall(graph: FiniteGraph<T>): FiniteGraph<T>? {
val nodes = graph.nodes.toList()
val nodeIndices = nodes.withIndex().associate { it.value to it.index }
val distances = Array(nodes.size) { from ->
IntArray(nodes.size) { to ->
if (from == to) {
0
} else {
Int.MAX_VALUE
}
}
}
nodes.forEachIndexed { index, node ->
graph.neighbors(node).forEach { (cost, neighbor) ->
val neighborIndex = nodeIndices.getValue(neighbor)
distances[index][neighborIndex] = minOf(distances[index][neighborIndex], cost)
}
}
for (k in nodes.indices) {
for (i in nodes.indices) {
for (j in nodes.indices) {
if (distances[i][k] == Int.MAX_VALUE || distances[k][j] == Int.MAX_VALUE) {
continue
}
val cost = distances[i][k] + distances[k][j]
if (i == j && cost < 0) {
// Negative cycle detected
return null
}
distances[i][j] = minOf(distances[i][j], cost)
}
}
}
val nodeMap = distances.withIndex().associate {
val node = nodes[it.index]
val edges = it.value
.mapIndexed { index, cost -> cost to nodes[index] }
.filter { edge -> edge.first < Int.MAX_VALUE }
node to edges
}
return MapGraph(nodeMap)
}
data class Valve(val name: String, val flow: Int) {
val isUseful = flow > 0
}
data class CaveNode(val location: Valve, val minute: Int, val openValves: Set<Valve>) {
val flow = openValves.sumOf(Valve::flow)
}
class CaveGraph(val tunnels: FiniteGraph<Valve>) : Graph<CaveNode> {
private val maxFlow = tunnels.nodes.sumOf(Valve::flow)
override fun neighbors(node: CaveNode): List<Pair<Int, CaveNode>> {
if (node.minute >= TIME_LIMIT) {
return emptyList()
}
val adjustedFlow = maxFlow - node.flow
val remainingTime = TIME_LIMIT - node.minute
return buildList {
tunnels.neighbors(node.location)
.forEach { (travelTime, valve) ->
val totalTime = travelTime + 1
if (valve.isUseful && valve !in node.openValves && totalTime < remainingTime) {
val neighbor = CaveNode(valve, node.minute + totalTime, node.openValves + valve)
add(totalTime * adjustedFlow to neighbor)
}
}
}.takeUnless { it.isEmpty() } ?: listOf(remainingTime * adjustedFlow to node.copy(minute = TIME_LIMIT))
}
fun convertCost(cost: Int) = TIME_LIMIT * maxFlow - cost
companion object {
const val TIME_LIMIT = 30
}
}
data class Destination(val valve: Valve, val travelTime: Int)
data class ElephantNode(
val human: Destination,
val elephant: Destination,
val minute: Int,
val openValves: Set<Valve>
)
class ElephantGraph(val tunnels: FiniteGraph<Valve>) : Graph<ElephantNode> {
private val maxFlow = tunnels.nodes.sumOf(Valve::flow)
override fun neighbors(node: ElephantNode): List<Pair<Int, ElephantNode>> {
if (node.minute >= TIME_LIMIT) {
return emptyList()
}
val remainingTime = TIME_LIMIT - node.minute
return if (node.human.travelTime == 0) {
val openValves = node.openValves + node.human.valve
val adjustedFlow = maxFlow - openValves.sumOf(Valve::flow)
buildList {
tunnels.neighbors(node.human.valve)
.forEach { (travelTime, valve) ->
val totalTime = travelTime + 1
if (valve.isUseful && valve !in openValves && totalTime < remainingTime) {
add(Destination(valve, totalTime))
}
}
if (size < 2) {
add(Destination(node.human.valve, remainingTime))
}
}.map { destination ->
adjustedFlow * node.elephant.travelTime to
ElephantNode(
human = Destination(destination.valve, destination.travelTime - node.elephant.travelTime),
elephant = Destination(node.elephant.valve, 0),
minute = node.minute + node.elephant.travelTime,
openValves = openValves,
)
}
} else {
val openValves = node.openValves + node.elephant.valve
val adjustedFlow = maxFlow - openValves.sumOf(Valve::flow)
buildList {
tunnels.neighbors(node.elephant.valve)
.forEach { (travelTime, valve) ->
val totalTime = travelTime + 1
if (valve.isUseful && valve !in openValves && totalTime < remainingTime) {
add(Destination(valve, totalTime))
}
}
if (size < 2) {
add(Destination(node.elephant.valve, remainingTime))
}
}.map { destination ->
adjustedFlow * node.human.travelTime to
ElephantNode(
human = Destination(node.human.valve, 0),
elephant = Destination(destination.valve, destination.travelTime - node.human.travelTime),
minute = node.minute + node.human.travelTime,
openValves = openValves,
)
}
}
}
fun convertCost(cost: Int) = TIME_LIMIT * maxFlow - cost
companion object {
const val TIME_LIMIT = 26
}
}
fun main() {
val regex = Regex("""Valve ([A-Z]{2}) has flow rate=(\d+); tunnels? leads? to valves? ([A-Z]{2}(?:, [A-Z]{2})*)""")
val input = readInput("Day16")
.associate { line ->
val (name, flow, tunnels) = regex.matchEntire(line)!!.destructured
val valve = Valve(name, flow.toInt())
name to (valve to tunnels.split(", "))
}
var tunnels: FiniteGraph<Valve> = MapGraph(input.values.associate { (valve, names) ->
valve to names.mapNotNull { name -> input[name]?.let { 1 to it.first } }
})
tunnels = floydWarshall(tunnels)!!
val cave = CaveGraph(tunnels)
val start = listOf(CaveNode(input["AA"]!!.first, 0, setOf()))
dijkstra(cave, start) { it.minute == CaveGraph.TIME_LIMIT }?.let { (cost, _) ->
println(cave.convertCost(cost))
}
val elephantCave = ElephantGraph(tunnels)
val elephantStart = listOf(ElephantNode(
human = Destination(input["AA"]!!.first, 0),
elephant = Destination(input["AA"]!!.first, 0),
minute = 0,
openValves = emptySet(),
))
dijkstra(elephantCave, elephantStart) { it.minute == ElephantGraph.TIME_LIMIT }?.let { (cost, _) ->
println(elephantCave.convertCost(cost))
}
}
| 0 | Kotlin | 0 | 1 | 76c6e8dc7b206fb8bc07d8b85ff18606f5232039 | 8,317 | advent-of-code-2022 | Apache License 2.0 |
src/day16/Day16.kt | ayukatawago | 572,742,437 | false | {"Kotlin": 58880} | package day16
import readInput
import kotlin.math.max
fun main() {
val testInput = readInput("day16/test")
val regex = """Valve ([A-Z]+) has flow rate=(\d+); tunnels* leads* to valves* ([A-Z\s,]+)""".toRegex()
val valveDataMap = HashMap<String, Valve>()
testInput.forEach {
val result = regex.matchEntire(it) ?: return@forEach
val name = result.groupValues[1]
val flowRate = result.groupValues[2].toInt()
val valves = result.groupValues[3].split(", ").toSet()
valveDataMap.put(name, Valve(flowRate, valves))
}
println(part1(valveDataMap))
println(part2(valveDataMap))
}
private fun part1(valveMap: Map<String, Valve>): Int {
val totalTime = 30
val dp = Array(totalTime + 1) { hashMapOf<Status, Int>() }
updateDp(dp, 0, Status("AA", emptySet()), 0)
(0 until totalTime).forEach { time ->
dp[time].forEach { (status, pressure) ->
val valve = valveMap[status.valveName]!!
if (valve.flowRate > 0 && status.valveName !in status.openedValves) {
val newStatus = Status(status.valveName, status.openedValves + status.valveName)
updateDp(dp, time + 1, newStatus, pressure + (totalTime - time - 1) * valve.flowRate)
}
valve.leadsTo.forEach {
val newStatus = Status(it, status.openedValves)
updateDp(dp, time + 1, newStatus, pressure)
}
}
}
return dp[totalTime].values.max()
}
private fun part2(valveMap: Map<String, Valve>): Int {
val totalTime = 26
val dp = Array(totalTime + 1) { hashMapOf<Status, Int>() }
updateDp(dp, 0, Status("AA", emptySet()), 0)
(0 until totalTime).forEach { time ->
dp[time].forEach { (status, pressure) ->
val valve = valveMap[status.valveName]!!
if (valve.flowRate > 0 && status.valveName !in status.openedValves) {
val newStatus = Status(status.valveName, status.openedValves + status.valveName)
updateDp(dp, time + 1, newStatus, pressure + (totalTime - time - 1) * valve.flowRate)
}
valve.leadsTo.forEach {
val newStatus = Status(it, status.openedValves)
updateDp(dp, time + 1, newStatus, pressure)
}
}
}
val bm = dp[totalTime].toList().groupingBy { it.first.openedValves }.fold(0) { a, e -> maxOf(a, e.second) }
val effectiveValveSet = valveMap.filter { it.value.flowRate > 0 }.map { it.key }.toSet()
var maxPressure = 0
effectiveValveSet.toRepeatedCombination().forEach { elf ->
val elfPressure = bm[elf] ?: return@forEach
val remaining = effectiveValveSet.toSet() - elf
remaining.toRepeatedCombination().forEach {
val pressure = bm[it] ?: return@forEach
maxPressure = max(maxPressure, elfPressure + pressure)
}
}
return maxPressure
}
private fun Set<String>.toRepeatedCombination(): List<Set<String>> {
return if (size == 1) {
listOf(emptySet(), setOf(first()))
} else {
val remainingList = drop(1).toSet().toRepeatedCombination()
remainingList + remainingList.map { it + first() }
}
}
private fun updateDp(dp: Array<HashMap<Status, Int>>, time: Int, status: Status, pressure: Int) {
val currentPressure = dp[time][status]
if (currentPressure == null || pressure > currentPressure) {
dp[time][status] = pressure
}
}
private data class Valve(val flowRate: Int, val leadsTo: Set<String>)
private data class Status(val valveName: String, val openedValves: Set<String>) | 0 | Kotlin | 0 | 0 | 923f08f3de3cdd7baae3cb19b5e9cf3e46745b51 | 3,627 | advent-of-code-2022 | Apache License 2.0 |
src/Day12.kt | mikemac42 | 573,071,179 | false | {"Kotlin": 45264} | import java.io.File
fun main() {
val testInput = """Sabqponm
abcryxxl
accszExk
acctuvwj
abdefghi"""
val realInput = File("src/Day12.txt").readText()
val part1TestOutput = fewestSteps(testInput) { it == 'S' }
println("Part 1 Test Output: $part1TestOutput")
check(part1TestOutput == 31)
val part1RealOutput = fewestSteps(realInput) { it == 'S' }
println("Part 1 Real Output: $part1RealOutput")
val part2TestOutput = fewestSteps(testInput) { it == 'S' || it == 'a' }
println("Part 2 Test Output: $part2TestOutput")
check(part2TestOutput == 29)
val part2RealOutput = fewestSteps(realInput) { it == 'S' || it == 'a' }
println("Part 2 Real Output: $part2RealOutput")
}
/**
* The heightmap shows the local area from above broken into a grid.
* a is the lowest elevation
* z is the highest elevation
* S is the starting position at elevation a
* E is the ending position at elevation z
* During each step, you can move exactly one square up, down, left, or right.
* The elevation of the destination can be at most one higher than the current elevation.
*/
fun fewestSteps(input: String, isStartPos: (Char) -> Boolean): Int {
val hill = parseHill(input, isStartPos)
// Breadth First Search
val visited = hill.elevations.entries.associate { it.key to false }.toMutableMap()
val distances: MutableMap<Pos, Int?> = hill.elevations.entries.associate { it.key to null }.toMutableMap()
val queue = mutableListOf<Pos>()
hill.startPosList.forEach { startPos ->
visited[startPos] = true
distances[startPos] = 0
queue.add(startPos)
}
while (queue.isNotEmpty()) {
val pos = queue.removeFirst()
if (pos == hill.endPos) break
val elevation = hill.elevations[pos]!!
val distance = distances[pos]!!
listOf(
Pos(pos.x, pos.y - 1),
Pos(pos.x, pos.y + 1),
Pos(pos.x - 1, pos.y),
Pos(pos.x + 1, pos.y)
).filter { nextPos ->
0 <= nextPos.x && nextPos.x <= hill.maxPos.x &&
0 <= nextPos.y && nextPos.y <= hill.maxPos.y &&
hill.elevations[nextPos]!! <= elevation + 1 &&
visited[nextPos] == false
}.map { nextPos ->
visited[nextPos] = true
distances[nextPos] = distance + 1
queue.add(nextPos)
}
}
return distances[hill.endPos]!!
}
private fun parseHill(input: String, isStartPos: (Char) -> Boolean): Hill {
val startPosList = mutableListOf<Pos>()
var endPos = Pos(-1, -1)
val elevations = mutableMapOf<Pos, Int>()
input.lines().mapIndexed { i, line ->
line.mapIndexed { j, char ->
if (isStartPos(char)) startPosList.add(Pos(i, j))
if (char == 'E') endPos = Pos(i, j)
elevations[Pos(i, j)] = when (char) {
'S' -> 0
'E' -> 'z'.code - 'a'.code
else -> char.code - 'a'.code
}
}
}
return Hill(elevations, startPosList, endPos, elevations.keys.last())
}
private data class Hill(val elevations: Map<Pos, Int>, val startPosList: List<Pos>, val endPos: Pos, val maxPos: Pos)
private data class Pos(val x: Int, val y: Int)
| 0 | Kotlin | 1 | 0 | 909b245e4a0a440e1e45b4ecdc719c15f77719ab | 3,047 | advent-of-code-2022 | Apache License 2.0 |
src/Day08.kt | iProdigy | 572,297,795 | false | {"Kotlin": 33616} | import kotlin.math.max
fun main() {
fun part1(input: List<String>): Int {
val grid = input.map { it.toCharArray() }.map { chars -> chars.map { it.digitToInt() } }
val width = grid.first().size
val length = grid.size
val visible = Array(length) { BooleanArray(width) }
fun directionalRunningMax(
rowInterval: IntProgression = 0 until length,
colInterval: IntProgression = 0 until width,
rowOffset: Int = 0,
colOffset: Int = 0,
startingEdge: (Int, Int) -> Boolean
) = Array(length) { IntArray(width) }.apply {
for (row in rowInterval) {
for (col in colInterval) {
if (startingEdge(row, col)) {
visible[row][col] = true
this[row][col] = grid[row][col]
} else {
this[row][col] = max(this[row + rowOffset][col + colOffset], grid[row + rowOffset][col + colOffset])
}
}
}
}
val ltrMax = directionalRunningMax(colOffset = -1) { _, col -> col == 0 }
val rtlMax = directionalRunningMax(colInterval = width - 1 downTo 0, colOffset = 1) { _, col -> col + 1 == width }
val ttbMax = directionalRunningMax(rowOffset = -1) { row, _ -> row == 0 }
val bttMax = directionalRunningMax(rowInterval = length - 1 downTo 0, rowOffset = 1) { row, _ -> row + 1 == length }
val maxes = listOf(ltrMax, rtlMax, ttbMax, bttMax)
for (row in 1 until length - 1) {
for (col in 1 until width - 1) {
val height = grid[row][col]
val minMax = maxes.minOf { it[row][col] }
if (height > minMax)
visible[row][col] = true
}
}
return visible.sumOf { it.count { b -> b } }
}
fun part2(input: List<String>): Int {
val grid = input.map { it.toCharArray() }.map { chars -> chars.map { it.digitToInt() } }
val width = grid.first().size
val length = grid.size
var scenic = 0
for (row in 1 until length - 1) {
for (col in 1 until width - 1) {
val height = grid[row][col]
fun outwardCount(rowOffset: Int = 0, colOffset: Int = 0, range: IntProgression): Int {
var c = 1
if (height > grid[row + rowOffset][col + colOffset]) {
c += range.takeWhileAndOneMore {
grid[if (rowOffset != 0) it else row][if (rowOffset != 0) col else it] < height
}.count()
}
return c
}
val top = outwardCount(-1, 0, row - 2 downTo 0)
val left = outwardCount(0, -1, col - 2 downTo 0)
val right = outwardCount(0, 1, col + 2 until width)
val bottom = outwardCount(1, 0, row + 2 until length)
scenic = max(scenic, top * left * right * bottom)
}
}
return scenic
}
// test if implementation meets criteria from the description, like:
val testInput = readInput("Day08_test")
check(part1(testInput) == 21)
check(part2(testInput) == 8)
val input = readInput("Day08")
println(part1(input)) // 1859
println(part2(input)) // 332640
}
| 0 | Kotlin | 0 | 1 | 784fc926735fc01f4cf18d2ec105956c50a0d663 | 3,426 | advent-of-code-2022 | Apache License 2.0 |
src/aoc2022/Day15.kt | NoMoor | 571,730,615 | false | {"Kotlin": 101800} | package aoc2022
import utils.*
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
private class Day15(val lines: List<String>) {
val sensors = lines.map { it.removePrefix("Sensor at ").allInts() }
.map { Sensor(Coord.xy(it[0], it[1]), Coord.xy(it[2], it[3])) }
.toList()
data class Sensor(val sensorLoc: Coord, val beaconLoc: Coord) {
fun range() : Int {
return abs(sensorLoc.x - beaconLoc.x) + abs(sensorLoc.y - beaconLoc.y)
}
}
fun part1(targetY: Int): Long {
val coveredRanges = coveredRanges(targetY)
val invalidLocations = coveredRanges.flatMap { it }.distinct().debug()
val beacons = sensors.map { it.beaconLoc }.filter { it.y == targetY }.distinct()
return invalidLocations.size - beacons.size.toLong()
}
fun part2(dimension: Int): Long {
for (y in 0..dimension) {
val x = findOpenSpot(y)
if (x != -1L) {
println("Found it! $x $y")
println("Answer: ${x * 4_000_000 + y}")
return x * 4_000_000 + y
}
}
throw RuntimeException("Solution not found")
}
/** Finds the open x value in the target y row or returns -1 to indicate that there is no opening. */
private fun findOpenSpot(y: Int): Long {
val coveredRanges = coveredRanges(y).sortedBy { it.first }.toList()
coveredRanges.reduce { a, b ->
if (a.overlaps(b) || a.last + 1 == b.first) {
return@reduce min(a.first, b.first)..max(a.last, b.last)
}
return a.last + 1.toLong()
}
return -1
}
/** Returns a list of ranges that are covered by sensors for the give row y. */
private fun coveredRanges(targetY: Int): List<IntRange> {
val notHereRanges = sensors.filter { s ->
abs(targetY - s.sensorLoc.y) <= s.range()
}.map { s ->
val dx = s.range() - abs(targetY - s.sensorLoc.y)
-dx + s.sensorLoc.x..dx + s.sensorLoc.x
}
return notHereRanges
}
}
fun main() {
val day = "15".toInt()
val todayTest = Day15(readInput(day, 2022, true))
execute({ todayTest.part1(10) }, "Day[Test] $day: pt 1", 26L)
val today = Day15(readInput(day, 2022))
// execute({ today.part1(2000000) }, "Day $day: pt 1")
execute({ todayTest.part2(20) }, "Day[Test] $day: pt 2", 56000011L)
execute({ today.part2(4_000_000) }, "Day $day: pt 2", 13615843289729) // 796961409
}
| 0 | Kotlin | 1 | 2 | d561db73c98d2d82e7e4bc6ef35b599f98b3e333 | 2,332 | aoc2022 | Apache License 2.0 |
src/Day04.kt | RichardLiba | 572,867,612 | false | {"Kotlin": 16347} | fun main() {
fun fullyContainsOther(a: Pair<Int, Int>, b: Pair<Int, Int>): Boolean {
return a.first <= b.first && a.second >= b.second
}
fun intersecting(a: Pair<Int, Int>, b: Pair<Int, Int>): Boolean {
return a.first <= b.second && b.first <= a.second
}
fun intersecting(a: Pair<String, String>, b: Pair<String, String>): Boolean {
return a.first.toInt() <= b.second.toInt() && b.first.toInt() <= a.second.toInt()
}
fun String.splitBy(char: Char): Pair<Int, Int> {
return Pair(this.substringBefore(char).toInt(), this.substringAfter(char).toInt())
}
fun splitLine(string: String): Pair<Pair<Int, Int>, Pair<Int, Int>> {
return Pair(string.substringBefore(',').splitBy('-'), string.substringAfter(',').splitBy('-'))
}
fun List<String>.intoPairs(): List<Pair<String, String>> {
return chunked(2).map { it[0] to it[1] }
}
fun splitLine2(string: String): Pair<Pair<String, String>, Pair<String, String>> {
return string.replace(",", "-").split("-").intoPairs().zipWithNext().first()
}
fun checkLine(string: String): Int {
val ranges = splitLine(string)
return if (fullyContainsOther(ranges.first, ranges.second) || fullyContainsOther(
ranges.second,
ranges.first
)
) 1 else 0
}
fun checkLine2(string: String): Int {
val ranges = splitLine(string)
return (if (intersecting(ranges.first, ranges.second) || intersecting(
ranges.second,
ranges.first
)
) 1 else 0)
}
fun checkLine2_2(string: String): Int {
val ranges = splitLine2(string)
return (if (intersecting(ranges.first, ranges.second) || intersecting(
ranges.second,
ranges.first
)
) 1 else 0)
}
fun part1(input: List<String>): Int {
return input.sumOf { checkLine(it) }
}
fun part2(input: List<String>): Int {
return input.sumOf { checkLine2(it) }
}
fun part2_2(input: List<String>): Int {
return input.sumOf { checkLine2_2(it) }
}
val input = readInput("Day04")
println(part1(input))
println(part2_2(input))
println(part2(input))
}
| 0 | Kotlin | 0 | 0 | 6a0b6b91b5fb25b8ae9309b8e819320ac70616ed | 2,306 | aoc-2022-in-kotlin | Apache License 2.0 |
src/day09/Day09.kt | maxmil | 578,287,889 | false | {"Kotlin": 32792} | package day09
import println
import readInput
import kotlin.system.measureTimeMillis
data class Position(val x: Int, val y: Int)
typealias Grid = List<List<Int>>
fun main() {
fun List<String>.parseGrid() = map { row -> row.map { it.toString().toInt() } }
fun Grid.withinBounds(it: Position) = it.x >= 0 && it.x < this[0].size && it.y >= 0 && it.y < this.size
fun Grid.adjacent(position: Position) = listOf(
position.copy(x = position.x - 1),
position.copy(x = position.x + 1),
position.copy(y = position.y - 1),
position.copy(y = position.y + 1),
).filter { withinBounds(it) }
fun Grid.isLowPoint(position: Position, value: Int): Boolean {
return !adjacent(position).any { this[it.y][it.x] <= value }
}
fun Grid.lowPoints() = flatMapIndexed { rowIndex, row ->
List(row.size) { colIndex -> Position(colIndex, rowIndex) }
.filter { position -> isLowPoint(position, this[position.y][position.x]) }
}
fun Grid.basinSize(position: Position, visited: MutableSet<Position>): Int {
if (visited.contains(position)) return 0
visited.add(position)
return adjacent(position)
.filter { this[it.y][it.x] != 9 }
.sumOf { [email protected](it, visited) } + 1
}
fun part1(grid: Grid) = grid.lowPoints().sumOf { grid[it.y][it.x] + 1 }
fun part2(grid: Grid): Int {
val visited = mutableSetOf<Position>()
return grid.lowPoints()
.map { grid.basinSize(it, visited) }
.sorted()
.takeLast(3)
.reduce { acc, size -> acc * size }
}
fun part2BFS(grid: Grid): Int {
return grid.lowPoints().map { lowPoint ->
var cnt = 0
val visited = mutableSetOf<Position>()
val toVisit = grid.adjacent(lowPoint).toMutableList()
while (toVisit.isNotEmpty()) {
val position = toVisit.removeFirst()
if (!visited.add(position) || grid[position.y][position.x] == 9) continue
cnt++;
toVisit.addAll(grid.adjacent(position))
}
cnt;
}.sorted()
.takeLast(3)
.reduce { acc, size -> acc * size }
}
val testGrid = readInput("day09/input_test").parseGrid()
check(part1(testGrid) == 15)
check(part2(testGrid) == 1134)
check(part2BFS(testGrid) == 1134)
val grid = readInput("day09/input").parseGrid()
part1(grid).println()
measureTimeMillis { print(part2(grid)) }.let { println(" in ${it}ms") }
measureTimeMillis { print(part2BFS(grid)) }.let { println(" in ${it}ms") }
}
| 0 | Kotlin | 0 | 0 | 246353788b1259ba11321d2b8079c044af2e211a | 2,677 | advent-of-code-2021 | Apache License 2.0 |
src/main/kotlin/com/github/ferinagy/adventOfCode/aoc2015/2015-15.kt | ferinagy | 432,170,488 | false | {"Kotlin": 787586} | package com.github.ferinagy.adventOfCode.aoc2015
import com.github.ferinagy.adventOfCode.println
import com.github.ferinagy.adventOfCode.readInputLines
fun main() {
val input = readInputLines(2015, "15-input")
val test1 = readInputLines(2015, "15-test1")
println("Part1:")
part1(test1).println()
part1(input).println()
println()
println("Part2:")
part2(test1).println()
part2(input).println()
}
private fun part1(input: List<String>): Long {
val ingredients = input.map { Ingredient.parse(it) }
val total = 100
val combinations = combinations(ingredients.size, total)
return combinations.maxOf { combo ->
val zip = combo.zip(ingredients)
val cap = zip.sumOf { (count, ingredient) -> count * ingredient.capacity }.coerceAtLeast(0)
val dur = zip.sumOf { (count, ingredient) -> count * ingredient.durability }.coerceAtLeast(0)
val fla = zip.sumOf { (count, ingredient) -> count * ingredient.flavor }.coerceAtLeast(0)
val tex = zip.sumOf { (count, ingredient) -> count * ingredient.texture }.coerceAtLeast(0)
cap.toLong() * dur * fla * tex
}
}
private fun part2(input: List<String>): Long {
val ingredients = input.map { Ingredient.parse(it) }
val total = 100
val targetCalories = 500
val combinations = combinations(ingredients.size, total)
return combinations.maxOf { combo ->
val zip = combo.zip(ingredients)
val cal = zip.sumOf { (count, ingredient) -> count * ingredient.calories }
if (cal != targetCalories) return@maxOf 0L
val cap = zip.sumOf { (count, ingredient) -> count * ingredient.capacity }.coerceAtLeast(0)
val dur = zip.sumOf { (count, ingredient) -> count * ingredient.durability }.coerceAtLeast(0)
val fla = zip.sumOf { (count, ingredient) -> count * ingredient.flavor }.coerceAtLeast(0)
val tex = zip.sumOf { (count, ingredient) -> count * ingredient.texture }.coerceAtLeast(0)
cap.toLong() * dur * fla * tex
}
}
private fun combinations(size: Int, total: Int): List<List<Int>> {
if (size == 1) return listOf(listOf(total))
val result = mutableListOf<List<Int>>()
for (i in 0..total) {
val subResult = combinations(size - 1, total - i)
subResult.forEach { combo ->
result += combo + i
}
}
return result
}
private data class Ingredient(
val name: String,
val capacity: Int,
val durability: Int,
val flavor: Int,
val texture: Int,
val calories: Int
) {
companion object {
fun parse(input: String): Ingredient {
val (name, cap, dur, fla, tex, cal) = regex.matchEntire(input)!!.destructured
return Ingredient(name, cap.toInt(), dur.toInt(), fla.toInt(), tex.toInt(), cal.toInt())
}
}
}
private val regex =
"""(\w+): capacity (-?\d+), durability (-?\d+), flavor (-?\d+), texture (-?\d+), calories (-?\d+)""".toRegex()
| 0 | Kotlin | 0 | 1 | f4890c25841c78784b308db0c814d88cf2de384b | 2,970 | advent-of-code | MIT License |
src/year2022/day11/Day11.kt | lukaslebo | 573,423,392 | false | {"Kotlin": 222221} | package year2022.day11
import check
import readInput
import java.util.LinkedList
fun main() {
// test if implementation meets criteria from the description, like:
val testInput = readInput("2022", "Day11_test")
check(part1(testInput), 10605)
check(part2(testInput), 2713310158L)
val input = readInput("2022", "Day11")
println(part1(input))
println(part2(input))
}
private fun part1(input: List<String>) = playMonkeyInTheMiddle(
monkeysById = parseMonkeysById(input),
rounds = 20,
divideWorryLevel = 3,
)
private fun part2(input: List<String>) = playMonkeyInTheMiddle(
monkeysById = parseMonkeysById(input),
rounds = 10000,
)
private fun playMonkeyInTheMiddle(monkeysById: Map<Int, Monkey>, rounds: Int, divideWorryLevel: Int = 1): Long {
val monkeys = monkeysById.values
val greatestCommonModFactor = monkeys.map { it.mod }.reduce { acc, n -> acc * n }
val monkeyBusiness = Array(monkeys.size) { 0L }
repeat(rounds) {
for (monkey in monkeys) {
while (monkey.items.isNotEmpty()) {
var itemWorryLevel = monkey.items.removeFirst()
itemWorryLevel = monkey.inspect(itemWorryLevel)
monkeyBusiness[monkey.id]++
if (divideWorryLevel > 1) {
itemWorryLevel /= divideWorryLevel
} else {
itemWorryLevel %= greatestCommonModFactor
}
val isDivisible = itemWorryLevel % monkey.mod == 0L
val nextMonkeyId = if (isDivisible) monkey.monkeyIdTrue else monkey.monkeyIdFalse
monkeysById[nextMonkeyId]!!.items.add(itemWorryLevel)
}
}
}
return monkeyBusiness.sorted().takeLast(2).let { it[0] * it[1] }
}
private fun parseMonkeysById(input: List<String>) = (input + "").chunked(7).map { lines ->
val id = lines[0][7].digitToInt()
val items = lines[1].substringAfter(':').split(',').mapTo(LinkedList()) { it.trim().toLong() }
val inspect: Inspect = lines[2].substringAfter("new = old ").let { line ->
val (operationString, numString) = line.split(' ')
val num = if (numString == "old") null else numString.toLong()
val operation: Long.(Long) -> Long = when (operationString) {
"*" -> Long::times
"+" -> Long::plus
else -> error("Operand $operationString not supported")
}
{ it.operation(num ?: it) }
}
val mod = lines[3].split(' ').last().toInt()
val monkeyIdTrue = lines[4].split(' ').last().toInt()
val monkeyIdFalse = lines[5].split(' ').last().toInt()
Monkey(id, items, inspect, mod, monkeyIdTrue, monkeyIdFalse)
}.associateBy { it.id }
typealias Inspect = (Long) -> Long
class Monkey(
val id: Int,
val items: LinkedList<Long>,
val inspect: Inspect,
val mod: Int,
val monkeyIdTrue: Int,
val monkeyIdFalse: Int,
)
| 0 | Kotlin | 0 | 1 | f3cc3e935bfb49b6e121713dd558e11824b9465b | 2,932 | AdventOfCode | Apache License 2.0 |
y2016/src/main/kotlin/adventofcode/y2016/Day10.kt | Ruud-Wiegers | 434,225,587 | false | {"Kotlin": 503769} | package adventofcode.y2016
import adventofcode.io.AdventSolution
object Day10 : AdventSolution(2016, 10, "Balance Bots") {
override fun solvePartOne(input: String): Int? {
val (chips, lowInstr, highInstr) = parse(input)
while (chips.values.any { it.size > 1 }) {
step(chips, lowInstr, highInstr)
chips.entries.find { it.value == listOf(17, 61) }
?.let { return it.key }
}
return null
}
override fun solvePartTwo(input: String): Int {
val (chips, lowInstr, highInstr) = parse(input)
while (chips.values.any { it.size > 1 })
step(chips, lowInstr, highInstr)
return (0..2)
.map { -it - 1 }
.map(chips::getValue)
.map(List<Int>::first)
.reduce(Int::times)
}
private fun step(chips: MutableMap<Int, List<Int>>, lowInstr: Map<Int, Int>, highInstr: Map<Int, Int>) {
chips
.filter { it.value.size > 1 }
.forEach { (bot, ch) ->
chips[bot] = emptyList()
val (lowChip, highChip) = ch
chips.merge(lowInstr.getValue(bot), listOf(lowChip)) { a, b -> (a + b).sorted() }
chips.merge(highInstr.getValue(bot), listOf(highChip)) { a, b -> (a + b).sorted() }
}
}
private fun parse(input: String): Triple<MutableMap<Int, List<Int>>, Map<Int, Int>, Map<Int, Int>> {
val lines = input.lineSequence()
val valuePattern = ("value (\\d+) goes to bot (\\d+)").toRegex()
val chips = lines
.mapNotNull { valuePattern.matchEntire(it) }
.groupBy({ it.groupValues[2].toInt() }, { it.groupValues[1].toInt() })
.mapValues { it.value.sorted() }
.toMutableMap()
val instructionPattern = ("bot (\\d+) gives low to (output|bot) (\\d+) and high to (output|bot) (\\d+)").toRegex()
val low = lines
.mapNotNull { instructionPattern.matchEntire(it)?.destructured }
.associate { (b0, t1, b1) -> b0.toInt() to if (t1 == "bot") b1.toInt() else -b1.toInt() - 1 }
val high = lines
.mapNotNull { instructionPattern.matchEntire(it)?.destructured }
.associate { (b0, _, _, t1, b1) -> b0.toInt() to if (t1 == "bot") b1.toInt() else -b1.toInt() - 1 }
return Triple(chips, low, high)
}
}
| 0 | Kotlin | 0 | 3 | fc35e6d5feeabdc18c86aba428abcf23d880c450 | 2,472 | advent-of-code | MIT License |
src/Day12.kt | sungi55 | 574,867,031 | false | {"Kotlin": 23985} | import java.util.*
fun main() {
val day = "Day12"
val testGraph: Graph = readInput(name = "${day}_test").asGraph()
val graph: Graph = readInput(name = "Day12").asGraph()
fun part1(graph: Graph): Int = graph.bfs(
start = graph.start,
isComplete = { it == graph.destination },
isNotBlocked = { from, to -> to - from <= 1 }
)
fun part2(graph: Graph): Int = graph.bfs(
start = graph.destination,
isComplete = { graph.elevations[it] == 0 },
isNotBlocked = { from, to -> from - to <= 1 }
)
check(part1(testGraph) == 31)
check(part2(testGraph) == 29)
println(part1(graph))
println(part2(graph))
}
data class Position(
val x: Int = 0, val y: Int = 0
) {
fun neighbors(): Set<Position> = setOf(
copy(x = x - 1), copy(x = x + 1), copy(y = y - 1), copy(y = y + 1)
)
}
data class Path(
val position: Position, val weight: Int
) : Comparable<Path> {
override fun compareTo(other: Path): Int = weight.compareTo(other.weight)
}
class Graph(
var start: Position,
var destination: Position,
var elevations: Map<Position, Int>,
) {
fun bfs(
start: Position,
isComplete: (Position) -> Boolean,
isNotBlocked: (Int, Int) -> Boolean
): Int {
val visitedPosition = mutableSetOf<Position>()
val queue = PriorityQueue<Path>().apply { add(Path(start, 0)) }
while (queue.isNotEmpty()) {
val nextPath = queue.poll()
nextPath.position
.takeIf { it !in visitedPosition }
?.also { visitedPosition.add(it) }
?.neighbors()
?.filter { it in elevations }
?.filter { isNotBlocked(elevations[nextPath.position]!!, elevations[it]!!) }
?.also { neighbors ->
when (neighbors.any { isComplete(it) }) {
true -> return nextPath.weight + 1
else -> queue.addAll(neighbors.map { Path(it, nextPath.weight + 1) })
}
}
}
return -1
}
}
fun List<String>.asGraph(): Graph = let {
var start = Position()
var destination = Position()
val elevations = it.flatMapIndexed { y, row ->
row.mapIndexed { x, height ->
val currentPosition = Position(x, y)
currentPosition to when (height) {
'S' -> 0.also { start = currentPosition }
'E' -> 25.also { destination = currentPosition }
else -> height - 'a'
}
}
}.toMap()
Graph(start, destination, elevations)
}
| 0 | Kotlin | 0 | 0 | 2a9276b52ed42e0c80e85844c75c1e5e70b383ee | 2,661 | aoc-2022 | Apache License 2.0 |
src/day04/Task.kt | dniHze | 433,447,720 | false | {"Kotlin": 35403} | package day04
import readInput
fun main() {
val input = readInput("day04")
println(solvePartTwo(input))
println(solvePartTwo(input))
}
fun solvePartOne(input: List<String>): Int {
val winners = calculateBingoWinners(input)
return winners.first().sum
}
fun solvePartTwo(input: List<String>): Int {
val winners = calculateBingoWinners(input)
return winners.last().sum
}
private fun calculateBingoWinners(input: List<String>): List<BingoWinner> {
val bingoInputs = input.bingoInputList()
val boards = buildBoards(input)
val indexes = buildIndexes(boards)
return buildList<BingoWinner> {
for (numberString in bingoInputs) {
val number = numberString.toInt()
val boardIndexes = indexes[number]
if (boardIndexes != null) {
for (boardIndex in boardIndexes) {
if (boardIndex.markAndCheck() && none { (index) -> index == boardIndex.board.index }) {
val index = boardIndex.board.index
val sum = boardIndex.board.calculateUnmarkedSum() * number
add(BingoWinner(index, sum))
}
}
}
}
}
}
private fun buildBoards(input: List<String>) = buildList {
val boardsInputOnly = input.drop(1)
val tempMatrix = mutableListOf<List<BingoNumber>>()
boardsInputOnly.forEachIndexed { index, value ->
val inputs = value.replace(' ', ',')
.split(',')
.filter { member -> member.isNotEmpty() }
.map { member -> member.toInt() }
if (inputs.isNotEmpty()) {
tempMatrix += inputs.map { intValue -> BingoNumber(intValue, false) }
}
if ((inputs.isEmpty() || index == boardsInputOnly.lastIndex) && tempMatrix.isNotEmpty()) {
val card = tempMatrix.toList()
tempMatrix.clear()
add(card)
}
}
}.mapIndexed { index, numbers -> BingoBoard(index, numbers) }
private fun buildIndexes(boards: List<BingoBoard>): Map<Int, List<BingoIndex>> = buildMap {
boards.forEach { board ->
board.numbers.forEachIndexed { y, row ->
row.forEachIndexed { x, (intValue) ->
val indexList = getOrPut(intValue) { emptyList() }
this[intValue] = indexList + BingoIndex(board, x, y)
}
}
}
}
private fun List<String>.bingoInputList() = first().splitToSequence(",")
private typealias BingoNumbers = List<List<BingoNumber>>
private data class BingoBoard(
val index: Int,
val numbers: BingoNumbers,
)
private fun BingoBoard.markAndCheck(x: Int, y: Int): Boolean {
get(x, y).marked = true
return checkRow(y) || checkColumn(x)
}
private fun BingoBoard.get(x: Int, y: Int) = numbers[y][x]
private fun BingoBoard.checkRow(y: Int): Boolean = numbers[y].all { number -> number.marked }
private fun BingoBoard.checkColumn(x: Int): Boolean = numbers.map { it[x] }.all { number -> number.marked }
private fun BingoBoard.calculateUnmarkedSum(): Int = numbers.sumOf { row ->
row.sumOf { number -> number.value.takeIf { !number.marked } ?: 0 }
}
private data class BingoIndex(
val board: BingoBoard,
val x: Int,
val y: Int,
)
private data class BingoWinner(
val index: Int,
val sum: Int,
)
private fun BingoIndex.markAndCheck(): Boolean = board.markAndCheck(x, y)
private data class BingoNumber(
val value: Int,
var marked: Boolean,
)
| 0 | Kotlin | 0 | 1 | f81794bd57abf513d129e63787bdf2a7a21fa0d3 | 3,493 | aoc-2021 | Apache License 2.0 |