FlatMap for nested collections in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to flatten the list of lists using flatMap.

Kotlin

val nestedList = listOf(listOf(1, 2), listOf(3, 4))
val flatList = nestedList.[1] { it }
println(flatList)

Drag options to blanks, or click blank then click option'

Amap

Bfilter

CflatMap

DforEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using map instead of flatMap results in a list of lists, not a flat list.

The flatMap function flattens the nested lists into a single list by applying the given lambda.

2fill in blank

medium

Complete the code to extract all words from a list of sentences using flatMap.

Kotlin

val sentences = listOf("hello world", "kotlin is fun")
val words = sentences.[1] { it.split(" ") }
println(words)

Drag options to blanks, or click blank then click option'

AflatMap

Bmap

Cfilter

Dreduce

Attempts:

3 left

💡 Hint

Common Mistakes

Using map will create a list of lists of words instead of a flat list.

flatMap applies the lambda to each sentence and flattens the resulting lists of words into one list.

3fill in blank

hard

Fix the error in the code to flatten a list of nullable lists using flatMap.

Kotlin

val listOfNullableLists: List<List<Int>?> = listOf(listOf(1, 2), null, listOf(3))
val flatList = listOfNullableLists.[1] { it ?: emptyList() }
println(flatList)

Drag options to blanks, or click blank then click option'

Aflatten

BfilterNotNull

Cmap

DflatMap

Attempts:

3 left

💡 Hint

Common Mistakes

Using map will keep the nested structure.

Using flatten directly on nullable lists causes errors.

flatMap is used with a lambda that replaces null with an empty list to safely flatten the collection.

4fill in blank

hard

Fill both blanks to create a flat list of all characters from a list of words.

Kotlin

val words = listOf("cat", "dog")
val chars = words.[1] { it.[2]() }
println(chars)

Drag options to blanks, or click blank then click option'

AflatMap

Bmap

CtoList

DtoCharArray

Attempts:

3 left

💡 Hint

Common Mistakes

Using map instead of flatMap results in a list of arrays, not a flat list.

Using toList() returns a list of strings, not characters.

flatMap applies the lambda to each word, and toCharArray() converts each word to a list of characters, which are then flattened into one list.

5fill in blank

hard

Fill all three blanks to create a map of words to their lengths, but only for words longer than 3 characters.

Kotlin

val words = listOf("apple", "bat", "carrot", "dog")
val result = words.[1] { word ->
    if (word.length [2] 3) mapOf(word [3] word.length) else emptyMap<String, Int>()
}
println(result)

Drag options to blanks, or click blank then click option'

AflatMap

B>

Cto

Dmap

Attempts:

3 left

💡 Hint

Common Mistakes

Using flatMap instead of map changes the structure.

Using '<' instead of '>' changes the filter condition.

Using '=' instead of 'to' causes syntax errors.

map transforms each word, the condition checks if length is greater than 3, and to creates a pair for the map.

Practice

1. What does the flatMap function do when applied to a nested list in Kotlin?

easy

A. It filters elements based on a condition.

B. It sorts the nested lists in ascending order.

C. It transforms each element and flattens the result into a single list.

D. It converts the list into a set to remove duplicates.

Solution

1. Step 1: Understand flatMap behavior

   flatMap applies a transformation to each element and then flattens the nested results into one list.

2. Step 2: Compare with other functions

   Unlike sorting, filtering, or converting to a set, flatMap combines mapping and flattening in one step.

3. Final Answer:

   It transforms each element and flattens the result into a single list. -> Option C

4. Quick Check:

   flatMap = transform + flatten [OK]

Hint: Remember: flatMap = map + flatten in one step [OK]

Common Mistakes:

• Confusing flatMap with filter or sort
• Thinking flatMap removes duplicates
• Assuming flatMap only maps without flattening

2. Which of the following is the correct syntax to use flatMap on a list of lists named nestedList in Kotlin?

easy

A. nestedList.flatMap { it }

B. nestedList.flatMap()

C. nestedList.flatMap -> it

D. nestedList.flatMap { it.flatten() }

Solution

1. Step 1: Identify correct lambda syntax

   The flatMap function requires a lambda to transform each element. { it } returns each inner list as is.

2. Step 2: Check other options

   nestedList.flatMap() misses lambda, C uses wrong arrow syntax, D uses flatten() incorrectly on flat inner lists.

3. Final Answer:

   nestedList.flatMap { it } -> Option A

4. Quick Check:

   flatMap needs a lambda like { it } [OK]

Hint: flatMap always needs a lambda block { } [OK]

Common Mistakes:

• Omitting the lambda block
• Using arrow (->) instead of curly braces
• Using flatten() instead of identity mapping

3. What is the output of the following Kotlin code?

val nested = listOf(listOf(1, 2), listOf(3, 4))
val result = nested.flatMap { it.map { it * 2 } }
println(result)

medium

A. [[2, 4], [6, 8]]

B. [1, 2, 3, 4]

C. [2, 4, [6, 8]]

D. [2, 4, 6, 8]

Solution

1. Step 1: Understand inner map transformation

   Each inner list element is multiplied by 2, so listOf(1,2) becomes listOf(2,4), and listOf(3,4) becomes listOf(6,8).

2. Step 2: Apply flatMap flattening

   flatMap flattens the transformed lists into one list: [2, 4, 6, 8].

3. Final Answer:

   [2, 4, 6, 8] -> Option D

4. Quick Check:

   flatMap + map doubles and flattens [OK]

Hint: flatMap flattens after map transformation [OK]

Common Mistakes:

• Expecting nested lists instead of flat list
• Ignoring the inner map multiplication
• Confusing output with original nested list

4. Identify the error in this Kotlin code snippet using flatMap:

val nested = listOf(listOf(1, 2), listOf(3, 4))
val result = nested.flatMap { it * 2 }
println(result)

medium

A. flatMap requires a filter inside the lambda.

B. Cannot multiply a list by an integer directly.

C. The variable 'nested' is not defined.

D. flatMap should be replaced with map.

Solution

1. Step 1: Analyze the lambda expression

   The lambda tries to multiply it (a list) by 2, which is invalid in Kotlin.

2. Step 2: Understand flatMap requirements

   flatMap expects a lambda returning an iterable, but it * 2 causes a type error.

3. Final Answer:

   Cannot multiply a list by an integer directly. -> Option B

4. Quick Check:

   List * Int is invalid in Kotlin [OK]

Hint: Check types inside lambda; lists can't be multiplied by numbers [OK]

Common Mistakes:

• Assuming list * number works like in some other languages
• Thinking flatMap needs a filter
• Confusing map and flatMap usage

5. Given a list of students where each student has a list of grades, how can you use flatMap to get a single list of all grades above 70?

data class Student(val name: String, val grades: List<Int>)
val students = listOf(
    Student("Alice", listOf(80, 65)),
    Student("Bob", listOf(90, 72)),
    Student("Carol", listOf(60, 85))
)
// Fill in the blank:
val passingGrades = students.flatMap { ________ }
println(passingGrades)

hard

A. it.grades.filter { grade -> grade > 70 }

B. it.grades.map { grade -> grade > 70 }

C. it.grades.filter { grade -> grade < 70 }

D. it.grades

Solution

1. Step 1: Filter grades above 70 for each student

   Inside the lambda, use it.grades.filter { grade -> grade > 70 } to keep only passing grades.

2. Step 2: Use flatMap to flatten all filtered grades

   flatMap combines all filtered lists into one flat list of passing grades.

3. Final Answer:

   it.grades.filter { grade -> grade > 70 } -> Option A

4. Quick Check:

   flatMap + filter extracts and flattens passing grades [OK]

Hint: Use flatMap with filter inside to flatten filtered results [OK]

Common Mistakes:

• Using map instead of filter, resulting in booleans
• Filtering for grades below 70 by mistake
• Not filtering and returning all grades