Does anyone have an idiomatic way of checking if the last `n` elements of a list are the same? Curre...

# announcements

[Marcin Wisniowski]

Does anyone have an idiomatic way of checking if the last n elements of a list are the same? Currently I have list.takeLast(n).toSet().size == 1 but I think this could be simpler.

[Kroppeb]

toSet() won't stop once it finds an element that is different and will use O(n) space.

[Marcin Wisniowski]

True, maybe list.takeLast(n).all { it == list.last() } is better.

[Marcin Wisniowski]

But it still unnecessarily compares the last element to itself.

[Kroppeb]

You could put it in an extension function if it's a thing you need more often.

[Kroppeb]

If you really hate the fact it compares the last element with itself, you could take a sublist that doesn't contain the last element, but it won't make that much of a difference.

[molikuner]

list.takeLast(n).dropLast(1).all { it == list.last() }

[todd.ginsberg]

list.takeLast(n).distinct().size == 1 seems like a nice way to express it.

[karelpeeters]

Except that's slower than toSet() for no reason, distinct() = toSet().toList()

[todd.ginsberg]

Yeah, that's fair.

[todd.ginsberg]

It's easier to read though, I feel.

[pablisco]

You could overload the default all to something like:

fun <T> List<T>.all(from: Int = 0, f: (T, T) -> Boolean): Boolean {
    for(i in from until (size-1)) if(!f(get(i), get(i + 1))) return false;
    return true
}

Highly efficient (although not pretty). Then you can use it like:

list.all(from = n) { a, b -> a == b }

I personally would go with the distinct solution if efficiency is not an issue. This is just a different option.

[Derek Peirce]

Try !list.takeLast(n).asSequence().distinct().drop(1).any(), the laziness of sequences will prevent any unnecessary comparisons, and will only store as much as is necessary.