创建一个保留重复值的列表的补充

Question

给定列表a = [1, 2, 2, 3] 及其子列表b = [1, 2] 找到一个以sorted(a) == sorted(b + complement) 的方式补充b 的列表。在上面的示例中，complement 将是[2, 3] 的列表。

使用列表推导很诱人：

complement = [x for x in a if x not in b]

或设置：

complement = list(set(a) - set(b))

但是，这两种方式都会返回complement = [3]。

一个明显的方法是：

complement = a[:]
for element in b:
    complement.remove(element)

但这让人非常不满意，而且不是很Pythonic。我错过了一个明显的成语还是这样？

正如下面指出的那样，性能如何，这是O(n^2) 有没有更有效的方法？

Answer 1

我想到的唯一更多声明性因此Pythonic的方式并且提高了大型b（和@987654322）的性能 @) 是使用某种递减计数器：

from collections import Counter

class DecrementCounter(Counter):

    def decrement(self,x):
        if self[x]:
            self[x] -= 1
            return True
        return False

现在我们可以使用列表推导：

b_count = DecrementCounter(b)
complement = [x for x in a if not b_count.decrement(x)]

因此，我们在这里跟踪b 中的计数，对于a 中的每个元素，我们查看它是否是b_count 的一部分。如果确实如此，我们会减少计数器并忽略该元素。否则我们将它添加到complement。请注意，这只有在我们确定这样的complement 存在时才有效。

在你构造了complement之后，你可以检查补码是否存在：

not bool(+b_count)

如果这是False，则无法构造此类补码（例如a=[1] 和b=[1,3]）。所以一个完整的实现可能是：

b_count = DecrementCounter(b)
complement = [x for x in a if not b_count.decrement(x)]
if +b_count:
    raise ValueError('complement cannot be constructed')

如果字典查找在 O(1) 中运行（它通常这样做，只有在极少数情况下它是 O(n)），那么这个算法在 O(n) 中运行em>O(|a|+|b|) （即列表大小的总和）。而remove 方法通常会在O(|a|×|b|)中运行。

Answer 2

为了降低您已经有效的方法的复杂性，您可以使用collections.Counter（这是一个具有快速查找功能的专用字典）来计算两个列表中的项目。

然后通过减去值来更新计数，最后通过仅保留计数大于 0 的项目过滤列表并使用itertools.chain 重建它/链接它

from collections import Counter
import itertools

a  = [1, 2, 2, 2, 3]
b = [1, 2]

print(list(itertools.chain.from_iterable(x*[k] for k,x in (Counter(a)-Counter(b)).items() if x > 0)))

结果：

[2, 2, 3]

Answer 3

O(n log n)

a = [1, 2, 2, 3]
b = [1, 2]
a.sort()
b.sort()

L = []
i = j = 0
while i < len(a) and j < len(b):
    if a[i] < b[j]:
        L.append(a[i])
        i += 1
    elif a[i] > b[j]:
        L.append(b[j])
        j += 1
    else:
        i += 1
        j += 1

while i < len(a):
    L.append(a[i])
    i += 1

while j < len(b):
    L.append(b[j])
    j += 1

print(L)

Answer 4

如果补语中元素的顺序无关紧要，那么只需要 collections.Counter：

from collections import Counter

a = [1, 2, 3, 2]
b = [1, 2]

complement = list((Counter(a) - Counter(b)).elements())  # complement = [2, 3]

如果补语中的项目顺序应与原始列表中的顺序相同，则使用以下内容：

from collections import Counter, defaultdict
from itertools import count

a = [1,2,3,2]
b = [2,1]

c = Counter(b)
d = defaultdict(count)

complement = [x for x in a if next(d[x]) >= c[x]]  # complement = [3, 2]

Answer 5

主要思想：如果值不唯一，则使其唯一

def add_duplicate_position(items):
    element_counter = {}
    for item in items:
        element_counter[item] = element_counter.setdefault(item,-1) + 1
        yield element_counter[item], item
    
assert list(add_duplicate_position([1, 2, 2, 3])) == [(0, 1), (0, 2), (1, 2), (0, 3)]

def create_complementary_list_with_duplicates(a,b):
    a = list(add_duplicate_position(a))
    b = set(add_duplicate_position(b))
    return [item for _,item in [x for x in a if x not in b]]
  
a = [1, 2, 2, 3]
b = [1, 2]
assert create_complementary_list_with_duplicates(a,b) == [2, 3]