Guard Clauses

Part of the Logic & Flow section of Coddy's Kotlin journey. Lesson 41 of 63.

A guard clause returns early when input cannot follow the main path. Checking exceptional cases first can reduce nested conditions. A return leaves the current function, so later statements in that function do not execute.

fun deliveryFee(items: Int): Int {
    if (items < 0) return -1
    return items * 2
}

Inside main:

println(deliveryFee(-1))

The negative input triggers the guard and prevents the normal fee calculation.

A guard clause exits the function before the normal path when its condition holds.

Challenge

Medium

Complete firstOrMissing with parameters values: List<Int>. Return -1 for an empty list using a guard clause. Otherwise return the first value.

Unless stricter bounds are stated above, collections contain at most 100 elements at each level, and integer arguments and integer collection values are between -1000 and 1000. Text supplied for parsing can include invalid or out-of-range representations as described.

Return a value of type Int. Keep the supplied input/output code. It reads scalar arguments one per line; a list starts with its count followed by its elements, and a map starts with its entry count followed by each key and value. Nested lists repeat the count-and-elements format for each row. The supplied main prints the return value followed by one newline. Lists use Kotlin's standard bracketed format; print no additional labels.

Try it yourself

fun firstOrMissing(values: List<Int>): Int {
    // Write your solution here.
    return 0
}
fun main() {
    val valuesCount = readln().toInt()
    val values = mutableListOf<Int>()
    for (i0 in 0 until valuesCount) {
        val valuesItem = readln().toInt()
        values.add(valuesItem)
    }
    println(firstOrMissing(values))
}