/**
     * Class that represents one of the current distance records
     *
     * Each race can be represented as the time limit and the last record distance.
     *
     * @property time The time available to complete the race.
     * @property distance The last record distance (we need to beat).
     */
    data class RaceRecord(val time: Double, val distance: Double) {
        companion object {
            /**
             * Parse the input from a string representing the input file
             *
             * Today's input is only two lines and they both mean different things, so we'll parse the
             * input as a single string, convert each line to a list of numbers, and zip them together
             * to make our [RaceRecord]s
             */
            fun parseInput(input: String): List<RaceRecord> {
                val toDoubleOrThrow: (String) -> Double = { n ->
                    n.toDoubleOrNull()
                            ?: throw IllegalArgumentException("$n cannot be parsed to a Double!")
                }

                val (raceTimes, raceDistances) =
                        input.trim().split("\\n".toRegex()).map { line ->
                            line.replaceFirst("\\w+:".toRegex(), "")
                                    .trim()
                                    .split("\\s+".toRegex())
                                    .map(toDoubleOrThrow)
                        }

                return raceTimes.zip(raceDistances) { time, distance -> RaceRecord(time, distance) }
            }
        }
    }

    class Day06(input: String) {

        // One string to one list. Piece of cake.
        private val parsed = RaceRecord.parseInput(input)

    }

    // My first imports!
    import kotlin.math.ceil
    import kotlin.math.floor
    import kotlin.math.sqrt

    data class RaceRecord(val time: Double, val distance: Double) {
        // companion object { ... }

        /**
         * Return the number of different ways we can win the race!
         *
         * @ return An Int indicating just how many different hold times will get us
         * the winning distance.
         */
        fun countWinningStrategies(): Int {
            // For: Hold Time -> h; Race Time -> t; Distance to Beat -> d
            // We can derive a formula for beating the previous record as:
            // - (t - h) * h > d
            //
            // Which rearranges to: (-1)*h^2 + (t * h) - d > 0
            // Now, that there is a quadratic expression! You know, the old
            // `ax^2 + bx + c = 0`? We can solve it like:
            // h = (-t +/- sqrt(t^2 - 4 * (-1) * (-d))) / 2 * (-1)
            //
            // That's math! The 'tricky' part is that we don't want to know the _exact_
            // hold time to _equal_ the previous record, we want to know the smallest
            // and largest hold times that will _beat_ the record. For that, we round
            // _away_ from the mean possible hold time and then adjust our value towards
            // the mean by 1. For example, the results of this formula for the first
            // example race (7ms, 9mm) indicate that you could travel the 9mm by holding
            // the button for 1.697ms or 5.303ms. The minimum number of whole milliseconds,
            // then is `floor(1.697) + 1` and the maximum is `ceil(5.303) - 1`. This
            // correctly handles cases where the exact time is an integer as well.
            val sqrtFormulaPart = sqrt((time * time) - (4 * distance))
            val minWinningHold = floor((-time + sqrtFormulaPart) / -2).toInt() + 1
            val maxWinningHold = ceil((-time - sqrtFormulaPart) / -2).toInt() - 1

            // The total number of winning holds is the length of the inclusive range
            // of all possible winning holds.
            return (maxWinningHold - minWinningHold) + 1
        }
    }

    class Day06(input: String) {

        // One string to one list. Piece of cake.
        // private val parsed = ...

        // In part 1, we calculate all our winning hold times and return
        // the product of that count from each race.
        fun solvePart1(): Int = parsed
          .map { it.countWinningStrategies() }
          .reduce { acc, n -> acc * n }

    }

    data class RaceRecord(val time: Double, val distance: Double) {
        // companion object { ... }

        // fun countWinningStrategies(): Int { ... }
    }

    class Day06(input: String) {

        // One string to one list. Piece of cake.
        // private val parsed = ...

        // In part 1, we calculate all our winning hold times and return
        // the product of that count from each race.
        // fun solvePart1(): Int = ...

        // In part 2, we learn what 'kerning' is and get mad about it. Then
        // we concatenate all the race times/records into one and figure how
        // how many ways we can win that one race.
        fun solvePart2(): Int {
            val uberRaceTime = parsed
              .joinToString("") { it.time.toInt().toString() }
              .toDouble()
            val uberDistance = parsed
              .joinToString("") { it.distance.toInt().toString() }
              .toDouble()
            return RaceRecord(uberRaceTime, uberDistance).countWinningStrategies()
        }
    }