Grouping Values

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

groupBy returns a map whose keys are produced by a lambda and whose values are lists of matching elements. Each group preserves the original order of its members. Accessing a missing group gives null, just like other map lookups.

Inside main:

val groups = listOf("a", "to", "b").groupBy { it.length }
println(groups[1])

The length-one group contains a and b in their original order.

groupBy stores every matching element in a list for its computed key.

Challenge

Medium

Complete wordsOfLength with parameters words: List<String>, length: Int. Group words by length, then return the requested group in original order. Return an empty list if the group is absent.

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<String>. 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 wordsOfLength(words: List<String>, length: Int): List<String> {
    // Write your solution here.
    return emptyList()
}
fun main() {
    val wordsCount = readln().toInt()
    val words = mutableListOf<String>()
    for (i0 in 0 until wordsCount) {
        val wordsItem = readLine().orEmpty()
        words.add(wordsItem)
    }
    val length = readln().toInt()
    println(wordsOfLength(words, length))
}