python从两个单独的列表中计算对，列表中没有唯一的值（我认为集合不起作用）

如果以前有人问过这个问题，请原谅，但我找不到答案。 我想在两个单独的列表中计算这些对。每对都包括重复项（这就是为什么我认为集合不起作用的原因），例如：

fun(A, B):
   return count

if A = [1 1 0 0] and B = [1 2 2 1]
returns 2 and not 1
if A = [1 1 0 0] and B = [1 3 3 3]
returns 1
if A = [1 2 2 0] and B = [1 3 2 2]
returns 3

具体来说，我做了一个智囊团类型的游戏，这是为了计算正确的颜色错误的斑点总数（正确的颜色正确的斑点从列表中删除后）

这是我目前拥有的，但它似乎不是很像蟒蛇

def count_func(A,B)       
    count = 0
       for b in reversed(B):
           used = False
           for a in reversed(A):
               if b == a and not used:
                        A.remove(b) #remove that from list
                        B.remove(b)
                        count += 1
                        used = True
    return count

顺便说一下，我正在使用Python 3。谢谢你的帮助，如果之前有人回答过，请告诉我

编辑：

---

更正了第二个示例并试图澄清

您可以删除布尔值“used”和字符串的反转：

def count_func(A,B):
    count = 0
    for b in B:
        for a in A:
            if b == a:
             A.remove(a)
             count += 1
             break
return count

---

您可以删除布尔值“used”和字符串的反转：

def count_func(A,B):
    count = 0
    for b in B:
        for a in A:
            if b == a:
             A.remove(a)
             count += 1
             break
return count

---

看起来您正在尝试获取A和B之间的重叠大小，包括重复输入

如果我理解正确，您可以从

集合

模块使用Python的

计数器。
计数器
获取一个列表，并创建一个从列表中的每个条目到它出现频率的映射

from collections import Counter

def func(A, B):
    a = Counter(A)
    b = Counter(B)
    count = 0
    for key in a:
        count += min(a[key], b[key])

    return count

这在
O（n）
时间内运行，其中
n=max（len（A），len（B））
看起来您正在尝试获取A和B之间的重叠大小，包括重复条目

如果我理解正确，您可以从
集合
模块使用Python的
计数器。
计数器
获取一个列表，并创建一个从列表中的每个条目到它出现频率的映射

from collections import Counter

def func(A, B):
    a = Counter(A)
    b = Counter(B)
    count = 0
    for key in a:
        count += min(a[key], b[key])

    return count

这在
O（n）
时间内运行，其中
n=max（len（A），len（B））
在Python中更快的实现是：

def count_pairs(A, B):
    a, b = sorted(A), sorted(B)
    i = j = 0
    count = 0
    while i<len(a) and j<len(b):
        if a[i]==b[j]:
            count += 1
            i += 1
            j += 1
        elif a[i]<b[j]:
            i += 1
        else:   # a[i]>b[j]
            j += 1
    return count

def计数对（A、B）：
a、 b=已排序（a），已排序（b）
i=j=0
计数=0
而在Python中更快的实现是：

def count_pairs(A, B):
    a, b = sorted(A), sorted(B)
    i = j = 0
    count = 0
    while i<len(a) and j<len(b):
        if a[i]==b[j]:
            count += 1
            i += 1
            j += 1
        elif a[i]<b[j]:
            i += 1
        else:   # a[i]>b[j]
            j += 1
    return count

def计数对（A、B）：
a、 b=已排序（a），已排序（b）
i=j=0
计数=0
而我在两个列表中的配对背后的逻辑是什么？真的不清楚，这个应该返回1而不是0吗？如果A=[1 1 0 0]和B=[3 3 3]，则返回1计算
（x，y）
的所有对，例如A中的
x
，
B中的
y
和
x==y
。两个列表中的对背后的逻辑是什么？真的不清楚，这个应该返回1而不是0吗？如果A=[1 1 0 0]和B=[3 3]，则返回1的想法是计算所有
（x，y）
，这样
A中的x
，
B中的y
和
x==y
。谢谢你所说的[key]是什么意思？我得到一个关于key未定义的错误，它代表什么吗？抱歉，我想在for循环中使用key:）非常好！但是你错了：第二种情况的正确答案是1，你自己的代码也这么说：）哎呀，没有看到第二个列表中的1！听起来不错，希望有帮助。这是一个编辑。谢谢，虽然这确实有效。谢谢你说的[key]是什么意思我得到一个关于key未定义的错误它代表什么吗？抱歉，我想在for循环中使用key:）非常好！但是你错了：第二种情况的正确答案是1，你自己的代码也这么说：）哎呀，没有看到第二个列表中的1！听起来不错，希望有帮助。这是一个编辑。谢谢，虽然这确实有效。这是正确的，但不是最佳的。它会给你O（N**2）的复杂度，所以对于大的列表，它的工作速度会很慢。反过来，在for循环中保持正确的索引不是很有必要吗？布尔值只是因为我很难打破for循环，但这是不必要的。不，因为在“for b in b”的每次迭代中，在调用“for a in a”时都会重新读取数组a。例如：for b in b:#[1,2,3]b=1 for a:#[2,1,3]a=2如果b==a:#1！=如果b==a:[1，2，3]b=1，如果b==a:[1，1，3]a=1.remove（a）#remove 1，a=[2，3]break#不再在a循环中的a中，但仍然在b循环中的b中：#[1，2，3]b=2对于a循环中的a，a现在被评估为a=[2，3]a=2这是正确的，但不是最优的。它会给你O（N**2）的复杂度，所以对于大的列表，它的工作速度会很慢。反过来，在for循环中保持正确的索引不是很有必要吗？布尔值只是因为我很难打破for循环，但这是不必要的。不，因为在“for b in b”的每次迭代中，在调用“for a in a”时都会重新读取数组a。例如：for b in b:#[1,2,3]b=1 for a:#[2,1,3]a=2如果b==a:#1！=如果b==a:[1，2，3]b=1，b=1，如果b==a:[1，1，3]a=1。删除（a）#删除1，a=[2，3]中断#不再在a的循环中，但在b的循环中仍然在b的循环中#[1，2，3]b=2，在a的循环中a现在被评估为a=[2，3]和a=2