Safe Map Lookups

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

map[key] returns a nullable value because the key may be absent. Use the Elvis operator for a fallback. A stored zero is different from a missing value. Read-only access does not imply deep immutability.

Inside main:

val stock = mapOf("pen" to 0)
println(stock["book"] ?: -1)

The book key is absent, so the null result selects the fallback.

A missing key produces null; the Elvis fallback is used only for null.

Challenge

Medium

Complete lookupStock with parameters stock: Map<String, Int>, key: String. Return the stock for the requested key, or -1 when absent. Stock values are nonnegative.

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 lookupStock(stock: Map<String, Int>, key: String): Int {
    // Write your solution here.
    return 0
}
fun main() {
    val stockCount = readln().toInt()
    val stock = mutableMapOf<String, Int>()
    for (i0 in 0 until stockCount) {
        val stockKey = readln()
        val stockValue = readln().toInt()
        stock[stockKey] = stockValue
    }
    val key = readLine().orEmpty()
    println(lookupStock(stock, key))
}