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
}

  

    
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
}
  
  

    
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
}

  

    
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
}
 
  

    
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
}

  

    
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
}