this post was submitted on 01 Dec 2024
51 points (98.1% liked)

Advent Of Code

996 readers
4 users here now

An unofficial home for the advent of code community on programming.dev!

Advent of Code is an annual Advent calendar of small programming puzzles for a variety of skill sets and skill levels that can be solved in any programming language you like.

AoC 2024

Solution Threads

M T W T F S S
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25

Rules/Guidelines

Relevant Communities

Relevant Links

Credits

Icon base by Lorc under CC BY 3.0 with modifications to add a gradient

console.log('Hello World')

founded 1 year ago
MODERATORS
Ategon
[email protected]
CameronDev
51
๐ŸŒฒ - 2024 DAY 1 SOLUTIONS -๐ŸŒฒ (self.advent_of_code)
submitted 1 month ago by Ategon to c/advent_of_code
39 comments fedilink hide all child comments
 

Day 1: Historian Hysteria

Megathread guidelines

  • Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
  • You can send code in code blocks by using three backticks, the code, and then three backticks or use something such as https://blocks.programming.dev if you prefer sending it through a URL

FAQ

you are viewing a single comment's thread
view the rest of the comments
[โ€“] proved_unglue 3 points 1 month ago (1 children)

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
}
[โ€“] [email protected] 1 points 1 month ago* (last edited 1 month ago) (1 children)

I have another Kotlin (albeit similar) solution:

import kotlin.math.abs

fun main() {

    fun getLists(input: List<String>): Pair<List<Int>, List<Int>> {
        val unsortedPairs = input.map {
            it.split("   ").map { it.toInt() }
        }

        val listA = unsortedPairs.map { it.first() }
        val listB = unsortedPairs.map { it.last() }
        return Pair(listA, listB)
    }

    fun part1(input: List<String>): Int {
        val (listA, listB) = getLists(input)

        return listA.sorted().zip(listB.sorted()).sumOf { abs(it.first - it.second) }
    }

    fun part2(input: List<String>): Int {
        val (listA, listB) = getLists(input)

        return listA.sumOf { number ->
            number * listB.count { it == number }
        }
    }

    // Or read a large test input from the `src/Day01_test.txt` file:
    val testInput = readInput("Day01_test")
    check(part1(testInput) == 11)
    check(part2(testInput) == 31)

    // Read the input from the `src/Day01.txt` file.
    val input = readInput("Day01")
    part1(input).println()
    part2(input).println()
}

It's a bit more compact. (If you take out the part that actually calls the functions on the (test-)input.)

[โ€“] proved_unglue 2 points 1 month ago

Thanks! I like the Pair destruction and zip().sumOf() approach. I'm relatively new to Kotlin, so this is a good learning experience. ๐Ÿ˜