Início / coding / Perguntas / 78550071
Accepted
k314159
Asked: 2024-05-29 22:00:47 +0800 CST

Último elemento da sequência, mas com uma quebra se uma condição for atendida

  • 772

Digamos que eu tenha uma Sequence<Int>origem desconhecida (não necessariamente de uma coleção) e de tamanho desconhecido, mas finito:

val seq = sequenceOf(1, 2, -3, 4, 5, /* ... */)

Suponha que a sequência seja grande o suficiente para tornar indesejável transformar toda a sequência em um arquivo List.

Quero obter o último elemento da sequência:

val last = seq.last()

Mas também quero capturar qualquer elemento "inválido" que possa aparecer (digamos que números negativos sejam inválidos) e retornar o primeiro elemento:

val invalid = seq.first { it < 0 }

Mas como posso fazer as duas coisas ao mesmo tempo?

val lastUnlessInvalidElementPresent = seq.firstOrNull { it < 0 } ?: seq.last()

O problema é que ?: seq.last()não funciona porque quando o tempo firstOrNullretorna nulo, toda a sequência já foi consumida.

Posso fazer isso iterativamente, mas preferiria uma solução funcional.

kotlin

4 respostas

  1. Não acho que isso possa ser feito facilmente com as funções integradas porque last é um predicado especial.

    Adaptar o existente lastOrNullpara testar a primeira ocorrência de um predicado ( it < 0) ficaria assim:

    inline fun <T> Sequence<T>.firstOrLastOrNull(predicate: (T) -> Boolean): T? {
    var last: T? = null
    for (element in this) {
        if (predicate(element)) return element
        last = element
    }
    return last
}

    Agora você pode usar seq.firstOrLastOrNull { it < 0 }para conseguir o que deseja. Isso não deve ser diferente, em termos de desempenho, das funções integradas.

    Você pode considerar usar um nome mais descritivo para essa função.

    • 1
  2. Best Answer

    Você pode usar fold()uma classe de dados simples que contém seu valor mais um sinalizador indicando se você ainda está no modo "obter o último" ou já no modo "encontrei um valor inválido, vamos mantê-lo":

    data class Elem(val value: Int, val valid: Boolean)

fun main() {
    val seq = sequenceOf(1, 2, -3, 4, 5, /* ... */)
    val initial = Elem(0, true)
    val lastUnlessInvalidElementPresent = seq.fold(Elem(0, true), 
       { acc, item -> if (acc.valid && item < 0) { Elem(item, false) }   // first invalid element
                      else if (acc.valid) { Elem(item, true) } // valid element, keep looking
                      else { acc } // already found an invalid element - keep it
       }
    )
    println(lastUnlessInvalidElementPresent)
}

    Essa abordagem tem duas desvantagens:

    • ainda consumirá fold()a sequência completa mesmo depois de encontrar um elemento inválido
    • você precisa de um elemento "padrão" sensato para inicializar seu valor

    Parque infantil

    • 0

  3. No final, encontrei minha própria solução sucinta:

    fun <T> Sequence<T>.firstMatchOrLastOrNull(predicate: (T) -> Boolean): T? {
    var last: T? = null
    return onEach { last = it }.firstOrNull(predicate) ?: last
}

fun main() {
    println(sequenceOf(1, 2, -3, 4, 5).firstMatchOrLastOrNull { it < 0 }) // -3
    println(sequenceOf(1, 2, 3, 4, 5).firstMatchOrLastOrNull { it < 0 })  // 5
}

    É quase funcional, mas não é puramente funcional porque usa uma variável mutável.

    • 0 
  4. fun <T> Sequence<T>.firstMatchOrLastOrNull(predicate: (T) -> Boolean): T? {
  return this.find(predicate) ?: this.lastOrNull()
}

println(sequenceOf(1, 2, -3, 4, 5).firstMatchOrLastOrNull { it < 0 })   // -3
println(sequenceOf(1, 2, 3, 4, 5).firstMatchOrLastOrNull { it < 0 })    // 5
println(sequenceOf<Int>().firstMatchOrLastOrNull { it < 0 })            // null
    • 0

relate perguntas