БЫСТРЫЕ уникальные комбинации (из списка с дубликатами) БЕЗ ЛУКОВ

Ответ 1

Вместо последующей обработки/фильтрации вашего вывода вы можете предварительно обработать свой список ввода. Таким образом, вы можете избежать генерации дубликатов в первую очередь. Предварительная обработка включает в себя либо сортировку (или использование collections.Counter on) ввода. Возможна одна рекурсивная реализация:

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

Требуется некоторое пространство стека для рекурсии, но при этом + сортировка ввода должна использовать существенно меньшее время + память, чем генерация и отбрасывание повторов.

Ответ 2

Современное состояние, вдохновленное первоначально 50, а не 100-кратным бонусами, на данный момент (вместо модуля расширения Python, полностью написанного на C):

Эффективный алгоритм и реализация, который лучше, чем очевидный подход (set + combinations) в лучшем (и среднем) случае, и конкурирует с ним в худшем случае.

Кажется, что можно выполнить это требование, используя своего рода "подделку, прежде чем вы сделаете это". Современное состояние дел состоит в том, что для решения проблемы получения уникальных комбинаций в случае неуникального списка существует два алгоритма функции генератора. Приведенный ниже алгоритм объединяет оба из них, что становится возможным, поскольку, по-видимому, существует пороговое значение для процента уникальных элементов в списке, которое может использоваться для соответствующего переключения между двумя алгоритмами. Расчет процента уникальности производится с таким крошечным количеством времени вычисления, что он даже явно не проявляется в конечных результатах из-за общей вариации принятого времени.

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() обеспечивает явное преимущество over uniqueCombinations() в случае, если список содержит менее 60 процентов уникальных элементов и не хуже, чем на функции (set + combinations) на основе (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.