Transforming with Map

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

The collection operation map applies a lambda to each element and returns a new list of results in the same order. This operation is different from the Map collection type: it transforms values, and does not create key-value entries unless your lambda returns pairs.

Inside main:

val lengths = listOf("sun", "rain").map { it.length }
println(lengths)

Each word becomes its length while order and element count stay the same.

map returns one transformed result per input element, preserving order.

Challenge

Medium

Complete squares with parameters values: List<Int>. Return the square of each value in input order. Values are between -1000 and 1000. Use map.

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 List<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 squares(values: List<Int>): List<Int> {
    // Write your solution here.
    return emptyList()
}
fun main() {
    val valuesCount = readln().toInt()
    val values = mutableListOf<Int>()
    for (i0 in 0 until valuesCount) {
        val valuesItem = readln().toInt()
        values.add(valuesItem)
    }
    println(squares(values))
}