Intermediate flow operators: How to not emit if the transformed value is the same?

I am trying to code a stopwatch using flows.

import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main(): Unit = runBlocking{
    val startTime = System.currentTimeMillis()
    val elapsedTime = MutableStateFlow(0L)
    // start stopwatch
    launch {
        while(true){
            elapsedTime.value = System.currentTimeMillis() - startTime
            delay(100)
        }
    }

    // update ui
    launch {
        elapsedTime.map{
            it/1000
        }.collect{
            println("$it seconds")
        }
    }
}

0 seconds
0 seconds
0 seconds
0 seconds
0 seconds
0 seconds
0 seconds
0 seconds
0 seconds
0 seconds
1 seconds
1 seconds
1 seconds

The problem is that intermediate flows do not keep track of whether the value changed like the following code:

import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main(): Unit = runBlocking{
    val startTime = System.currentTimeMillis()
    val elapsedTime = MutableStateFlow(0L)
    // start stopwatch
    launch {
        while(true){
            elapsedTime.value = (System.currentTimeMillis() - startTime)/1000
            delay(5)
        }
    }

    // update ui
    launch {
        elapsedTime.collect{
            println("$it seconds")
        }
    }
}

0 seconds
1 seconds
2 seconds
3 seconds

I want to have a single root flow elapsedTime.value = System.currentTimeMillis() - startTime from which I can have multiple observers with different levels of accuracy using .map{it/a}. Is there a clean way to accomplish this?

Yes, using distinctUntilChanged(). And just as an example of different way to create the flow without having to use MutableStateFlow, I used the flow builder with stateIn. And an alternate (my preferred) way to collect a flow in its own coroutine using onEach/launchIn instead of collect/launch for less code indentation and nested brackets.

fun main(): Unit = runBlocking {
    val elapsedTime = flow {
        val startTime = System.currentTimeMillis()
        while(true){
            emit(System.currentTimeMillis() - startTime)
            delay(5)
        }
    }.stateIn(this, SharingStarted.Eagerly, 0L)

    // update ui
    elapsedTime.map { it / 1000L }
        .distinctUntilChanged()
        .onEach { println("$it seconds") }
        .launchIn(this)

    launch {
        elapsedTime.map { it / 100 L }
            .distinctUntilChanged()
            .collect { println("$it deciseconds") }
    }
}

</details>