无需查找的快速独特组合（来自重复列表）
FAST unique combinations (from list with duplicates) WITHOUT LOOKUPS
我似乎尽管网上有很多算法和函数可以从独特的项目列表中生成任意大小的独特组合，但在列表的情况下 none 可用非唯一项目（即包含相同值重复项的列表。）
The question is how to generate ON-THE-FLY in a generator function all
the unique combinations from a non-unique list without the
computational expensive need of filtering out duplicates?
现在，由于对这个问题有赏金动机的回答，所以更容易更清楚地说明我期望实现的目标：
首先让我们提供代码来说明如何检查组合 comboB 是否被认为是另一个组合 (comboA) 的重复：
comboA = [1,2,2]
comboB = [2,1,2]
print("B is a duplicate of A:", comboA.sort()==comboB.sort())
在给定的示例中，B 是 A 的副本，并且 print() 打印 True。
获得能够在非唯一列表的情况下即时提供唯一组合的生成器函数的问题已在此处解决：，但提供的生成器函数需要查找并需要内存什么在大量组合的情况下会导致问题。
当前版本的答案提供功能无需任何查找即可完成工作，似乎是这里的正确答案，但是......
摆脱查找的目的是在列表重复的情况下加快唯一组合的生成。
我最初（写这个问题的第一个版本）错误地假设不需要创建用于确保唯一性的查找的集合的代码有望比需要查找的代码更有优势。 事实并非如此。至少并非总是如此。到目前为止提供的答案中的代码不使用查找，但在没有冗余列表或列表中只有少数冗余项的情况下需要花费更多时间来生成所有组合。
这里用一些时间来说明当前的情况：
-----------------
k: 6 len(ls): 48
Combos Used Code Time
---------------------------------------------------------
12271512 len(list(combinations(ls,k))) : 2.036 seconds
12271512 len(list(subbags(ls,k))) : 50.540 seconds
12271512 len(list(uniqueCombinations(ls,k))) : 8.174 seconds
12271512 len(set(combinations(sorted(ls),k))): 7.233 seconds
---------------------------------------------------------
12271512 len(list(combinations(ls,k))) : 2.030 seconds
1 len(list(subbags(ls,k))) : 0.001 seconds
1 len(list(uniqueCombinations(ls,k))) : 3.619 seconds
1 len(set(combinations(sorted(ls),k))): 2.592 seconds
以上时间说明了两个极端：没有重复和只有重复。所有其他时间都在这两者之间。
我对以上结果的解释是纯 Python 函数（没有 itertools 或其他 C 编译模块）可以非常快，但也可能慢得多，具体取决于其中有多少重复项一个列表。因此，可能没有办法为 Python.so 扩展模块编写 C++ 代码来提供所需的功能。
您可以预处理输入列表，而不是 post-processing/filtering 您的输出。这样，您可以首先避免生成重复项。预处理涉及对输入进行排序（或使用 collections.Counter）。一种可能的递归实现是：
def subbags(bag, k):
a = sorted(bag)
n = len(a)
sub = []
def index_of_next_unique_item(i):
j = i + 1
while j < n and a[j] == a[i]:
j += 1
return j
def combinate(i):
if len(sub) == k:
yield tuple(sub)
elif n - i >= k - len(sub):
sub.append(a[i])
yield from combinate(i + 1)
sub.pop()
yield from combinate(index_of_next_unique_item(i))
yield from combinate(0)
bag = [1, 2, 3, 1, 2, 1]
k = 3
i = -1
print(sorted(bag), k)
print('---')
for i, subbag in enumerate(subbags(bag, k)):
print(subbag)
print('---')
print(i + 1)
输出：
[1, 1, 1, 2, 2, 3] 3
---
(1, 1, 1)
(1, 1, 2)
(1, 1, 3)
(1, 2, 2)
(1, 2, 3)
(2, 2, 3)
---
6
递归需要一些堆栈 space，但是这种 + 对输入进行排序应该比生成和丢弃重复使用更少的时间 + 内存。
目前最先进的灵感最初来自 50 次而不是 100 次重复赏金（而不是完全用 C 编写的 Python 扩展模块）：
An efficient algorithm and implementation that is better than the obvious (set + combinations) approach in the best (and average) case, and is competitive with it in the worst case.
似乎可以使用一种 "fake it before you make it" 方法来满足此要求。目前最先进的是有两种生成器函数算法可用于解决在非唯一列表的情况下获得唯一组合的问题。下面提供的算法将它们结合起来成为可能，因为它似乎存在列表中唯一项目百分比的阈值，可用于在两种算法之间进行适当的切换。唯一性百分比的计算是用非常少的计算时间完成的，由于所采用的时间的常见变化，它甚至没有清楚地显示在最终结果中。
def iterFastUniqueCombos(lstList, comboSize, percUniqueThresh=60):
lstListSorted = sorted(lstList)
lenListSorted = len(lstListSorted)
percUnique = 100.0 - 100.0*(lenListSorted-len(set(lstListSorted)))/lenListSorted
lstComboCandidate = []
setUniqueCombos = set()
def idxNextUnique(idxItemOfList):
idxNextUniqueCandidate = idxItemOfList + 1
while (
idxNextUniqueCandidate < lenListSorted
and
lstListSorted[idxNextUniqueCandidate] == lstListSorted[idxItemOfList]
): # while
idxNextUniqueCandidate += 1
idxNextUnique = idxNextUniqueCandidate
return idxNextUnique
def combinate(idxItemOfList):
if len(lstComboCandidate) == sizeOfCombo:
yield tuple(lstComboCandidate)
elif lenListSorted - idxItemOfList >= sizeOfCombo - len(lstComboCandidate):
lstComboCandidate.append(lstListSorted[idxItemOfList])
yield from combinate(idxItemOfList + 1)
lstComboCandidate.pop()
yield from combinate(idxNextUnique(idxItemOfList))
if percUnique > percUniqueThresh:
from itertools import combinations
allCombos = combinations(lstListSorted, comboSize)
for comboCandidate in allCombos:
if comboCandidate in setUniqueCombos:
continue
yield comboCandidate
setUniqueCombos.add(comboCandidate)
else:
yield from combinate(0)
#:if/else
#:def iterFastUniqueCombos()
下面提供的时序表明上面的 iterFastUniqueCombos() 生成器函数提供了明显的优势
超过 uniqueCombinations() 个变体，以防列表中的唯一元素少于 60%，并且不比
基于 (set + combinations) 的 uniqueCombinations() 生成器函数在相反的情况下比 iterUniqueCombos() 快得多（由于在
(set + combinations) 和 (no lookups) 变体在列表中独特元素数量的 60% 阈值处：
=========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 1 percUnique 2
Combos: 12271512 print(len(list(combinations(lst,k)))) : 2.04968 seconds.
Combos: 1 print(len(list( iterUniqueCombos(lst,k)))) : 0.00011 seconds.
Combos: 1 print(len(list( iterFastUniqueCombos(lst,k)))) : 0.00008 seconds.
Combos: 1 print(len(list( uniqueCombinations(lst,k)))) : 3.61812 seconds.
========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 48 percUnique 100
Combos: 12271512 print(len(list(combinations(lst,k)))) : 1.99383 seconds.
Combos: 12271512 print(len(list( iterUniqueCombos(lst,k)))) : 49.72461 seconds.
Combos: 12271512 print(len(list( iterFastUniqueCombos(lst,k)))) : 8.07997 seconds.
Combos: 12271512 print(len(list( uniqueCombinations(lst,k)))) : 8.11974 seconds.
========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 27 percUnique 56
Combos: 12271512 print(len(list(combinations(lst,k)))) : 2.02774 seconds.
Combos: 534704 print(len(list( iterUniqueCombos(lst,k)))) : 1.60052 seconds.
Combos: 534704 print(len(list( iterFastUniqueCombos(lst,k)))) : 1.62002 seconds.
Combos: 534704 print(len(list( uniqueCombinations(lst,k)))) : 3.41156 seconds.
========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 31 percUnique 64
Combos: 12271512 print(len(list(combinations(lst,k)))) : 2.03539 seconds.
Combos: 1114062 print(len(list( iterUniqueCombos(lst,k)))) : 3.49330 seconds.
Combos: 1114062 print(len(list( iterFastUniqueCombos(lst,k)))) : 3.64474 seconds.
Combos: 1114062 print(len(list( uniqueCombinations(lst,k)))) : 3.61857 seconds.
我似乎尽管网上有很多算法和函数可以从独特的项目列表中生成任意大小的独特组合，但在列表的情况下 none 可用非唯一项目（即包含相同值重复项的列表。）
The question is how to generate ON-THE-FLY in a generator function all the unique combinations from a non-unique list without the computational expensive need of filtering out duplicates?
现在，由于对这个问题有赏金动机的回答，所以更容易更清楚地说明我期望实现的目标：
首先让我们提供代码来说明如何检查组合 comboB 是否被认为是另一个组合 (comboA) 的重复：
comboA = [1,2,2]
comboB = [2,1,2]
print("B is a duplicate of A:", comboA.sort()==comboB.sort())
在给定的示例中，B 是 A 的副本，并且 print() 打印 True。
获得能够在非唯一列表的情况下即时提供唯一组合的生成器函数的问题已在此处解决：
当前版本的答案提供功能无需任何查找即可完成工作，似乎是这里的正确答案，但是......
摆脱查找的目的是在列表重复的情况下加快唯一组合的生成。
我最初（写这个问题的第一个版本）错误地假设不需要创建用于确保唯一性的查找的集合的代码有望比需要查找的代码更有优势。 事实并非如此。至少并非总是如此。到目前为止提供的答案中的代码不使用查找，但在没有冗余列表或列表中只有少数冗余项的情况下需要花费更多时间来生成所有组合。
这里用一些时间来说明当前的情况：
-----------------
k: 6 len(ls): 48
Combos Used Code Time
---------------------------------------------------------
12271512 len(list(combinations(ls,k))) : 2.036 seconds
12271512 len(list(subbags(ls,k))) : 50.540 seconds
12271512 len(list(uniqueCombinations(ls,k))) : 8.174 seconds
12271512 len(set(combinations(sorted(ls),k))): 7.233 seconds
---------------------------------------------------------
12271512 len(list(combinations(ls,k))) : 2.030 seconds
1 len(list(subbags(ls,k))) : 0.001 seconds
1 len(list(uniqueCombinations(ls,k))) : 3.619 seconds
1 len(set(combinations(sorted(ls),k))): 2.592 seconds
以上时间说明了两个极端：没有重复和只有重复。所有其他时间都在这两者之间。
我对以上结果的解释是纯 Python 函数（没有 itertools 或其他 C 编译模块）可以非常快，但也可能慢得多，具体取决于其中有多少重复项一个列表。因此，可能没有办法为 Python.so 扩展模块编写 C++ 代码来提供所需的功能。
您可以预处理输入列表，而不是 post-processing/filtering 您的输出。这样，您可以首先避免生成重复项。预处理涉及对输入进行排序（或使用 collections.Counter）。一种可能的递归实现是：
def subbags(bag, k):
a = sorted(bag)
n = len(a)
sub = []
def index_of_next_unique_item(i):
j = i + 1
while j < n and a[j] == a[i]:
j += 1
return j
def combinate(i):
if len(sub) == k:
yield tuple(sub)
elif n - i >= k - len(sub):
sub.append(a[i])
yield from combinate(i + 1)
sub.pop()
yield from combinate(index_of_next_unique_item(i))
yield from combinate(0)
bag = [1, 2, 3, 1, 2, 1]
k = 3
i = -1
print(sorted(bag), k)
print('---')
for i, subbag in enumerate(subbags(bag, k)):
print(subbag)
print('---')
print(i + 1)
输出：
[1, 1, 1, 2, 2, 3] 3
---
(1, 1, 1)
(1, 1, 2)
(1, 1, 3)
(1, 2, 2)
(1, 2, 3)
(2, 2, 3)
---
6
递归需要一些堆栈 space，但是这种 + 对输入进行排序应该比生成和丢弃重复使用更少的时间 + 内存。
目前最先进的灵感最初来自 50 次而不是 100 次重复赏金（而不是完全用 C 编写的 Python 扩展模块）：
An efficient algorithm and implementation that is better than the obvious
(set + combinations)approach in the best (and average) case, and is competitive with it in the worst case.
似乎可以使用一种 "fake it before you make it" 方法来满足此要求。目前最先进的是有两种生成器函数算法可用于解决在非唯一列表的情况下获得唯一组合的问题。下面提供的算法将它们结合起来成为可能，因为它似乎存在列表中唯一项目百分比的阈值，可用于在两种算法之间进行适当的切换。唯一性百分比的计算是用非常少的计算时间完成的，由于所采用的时间的常见变化，它甚至没有清楚地显示在最终结果中。
def iterFastUniqueCombos(lstList, comboSize, percUniqueThresh=60):
lstListSorted = sorted(lstList)
lenListSorted = len(lstListSorted)
percUnique = 100.0 - 100.0*(lenListSorted-len(set(lstListSorted)))/lenListSorted
lstComboCandidate = []
setUniqueCombos = set()
def idxNextUnique(idxItemOfList):
idxNextUniqueCandidate = idxItemOfList + 1
while (
idxNextUniqueCandidate < lenListSorted
and
lstListSorted[idxNextUniqueCandidate] == lstListSorted[idxItemOfList]
): # while
idxNextUniqueCandidate += 1
idxNextUnique = idxNextUniqueCandidate
return idxNextUnique
def combinate(idxItemOfList):
if len(lstComboCandidate) == sizeOfCombo:
yield tuple(lstComboCandidate)
elif lenListSorted - idxItemOfList >= sizeOfCombo - len(lstComboCandidate):
lstComboCandidate.append(lstListSorted[idxItemOfList])
yield from combinate(idxItemOfList + 1)
lstComboCandidate.pop()
yield from combinate(idxNextUnique(idxItemOfList))
if percUnique > percUniqueThresh:
from itertools import combinations
allCombos = combinations(lstListSorted, comboSize)
for comboCandidate in allCombos:
if comboCandidate in setUniqueCombos:
continue
yield comboCandidate
setUniqueCombos.add(comboCandidate)
else:
yield from combinate(0)
#:if/else
#:def iterFastUniqueCombos()
下面提供的时序表明上面的 iterFastUniqueCombos() 生成器函数提供了明显的优势
超过 uniqueCombinations() 个变体，以防列表中的唯一元素少于 60%，并且不比
基于 (set + combinations) 的 uniqueCombinations() 生成器函数在相反的情况下比 iterUniqueCombos() 快得多（由于在
(set + combinations) 和 (no lookups) 变体在列表中独特元素数量的 60% 阈值处：
=========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 1 percUnique 2
Combos: 12271512 print(len(list(combinations(lst,k)))) : 2.04968 seconds.
Combos: 1 print(len(list( iterUniqueCombos(lst,k)))) : 0.00011 seconds.
Combos: 1 print(len(list( iterFastUniqueCombos(lst,k)))) : 0.00008 seconds.
Combos: 1 print(len(list( uniqueCombinations(lst,k)))) : 3.61812 seconds.
========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 48 percUnique 100
Combos: 12271512 print(len(list(combinations(lst,k)))) : 1.99383 seconds.
Combos: 12271512 print(len(list( iterUniqueCombos(lst,k)))) : 49.72461 seconds.
Combos: 12271512 print(len(list( iterFastUniqueCombos(lst,k)))) : 8.07997 seconds.
Combos: 12271512 print(len(list( uniqueCombinations(lst,k)))) : 8.11974 seconds.
========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 27 percUnique 56
Combos: 12271512 print(len(list(combinations(lst,k)))) : 2.02774 seconds.
Combos: 534704 print(len(list( iterUniqueCombos(lst,k)))) : 1.60052 seconds.
Combos: 534704 print(len(list( iterFastUniqueCombos(lst,k)))) : 1.62002 seconds.
Combos: 534704 print(len(list( uniqueCombinations(lst,k)))) : 3.41156 seconds.
========== sizeOfCombo: 6 sizeOfList: 48 noOfUniqueInList 31 percUnique 64
Combos: 12271512 print(len(list(combinations(lst,k)))) : 2.03539 seconds.
Combos: 1114062 print(len(list( iterUniqueCombos(lst,k)))) : 3.49330 seconds.
Combos: 1114062 print(len(list( iterFastUniqueCombos(lst,k)))) : 3.64474 seconds.
Combos: 1114062 print(len(list( uniqueCombinations(lst,k)))) : 3.61857 seconds.