Combining flows (zip, combine) in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin flow zip example?

Consider the following Kotlin code using zip on two flows. What will be printed?

Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val flow1 = flowOf(1, 2, 3)
    val flow2 = flowOf("A", "B", "C", "D")

    flow1.zip(flow2) { a, b -> "$a$b" }
        .collect { println(it) }
}

A

1A
2B
3C
4D

B

1A
2B
3C

C

1A
2B
3C
D

D

A1
B2
C3

💡 Hint

Remember that zip pairs elements until one flow runs out.

The zip operator pairs elements from both flows one by one. Since flow1 has 3 elements and flow2 has 4, the resulting flow emits 3 pairs. The extra element 'D' in flow2 is ignored.

❓ Predict Output

intermediate

What does this Kotlin flow combine example print?

Look at this Kotlin code using combine on two flows. What will be the output?

Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.delay

fun main() = runBlocking {
    val flow1 = flow {
        emit(1)
        delay(100)
        emit(2)
    }
    val flow2 = flow {
        emit("A")
        delay(50)
        emit("B")
    }

    flow1.combine(flow2) { a, b -> "$a$b" }
        .collect { println(it) }
}

A

1A
2A
2B

B

1A
2A
1B
2B

C

1A
1B
2B

D

1A
2B

💡 Hint

combine emits every time any flow emits, using the latest values from both.

combine emits when either flow emits, using the latest values from both flows. The sequence is: both emit first values (1 and A) → 1A, then flow2 emits B (latest flow1 is 1) → 1B, then flow1 emits 2 (latest flow2 is B) → 2B.

🔧 Debug

advanced

Why does this Kotlin flow zip code cause a compilation error?

This Kotlin code tries to zip two flows but fails to compile. What is the cause?

Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val flow1 = flowOf(1, 2, 3)
    val flow2 = flowOf("A", "B", "C")

    val zipped = flow1.zip(flow2) { a, b -> a + b }
    zipped.collect { println(it) }
}

A Runtime error: NullPointerException

B Compilation error: Missing collect call on zipped flow

C No error, prints 1A 2B 3C

D Compilation error: Cannot add Int and String with '+' operator

💡 Hint

Check the types used in the lambda inside zip.

The lambda tries to add an Int and a String using '+', which is not allowed in Kotlin. This causes a compilation error.

📝 Syntax

advanced

Which option correctly combines two flows with combine operator?

Select the Kotlin code snippet that correctly uses combine to merge two flows of Int and String.

A flow1.combine(flow2) { a, b -> "$a$b" }

B flow1.combine(flow2) { a, b -> a + b }

C flow1.zip(flow2) { a, b -> "$a$b" }

D flow1.combine(flow2) { a, b -> a * b }

💡 Hint

combine requires a lambda that returns a value combining both inputs.

Option A correctly uses combine with a lambda that concatenates Int and String as a String. Option A tries to add Int and String with '+', which is invalid. Option A uses zip, not combine. Option A tries to multiply Int and String, invalid operation.

🚀 Application

expert

How many items are emitted by this zipped flow?

Given these two Kotlin flows, how many items will the zipped flow emit?

Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val flow1 = flow {
        emit(10)
        emit(20)
        emit(30)
        emit(40)
    }
    val flow2 = flow {
        emit("X")
        emit("Y")
    }

    val zipped = flow1.zip(flow2) { a, b -> "$a$b" }
    var count = 0
    zipped.collect {
        count++
    }
    println(count)
}

A 2

B 4

C 6

D 0

💡 Hint

zip emits pairs until one flow runs out of elements.

zip stops emitting when the shortest flow ends. flow1 emits 4 items, flow2 emits 2 items, so zipped emits 2 items.