Inlägg

fun run() {
        
        val input = File("src/input/day6.txt").readText()

        println(findNonRepearting(input, 4))
        println(findNonRepearting(input, 14))
    }

    private fun findNonRepearting(input: String, markerLength: Int): Int {
        val buffer: ArrayDeque<Char> = ArrayDeque()

        for((index, c) in input.withIndex())
        {
            val indexOfAlreadyExisting = buffer.indexOf(c)
            if (indexOfAlreadyExisting != -1) {

                repeat(indexOfAlreadyExisting + 1) {buffer.removeFirst()}
            }

            buffer.addLast(c)

            if (buffer.size == markerLength) {
                return index + 1
            }
        }

        throw IllegalArgumentException("Nu blev det tokigt")
    }

//Annan lösning
 private fun findNonRepeartingAlternative(input: String, markerLength: Int): Int {
        val buffer: ArrayDeque<Char> = ArrayDeque()

        for((index, c) in input.withIndex())
        {
            buffer.addLast(c)

            if(buffer.size == markerLength + 1)
            {
                buffer.removeFirst()
            }

            if(buffer.distinct().size >= markerLength)
            {
                return index + 1
            }
        }
        throw IllegalArgumentException("Nu blev det tokigt")
    }

data class Crate(val crateMarking: Char)
    data class CrateStack(val stack: ArrayDeque<Crate>)
    data class MoveInstruction(val numberToMove: Int, val target: Int, val destination: Int)

    fun run() {
        val input = File("src/input/day5.txt").readText()
        val inputParts = input.split("\r\n\r\n")
        val crates = inputParts[0]
        val instructions = inputParts[1]

        val rowsFromBottom = crates.split("\n").reversed()
        val numberOfStacks = rowsFromBottom.first().trim().last().digitToInt()

        val part1Lambda = {moves: Int, targetStack: CrateStack, destinationStack: CrateStack ->
            for (i in 1..moves) {
                destinationStack.stack.addFirst(targetStack.stack.removeFirst())
            }
        }
        val part2Lambda = {moves: Int, targetStack: CrateStack, destinationStack: CrateStack ->
            val tempCrateStack = ArrayDeque<Crate>()
            for (i in 1..moves) {
                val topCrate = targetStack.stack.removeFirst()
                tempCrateStack.add(topCrate)
            }
            repeat(tempCrateStack.size) { destinationStack.stack.addFirst(tempCrateStack.removeLast()) }
        }

        println(solver(part1Lambda, instructions, getCrates(rowsFromBottom, numberOfStacks)))
        println(solver(part2Lambda, instructions, getCrates(rowsFromBottom, numberOfStacks)))
    }

    private fun getCrates(rowsFromBottom: List<String>, numberOfStacks: Int): List<CrateStack> {
        val stacks = IntRange(1, numberOfStacks).map { CrateStack(ArrayDeque()) }

        rowsFromBottom.drop(1).forEach { row ->
            for ((currentStack, i) in (1..row.length step 4).withIndex()) {
                val crateMarking = row[i]
                if (crateMarking.isLetter()) {
                    val crate = Crate(crateMarking)
                    stacks[currentStack].stack.addFirst(crate)
                }

            }
        }
        return stacks
    }

    private fun solver(lambda: (Int,CrateStack, CrateStack) -> Unit, moveInstructions: String, stacks:List<CrateStack>): String {
        buildMoveCrateInstruction(moveInstructions).forEach { instruction ->
            val targetStack = stacks[instruction.target - 1]
            val destinationStack = stacks[instruction.destination - 1]

            lambda(instruction.numberToMove, targetStack, destinationStack)
        }

        return stacks.map { it.stack.first().crateMarking }.toString()
    }

    private fun buildMoveCrateInstruction(moveInstructions: String): List<MoveInstruction> {
        val instructionParts = moveInstructions.split("\r\n").map { it.split(" ") }
        return instructionParts.map { MoveInstruction(it[1].toInt(), it[3].toInt(), it.last().toInt()) }
    }

    val allElfCalories = File("src/input/day1.txt")
        .readText()
        .split("\r\n\r\n")
        .flatMap { it.split("\r\n").map { calorie -> calorie.toInt() } }
        .sortedDescending()

    println(allElfCalories.first())
    println(allElfCalories.take(3).sum())

 private val part1 = mapOf(
        "A X" to 4,
        "A Y" to 8,
        "A Z" to 3,
        "B X" to 1,
        "B Y" to 5,
        "B Z" to 9,
        "C X" to 7,
        "C Y" to 2,
        "C Z" to 6
    )

    private val part2 = mapOf(
        "A X" to 3,
        "A Y" to 4,
        "A Z" to 8,
        "B X" to 1,
        "B Y" to 5,
        "B Z" to 9,
        "C X" to 2,
        "C Y" to 6,
        "C Z" to 7
    )

    fun run(){
        val allPlayPoints = File("src/input/day2.txt")
            .readLines()

        val part1Answer = allPlayPoints.groupBy { it }
            .map { it.value.size * part1[it.key]!! }
            .sum()
        val part2Answer = allPlayPoints.groupBy { it }
            .map { it.value.size * part2[it.key]!! }
            .sum()
        println(part1Answer)
        println(part2Answer)
    }

        val rucksackContents = File("src/input/day3.txt")
            .readLines()

        val part1Answer = rucksackContents
            .flatMap { row ->
                val strFirstPartAsArray = row.substring(0, row.length / 2).toCharArray()
                val strSecondPartAsArray = row.substring(row.length/2).toCharArray()

                strFirstPartAsArray.intersect(strSecondPartAsArray.toSet())
                    .map { if (it.isLowerCase()) it.code - 96 else it.code - 38 }
             }

        val part2Answer = rucksackContents
            .chunked(3)
            .flatMap { chunk ->
                val firstElf = chunk[0].toCharArray()
                val secondElf = chunk[1].toCharArray()
                val thirdElf = chunk[2].toCharArray()

                firstElf.intersect(secondElf.toSet()).intersect(thirdElf.toSet())
                    .map { if (it.isLowerCase()) it.code - 96 else it.code - 38 }
            }

        println(part1Answer.sum())
        println(part2Answer.sum())

    fun run() {
        val sectionPairs = File("src/input/day4.txt")
            .readLines()
            .map { row ->
                val pairs = row.split(",")
                Pair(buildSectionsArr(pairs[0]), buildSectionsArr(pairs[1]))
            }

        val part1Answer = sectionPairs.count { it.first.containsAll(it.second) || it.second.containsAll(it.first) }
        val part2Answer = sectionPairs.count {
            it.first.intersect(it.second).isNotEmpty() || it.second.intersect(it.first).isNotEmpty()
        }

        println(part1Answer)
        println(part2Answer)
    }

    private fun buildSectionsArr(sections: String): List<Int> {
        val startAndEnd = sections.split("-")
        val start = startAndEnd[0].toInt()
        val end = startAndEnd[1].toInt()
        return IntRange(start, end).toList()
    }