Kotlin
Not much inspiration. Brute forcing my way through today's level.
I guess adding type aliases and removing the regex from parser makes it a bit more readable.
typealias Rule = Pair<Int, Int>
typealias PageNumbers = List<Int>
fun part1(input: String): Int {
val (rules, listOfNumbers) = parse(input)
return listOfNumbers
.filter { numbers -> numbers == sort(numbers, rules) }
.sumOf { numbers -> numbers[numbers.size / 2] }
}
fun part2(input: String): Int {
val (rules, listOfNumbers) = parse(input)
return listOfNumbers
.filterNot { numbers -> numbers == sort(numbers, rules) }
.map { numbers -> sort(numbers, rules) }
.sumOf { numbers -> numbers[numbers.size / 2] }
}
private fun sort(numbers: PageNumbers, rules: List<Rule>): PageNumbers {
return numbers.sortedWith { a, b -> if (rules.contains(a to b)) -1 else 1 }
}
private fun parse(input: String): Pair<List<Rule>, List<PageNumbers>> {
val (rulesSection, numbersSection) = input.split("\n\n")
val rules = rulesSection.lines()
.mapNotNull { line ->
val parts = line.split('|').map { it.toInt() }
if (parts.size >= 2) parts[0] to parts[1] else null
}
val numbers = numbersSection.lines()
.map { line -> line.split(',').map { it.toInt() } }
return rules to numbers
}
Kotlin
Took me a while to figure out how to sort according to the rules. đ¤¯
fun part1(input: String): Int {
val (rules, listOfNumbers) = parse(input)
return listOfNumbers
.filter { numbers -> numbers == sort(numbers, rules) }
.sumOf { numbers -> numbers[numbers.size / 2] }
}
fun part2(input: String): Int {
val (rules, listOfNumbers) = parse(input)
return listOfNumbers
.filterNot { numbers -> numbers == sort(numbers, rules) }
.map { numbers -> sort(numbers, rules) }
.sumOf { numbers -> numbers[numbers.size / 2] }
}
private fun sort(numbers: List<Int>, rules: List<Pair<Int, Int>>): List<Int> {
return numbers.sortedWith { a, b -> if (rules.contains(a to b)) -1 else 1 }
}
private fun parse(input: String): Pair<List<Pair<Int, Int>>, List<List<Int>>> {
val (rulesSection, numbersSection) = input.split("\n\n")
val rules = rulesSection.lines()
.mapNotNull { line -> """(\d{2})\|(\d{2})""".toRegex().matchEntire(line) }
.map { match -> match.groups[1]?.value?.toInt()!! to match.groups[2]?.value?.toInt()!! }
val numbers = numbersSection.lines().map { line -> line.split(',').map { it.toInt() } }
return rules to numbers
}
Kotlin
fun part1(input: String): Int {
return countWordOccurrences(input.lines())
}
fun part2(input: String): Int {
val grid = input.lines().map(String::toList)
var count = 0
for (row in 1..grid.size - 2) {
for (col in 1..grid[row].size - 2) {
if (grid[row][col] == 'A') {
count += countCrossMatch(grid, row, col)
}
}
}
return count
}
private fun countCrossMatch(grid: List<List<Char>>, row: Int, col: Int): Int {
val surroundingCorners = listOf(
grid[row - 1][col - 1], // upper left
grid[row - 1][col + 1], // upper right
grid[row + 1][col - 1], // lower left
grid[row + 1][col + 1], // lower right
)
// no matches:
// M S S M
// A A
// S M M S
return if (surroundingCorners.count { it == 'M' } == 2
&& surroundingCorners.count { it == 'S' } == 2
&& surroundingCorners[0] != surroundingCorners[3]
) 1 else 0
}
private fun countWordOccurrences(matrix: List<String>): Int {
val rows = matrix.size
val cols = if (rows > 0) matrix[0].length else 0
val directions = listOf(
Pair(0, 1), // Horizontal right
Pair(1, 0), // Vertical down
Pair(1, 1), // Diagonal down-right
Pair(1, -1), // Diagonal down-left
Pair(0, -1), // Horizontal left
Pair(-1, 0), // Vertical up
Pair(-1, -1), // Diagonal up-left
Pair(-1, 1) // Diagonal up-right
)
fun isWordAt(row: Int, col: Int, word: String, direction: Pair<Int, Int>): Boolean {
val (dx, dy) = direction
for (i in word.indices) {
val x = row + i * dx
val y = col + i * dy
if (x !in 0 until rows || y !in 0 until cols || matrix[x][y] != word[i]) {
return false
}
}
return true
}
var count = 0
for (row in 0 until rows) {
for (col in 0 until cols) {
for (direction in directions) {
if (isWordAt(row, col, "XMAS", direction)) {
count++
}
}
}
}
return count
}
Thanks! I like the Pair destruction and zip().sumOf() approach. I'm relatively new to Kotlin, so this is a good learning experience. đ
Kotlin
No đ for Kotlin here?
import kotlin.math.abs
fun part1(input: String): Int {
val diffs: MutableList<Int> = mutableListOf()
val pair = parse(input)
pair.first.sort()
pair.second.sort()
pair.first.forEachIndexed { idx, num ->
diffs.add(abs(num - pair.second[idx]))
}
return diffs.sum()
}
fun part2(input: String): Int {
val pair = parse(input)
val frequencies = pair.second.groupingBy { it }.eachCount()
var score = 0
pair.first.forEach { num ->
score += num * frequencies.getOrDefault(num, 0)
}
return score
}
private fun parse(input: String): Pair<MutableList<Int>, MutableList<Int>> {
val left: MutableList<Int> = mutableListOf()
val right: MutableList<Int> = mutableListOf()
input.lines().forEach { line ->
if (line.isNotBlank()) {
val parts = line.split("\\s+".toRegex())
left.add(parts[0].toInt())
right.add(parts[1].toInt())
}
}
return left to right
}
Kotlin
A bit late to the party, but here you go.
import kotlin.math.abs
fun part1(input: String): Int {
return solve(input, ::isSafe)
}
fun part2(input: String): Int {
return solve(input, ::isDampSafe)
}
private fun solve(input: String, condition: (List<Int>) -> Boolean): Int {
var safeCount = 0
input.lines().forEach { line ->
if (line.isNotBlank()) {
val nums = line.split("\\s+".toRegex()).map { it.toInt() }
safeCount += if (condition(nums)) 1 else 0
}
}
return safeCount
}
private fun isSafe(list: List<Int>): Boolean {
val safeDiffs = setOf(1, 2, 3)
var incCount = 0
var decCount = 0
for (idx in 0..<list.lastIndex) {
if (!safeDiffs.contains(abs(list[idx] - list[idx + 1]))) {
return false
}
if (list[idx] <= list[idx + 1]) incCount++
if (list[idx] >= list[idx + 1]) decCount++
}
return incCount == 0 || decCount == 0
}
private fun isDampSafe(list: List<Int>): Boolean {
if (isSafe(list)) {
return true
} else {
for (idx in 0..list.lastIndex) {
val shortened = list.toMutableList()
shortened.removeAt(idx)
if (isSafe(shortened)) {
return true
}
}
}
return false
}
Nice, sometimes a few extra linebreaks can do the trick...
Kotlin
fun part1(input: String): Int {
val pattern = "mul\\((\\d{1,3}),(\\d{1,3})\\)".toRegex()
var sum = 0
pattern.findAll(input).forEach { match ->
val first = match.groups[1]?.value?.toInt()!!
val second = match.groups[2]?.value?.toInt()!!
sum += first * second
}
return sum
}
fun part2(input: String): Int {
val pattern = "mul\\((\\d{1,3}),(\\d{1,3})\\)|don't\\(\\)|do\\(\\)".toRegex()
var sum = 0
var enabled = true
pattern.findAll(input).forEach { match ->
if (match.value == "do()") enabled = true
else if (match.value == "don't()") enabled = false
else if (enabled) {
val first = match.groups[1]?.value?.toInt()!!
val second = match.groups[2]?.value?.toInt()!!
sum += first * second
}
}
return sum
}