2021 Day4

class Bingo(numbersToCall: String, bingoCards:String) {
    private val numbersToCall = numbersToCall.split(",").map { it.toInt() }
    private val bingoCards = bingoCards.replace("\n ", "\n").replace("  ", " ")
        .split("\n\n")
        .map { card -> BingoCard(
             card.split("\n")
            .map { row -> row.split(" ")
            .map { number -> number.toInt() } }
        )}

    fun play(): Int {
        val calledNumbers = numbersToCall.takeWhile { number -> !bingoCards.any { card -> card.call(number) } }
        val lastCalledNumber = numbersToCall[calledNumbers.size]
        val cardThatWon = bingoCards.first { it.hasWon() }
        return lastCalledNumber * cardThatWon.sumOfNotCalled(calledNumbers + lastCalledNumber)
    }

    fun biggestLoser(): Int{
        val calledNumbers = numbersToCall.takeWhile { number ->
            bingoCards.count { card -> card.call(number) } < (bingoCards.size - 1)
        }
        val worstBingoCard = bingoCards.first { !it.hasWon() }
        val worstCalledNumbers = numbersToCall.subList(calledNumbers.size, numbersToCall.size)
            .takeWhile { number -> !worstBingoCard.call(number) }
        val lastCalledNumber = numbersToCall[calledNumbers.size + worstCalledNumbers.size]
        return worstBingoCard.sumOfNotCalled(calledNumbers + worstCalledNumbers + lastCalledNumber) * lastCalledNumber
    }
}

class BingoCard (rows: List<List<Int>>) {
    private val cardNumbers = (0 until rows.size).fold(HashMap<Int, Pair<Int, Int>>()) {
            acc, x -> (0 until rows.size).forEach { y -> acc[rows[x][y]] = (x to y) }
        acc
    }.toMap()

    private val rowCounts = Array<Int>(rows.size) {0}
    private val columnCounts =  Array<Int>(rows.size) {0}

    fun call(number: Int): Boolean {
        if (hasWon()) return true
        if (!cardNumbers.containsKey(number) ) return false
        return (rowCounts[cardNumbers[number]?.first!!]++ == rowCounts.size-1
                || columnCounts[cardNumbers[number]?.second!!]++ == rowCounts.size-1)
    }

    fun sumOfNotCalled(calledNumbers:List<Int>) = cardNumbers.keys.filter { !calledNumbers.contains(it)  }.sum()
    fun hasWon() = rowCounts.any { it >= 5 } || columnCounts.any { it >= 5 }
}