Python-Kombinationen ohne Wiederholungen

Ich habe eine Liste von zahlen, und ich möchte, um Kombinationen daraus. Wenn ich die Liste:

t = [2,2,2,2,4]
c = list(itertools.combinations(t, 4))

Ist das Ergebnis:

(2, 2, 2, 2)
(2, 2, 2, 4)
(2, 2, 2, 4)
(2, 2, 2, 4)
(2, 2, 2, 4)

aber ich will:

(2, 2, 2, 2)
(2, 2, 2, 4)

Ist es möglich, Duplikate zu beseitigen, außer neue Liste und gehen durch die erste Liste?

Verwenden Sie eine set?...

InformationsquelleAutor GoobyPrs | 2016-04-05

python

6

Als Donkey Kong-points gesetzt werden, erhalten Sie die eindeutige Werte in einer Liste durch die Umwandlung der Liste in ein set :
```
t = [2,2,2,2,4]
c = list(itertools.combinations(t, 4))
unq = set(c)
print(unq)
```
Und das Ergebnis wird sein:
```
{(2, 2, 2, 4), (2, 2, 2, 2)}
```
Wenn Sie möchten, es zu benutzen, wie eine Liste, können Sie wandeln es wieder dadurch :
```
result = list(unq)
```
Alternative und mehr saubere,umfassende Weg wird sein :
```
t = [2,2,2,2,4]
c = set(itertools.combinations(t, 4))
```
- Nur set(itertools.combinations(t, 4))
- Es war sein code ist er mit der Liste, ich bin einfach weiterhin seinen code ...
- Ja , das wird die saubere Art und Weise.
- Tun Sie das nicht. Warum sollte er gegossen, um eine Liste und dann einen Satz und dann zurück zu einer Liste?
- die Antwort sollte ein clean Update - code als auch...:)
- Downvoted. Es gibt absolut keine Punkt zu halten, eine Methode, wo man eine Liste erstellen => set => Liste. "Weiterhin seinen code" hat kein Verdienst, wenn es falsch/ nicht notwendig.
- Kein problem, Kumpel.
InformationsquelleAutor Randhawa

Ich weiß, das ist spät, aber ich möchte einen Punkt hinzufügen.

set(itertools.combinations(t, 4)) würde das tun, einen guten job für die meisten Fällen, aber es immer noch durchläuft alle sich wiederholenden Kombinationen intern und so kann man es rechnerisch schwer. Dies ist insbesondere der Fall, wenn es nicht viele tatsächliche einzigartige Kombinationen.

Diese eine iteriert nur einzigartige Kombinationen:

from itertools import chain,repeat,islice,count
from collections import Counter

def combinations_without_repetition(r, iterable=None, values=None, counts=None):
    if iterable:
        values, counts = zip(*Counter(iterable).items())

    f = lambda i,c: chain.from_iterable(map(repeat, i, c))
    n = len(counts)
    indices = list(islice(f(count(),counts), r))
    if len(indices) < r:
        return
    while True:
        yield tuple(values[i] for i in indices)
        for i,j in zip(reversed(range(r)), f(reversed(range(n)), reversed(counts))):
            if indices[i] != j:
                break
        else:
            return
        j = indices[i]+1
        for i,j in zip(range(i,r), f(count(j), islice(counts, j, None))):
            indices[i] = j

Verwendung:

>>> t = [2,2,2,2,4]
# elements in t must be hashable
>>> list(combinations_without_repetition(4, iterable=t)) 
[(2, 2, 2, 2), (2, 2, 2, 4)]

# You can pass values and counts separately. For this usage, values don't need to be hashable
# Say you have ['a','b','b','c','c','c'], then since there is 1 of 'a', 2 of 'b', and 3 of 'c', you can do as follows:
>>> list(combinations_without_repetition(3, values=['a','b','c'], counts=[1,2,3]))
[('a', 'b', 'b'), ('a', 'b', 'c'), ('a', 'c', 'c'), ('b', 'b', 'c'), ('b', 'c', 'c'), ('c', 'c', 'c')]

# combinations_without_repetition() is a generator (and thus an iterator)
# so you can iterate it
>>> for comb in combinations_without_repetition(4, t):
...     print(sum(comb))
...
8   # 2+2+2+2
10  # 2+2+2+4

Beachten Sie, dass itertools.combinations() ist implementiert in C, was bedeutet, es ist viel schneller als mein python-Skript für die meisten Fälle. Dieser code funktioniert besser als set(itertools.combinations()) Methode nur, wenn es wesentlich MEHR sich wiederholende Kombinationen als einzigartige Kombinationen.

InformationsquelleAutor hahho

5

Technisch, was Sie erhalten, sind keine echten Duplikate, es ist einfach wie itertools.Kombinationen funktioniert, wenn Sie Lesen, die Beschreibung auf der verlinkten Seite:

itertools.combinations(iterable, r)

Return r Länge untersequenzen von Elementen aus dem input durchsuchbar.

Kombinationen abgegeben werden, in lexikographischer Reihenfolge Sortieren. Also, wenn die Eingabe iterierbar ist sortiert, die Kombination Tupel produziert werden, in
Reihenfolge sortiert.

Elemente behandelt werden, als einzigartige, basierend auf Ihrer position, nicht auf Ihren Wert. Also, wenn die input-Elemente sind einzigartig, es wird keine
wiederholen Sie die Werte in jeder Kombination.

DEMO:
```
>>> import itertools as it
>>> list(it.combinations([1,2,3,4,5], 4))
[(1, 2, 3, 4), (1, 2, 3, 5), (1, 2, 4, 5), (1, 3, 4, 5), (2, 3, 4, 5)]
```
So, wie gepostet auf der vorherigen Antwort, set() wird Sie mit einer einzigartigen Werte, die Sie möchten:
```
>>> set(it.combinations(t, 4))
{(2, 2, 2, 4), (2, 2, 2, 2)}
```
InformationsquelleAutor Iron Fist

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.