Collections 在Kotlin中保持重复值的两个列表的交集

我希望在不消除重复项的情况下找到两个列表之间的公共元素数

例如：

---

输入：

[1,3,3]

&

[4,3,3]

输出：

2

，因为公共元素是

[3,3]

---

输入：

[1,2,3]

&

[4,3,3]

输出：

1

，因为公共元素是

[3]

---

如果我使用Kotlin集合，结果是一个集合，这将阻止我计算重复值

我发现（对于Python），它以不同的方式处理重复项，这使我使用了实现，其中

a

和

b

是以下列表：

val aCounts = a.groupingBy { it }.eachCount()
val bCounts = b.groupingBy { it }.eachCount()
var intersectionCount = 0;
for ((k, v) in aCounts) {
    intersectionCount += Math.min(v, bCounts.getOrDefault(k, 0))
}

然而，作为Kotlin的新手，我想知道是否有一种更“Kotlin-y”的方式来实现这一点——利用Kotlin的所有集合功能？可能是避免显式迭代的方法？

这：

val a = listOf(1, 2, 3, 3, 4, 5, 5, 5, 6)
val b = listOf(1, 3, 3, 3, 4, 4, 5, 6, 6, 7)

var counter = 0

a.intersect(b).forEach { x -> counter += listOf(a.count {it == x}, b.count {it == x}).min()!! }

println(counter)

将打印

6

它使用两个列表的交集，并通过迭代其每个项目，将两个列表中项目的最小出现次数添加到计数器中。

通过此导入：

import kotlin.math.min

您可以避免在每次迭代时创建列表，并简化为：

a.intersect(b).forEach { x-> counter += min(a.count {it == x}, b.count {it == x}) } 

由Arjan提供，一种更优雅的计算方法：

val result = a.intersect(b).map { x -> min(a.count {it == x}, b.count {it == x}) }.sum()

---

从两个或多个arraylist获取公共元素

输入

• a={1,2,2,4,5,6}
• b={1,2,2,4,5,6}
• c={1,2,2,4,6}

输出={1,2,2,4,6}

fun main() {

val array = ArrayList<ArrayList<String>>()

val arr1 = arrayListOf("1", "2", "2", "4", "5", "6")
val arr2 = arrayListOf("1", "2", "2", "4", "5", "6")
val arr3 = arrayListOf("1", "2", "2", "4", "6")

array.add(arr1)
array.add(arr2)
array.add(arr3)


println(getCommonElements(array)) }

获取公共元素的算法

fun getCommonElements(arrayList: ArrayList<ArrayList<String>>): ArrayList<String> {

val commonElements = ArrayList<String>()
var isContain = true
val firstArray = arrayList[0]

val indexArray = ArrayList<IndexArray>()

// for loop for firstArray
for (e in firstArray) {

    var elementIndex: Int
    var arrayIndex: Int

    // for loop for next ArrayList
    for (i in 1 until arrayList.size) {

        if (!arrayList[i].contains(e)) {
            isContain = false
            break

        } else {
            elementIndex = arrayList[i].indexOf(e)
            arrayIndex = i

            indexArray.add(IndexArray(arrayIndex, elementIndex))
        }
    }

    if (isContain) {
        commonElements.add(e)

        // remove element
        for (i in 0 until indexArray.size) {
            arrayList[indexArray[i].arrayIndex].removeAt(indexArray[i].elementIndex)
        }

        indexArray.clear()

    } else {
        indexArray.clear()
        isContain = true
    }


}

return commonElements }

有趣的getCommonElements（arrayList:arrayList）：arrayList{ val commonElements=ArrayList（） var isContain=true val firstArray=arrayList[0] val indexArray=ArrayList（） //firstArray的for循环 for（第一个数组中的e）{ 变量元素索引：Int var arrayIndex:Int //下一个ArrayList的for循环 for（在arrayList.size之前的1中输入i）{ 如果（！arrayList[i].包含（e））{ isContain=false 打破 }否则{ elementIndex=arrayList[i].indexOf（e） arrayIndex=i 添加（indexArray（arrayIndex，elementIndex）） } } 如果（包含）{ commonElements.add（e） //删除元素 用于（i在0中直到indexArray.size）{ arrayList[indexArray[i].arrayIndex].removeAt（indexArray[i].elementIndex） } indexArray.clear（） }否则{ indexArray.clear（） isContain=true } } 返回commonElements}

---

它可以做得更短，而不需要一个计数器变量：

val result=a.intersect（b）.map{x->min（a.count{It==x}，b.count{It==x}）}.sum（）

我同意它更优雅，但性能相同。不管怎样，你想让我把它包括在答案中吗（当然我会提到你）。当然，你可以在你的答案中提到它。一个好处是它只使用值，而不是可能会意外更改的变量。因为它不使用单独的结果值，所以它还允许我们创建一个单行函数。这就是为什么我认为它更优雅。有趣，谢谢！Kotlin！它的缺点是迭代

a

和

b

以查找

a.intersect（b）

中每个元素的计数。例如，如果

a

和

b

在0和100000之间包含100000个随机整数，则采用原始问题的方法

fun getCommonElements(arrayList: ArrayList<ArrayList<String>>): ArrayList<String> {

val commonElements = ArrayList<String>()
var isContain = true
val firstArray = arrayList[0]

val indexArray = ArrayList<IndexArray>()

// for loop for firstArray
for (e in firstArray) {

    var elementIndex: Int
    var arrayIndex: Int

    // for loop for next ArrayList
    for (i in 1 until arrayList.size) {

        if (!arrayList[i].contains(e)) {
            isContain = false
            break

        } else {
            elementIndex = arrayList[i].indexOf(e)
            arrayIndex = i

            indexArray.add(IndexArray(arrayIndex, elementIndex))
        }
    }

    if (isContain) {
        commonElements.add(e)

        // remove element
        for (i in 0 until indexArray.size) {
            arrayList[indexArray[i].arrayIndex].removeAt(indexArray[i].elementIndex)
        }

        indexArray.clear()

    } else {
        indexArray.clear()
        isContain = true
    }


}

return commonElements }