Kotlin 检查列表是否有重复元素的功能方法

我有一个元素列表，并想检查是否有任何重复。我还想早点休息——我不在乎复制品是什么，也不在乎是否有很多，我只想知道是否至少有一个

符合该法案的一个必要方法是：

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
}

fun hasDuplicates(input: List<List<String>>): Boolean {
    val flat = input.flatten()
    return flat.size != flat.toSet().size
}

在这一点上，我可以简单地检查

seenCount>0

并提前返回

有什么帮助吗？任何其他想法都是受欢迎的

更新：明白了，这不是最初的想法，但似乎可行：

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
}

fun具有重复项（输入：列表）：布尔值{
input.asSequence（）.flatte（）
奥纳赫先生{
println（“获取$it”）
}
.fold（mutableSetOf（））{seen，元素->
如果（！seen.add（元素））{
返回真值
}
看到
}
返回错误
}

---

上述代码的性能比第一个版本稍差，循环处于最差的cade（没有重复），在最佳情况下（第二个元素是重复的）和“中等”情况下（展平列表的中间元素是重复的）几乎相同.

问题中描述的想法可以通过以下方式实现：

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
}

使用

aggregate

也会起作用，但性能差得可以忽略，而且对读者来说更复杂：

fun uniqueOrNull(input: List<List<String>>): Set<String>? {
    return input.asSequence().flatten()
        .groupingBy { it }
        .aggregate { _, _: Int?, _, first ->
            if (first) {
                1
            } else {
                return null
            }
        }.keys
}

fun uniqueOrNull（输入：列表）：设置？{
返回input.asSequence（）.flatte（）
.groupingBy{it}
.aggregate{{}，{u:Int？，{u，first->
如果（第一）{
1.
}否则{
返回空
}
}.钥匙
}

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
}

fun uniqueOrNull(input: List<List<String>>): Set<String>? {
    return input.asSequence().flatten()
        .fold(mutableSetOf()) { seen, element ->
            if (!seen.add(element)) {
                return null
            }
            seen
        }
}

fun uniqueOrNull(input: List<List<String>>): Set<String>? {
    return input.asSequence().flatten()
        .groupingBy { it }
        .aggregate { _, _: Int?, _, first ->
            if (first) {
                1
            } else {
                return null
            }
        }.keys
}