Functional way of checking if a list of list has duplicate elements - kotlin

Question

I have a list of list of elements, and would like to check if there are any duplicates. I would also like to break early - I don't care what the duplicates are, nor if there are many of them, I just want to know if there is at least one.
An imperative way which fits the bill would be:
fun main() {
println(hasDuplicates(listOf(
listOf("1", "2", "3"),
listOf("4", "5"),
listOf("1", "2")
)))
}
fun hasDuplicates(input: List<List<String>>): Boolean {
val seen = mutableSetOf<String>()
input.forEach { inner ->
inner.forEach { element ->
if (!seen.add(element)) {
return true
}
}
}
return false
}
Another way, without explicit iteration, would be:
fun hasDuplicates(input: List<List<String>>): Boolean {
val flat = input.flatten()
return flat.size != flat.toSet().size
}
but this iterates the whole list, and even creates a flattened intermediary in the first step.
I have an idea, but don't know how to implement it: suppose I could map each (flattened) list element to the number of times it has already be seen. I have this so far:
fun hasDuplicates(input: List<List<String>>): Boolean {
return input.asSequence().flatten()
// .onEach {
// println("getting $it")
// }
.groupingBy { it }
.eachCount()
.any { (_, count) -> count > 1 }
}
It does what it should but it first iterates the whole list (uncomment the onEach intermediary to see) to collect the groups. The idea would incrementally emit the element and its count, like (for input list ["1", "2", "1"]:
// (element, seenCount)
("1", 0)
("2", 0)
("1", 1)
at which point I could simply check for seenCount > 0 and return early.
Any help? Any other ideas are also welcome.
UPDATE: Got this, not really the initial idea, but seems to work:
fun hasDuplicates(input: List<List<String>>): Boolean {
input.asSequence().flatten()
.onEach {
println("getting $it")
}
.fold(mutableSetOf<String>()) { seen, element ->
if (!seen.add(element)) {
return true
}
seen
}
return false
}
The above code performs slightly worse than the very first version with loops in the worst cade (no duplicates), pretty much the same in the best case (second element is the duplicate) and in the 'medium' case (middle element of the flattened list is a duplicate).

Answer 1

The idea described in the question can be implemented the following way:
fun hasDuplicates(input: List<List<String>>): Boolean {
input.asSequence().flatten()
// .onEach {
// println("getting $it")
// }
.groupingBy { it }
.aggregate { _, _: Int?, _, first ->
if (first) {
1
} else {
return true
}
}
return false
}
The type of the accumulator (Int? above) doesn't matter as it is unused.
But, the following solution is even better for me, as it allows me to return the set in the case that all is unique, which I need later:
fun uniqueOrNull(input: List<List<String>>): Set<String>? {
return input.asSequence().flatten()
.fold(mutableSetOf()) { seen, element ->
if (!seen.add(element)) {
return null
}
seen
}
}
Using aggregate would also work, but performs negligibly worse and is more complicated to the reader:
fun uniqueOrNull(input: List<List<String>>): Set<String>? {
return input.asSequence().flatten()
.groupingBy { it }
.aggregate { _, _: Int?, _, first ->
if (first) {
1
} else {
return null
}
}.keys
}