Day 5: Print Queue

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://topaz.github.io/paste/ if you prefer sending it through a URL

FAQ

  • 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, rules: List>): List {
        return numbers.sortedWith { a, b -> if (rules.contains(a to b)) -1 else 1 }
    }
    
    private fun parse(input: String): Pair>, List>> {
        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
    }
    
      • I guess adding type aliases and removing the regex from parser makes it a bit more readable.

        typealias Rule = Pair
        typealias PageNumbers = List
        
        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): PageNumbers {
            return numbers.sortedWith { a, b -> if (rules.contains(a to b)) -1 else 1 }
        }
        
        private fun parse(input: String): Pair, List> {
            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
        }