Gegeven een set
{0, 1, 2, 3}
Hoe kan ik de subsets produceren:
[set(),
{0},
{1},
{2},
{3},
{0, 1},
{0, 2},
{0, 3},
{1, 2},
{1, 3},
{2, 3},
{0, 1, 2},
{0, 1, 3},
{0, 2, 3},
{1, 2, 3},
{0, 1, 2, 3}]
1, Autoriteit 100%
De Python itertoolspagina heeft exact een powersetrecept hiervoor:
from itertools import chain, combinations
def powerset(iterable):
"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
Uitgang:
>>> list(powerset("abcd"))
[(), ('a',), ('b',), ('c',), ('d',), ('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd'), ('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'c', 'd'), ('b', 'c', 'd'), ('a', 'b', 'c', 'd')]
Als u aan het begin van die lege tuple niet leuk vindt, kunt u gewoon de rangeVerklarding wijzigen in range(1, len(s)+1)naar Vermijd een combinatie van 0-lengte.
2, Autoriteit 34%
Hier is meer code voor een boemper. Dit is helemaal geschreven:
>>> def powerset(s):
... x = len(s)
... for i in range(1 << x):
... print [s[j] for j in range(x) if (i & (1 << j))]
...
>>> powerset([4,5,6])
[]
[4]
[5]
[4, 5]
[6]
[4, 6]
[5, 6]
[4, 5, 6]
De opmerking van Mark Rushakoff is hier van toepassing: “Als je die lege tuple aan het begin niet leuk vindt, verder.”je kunt de range-instructie gewoon veranderen in range(1, len(s)+1) om een 0 te vermijden -lengte combinatie”, behalve in mijn geval verander je for i in range(1 << x)in for i in range(1, 1 << x).
Als ik hier jaren later op terugkom, zou ik het nu als volgt schrijven:
def powerset(s):
x = len(s)
masks = [1 << i for i in range(x)]
for i in range(1 << x):
yield [ss for mask, ss in zip(masks, s) if i & mask]
En dan zou de testcode er zo uitzien, zeg:
print(list(powerset([4, 5, 6])))
Het gebruik van yieldbetekent dat u niet alle resultaten in een enkel stuk geheugen hoeft te berekenen. Het vooraf berekenen van de maskers buiten de hoofdlus wordt verondersteld een waardevolle optimalisatie te zijn.
Antwoord 3, autoriteit 11%
Als je op zoek bent naar een snel antwoord, heb ik net op google naar “python power set” gezocht en dit bedacht: Python Power Set-generator
Hier is een copy-paste van de code op die pagina:
def powerset(seq):
"""
Returns all the subsets of this set. This is a generator.
"""
if len(seq) <= 1:
yield seq
yield []
else:
for item in powerset(seq[1:]):
yield [seq[0]]+item
yield item
Dit kan als volgt worden gebruikt:
l = [1, 2, 3, 4]
r = [x for x in powerset(l)]
Nu is r een lijst van alle elementen die je wilde, en kan worden gesorteerd en afgedrukt:
r.sort()
print r
[[], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 4], [1, 3], [1, 3, 4], [1, 4], [2], [2, 3], [2, 3, 4], [2, 4], [3], [3, 4], [4]]
Antwoord 4, autoriteit 7%
def powerset(lst):
return reduce(lambda result, x: result + [subset + [x] for subset in result],
lst, [[]])
Antwoord 5, autoriteit 6%
TL;DR (ga direct naar Vereenvoudiging)
Ik weet dat ik eerder een antwoord heb toegevoegd, maar ik ben erg blij met mijn nieuwe implementatie. Ik neem een set als invoer, maar het kan eigenlijk elke iterable zijn, en ik retourneer een set sets die de vermogensset van de invoer is. Ik hou van deze benadering omdat het meer aansluit bij de wiskundige definitie van power set(set van alle subsets).
def power_set(A):
"""A is an iterable (list, tuple, set, str, etc)
returns a set which is the power set of A."""
length = len(A)
l = [a for a in A]
ps = set()
for i in range(2 ** length):
selector = f'{i:0{length}b}'
subset = {l[j] for j, bit in enumerate(selector) if bit == '1'}
ps.add(frozenset(subset))
return ps
Als je precies de output wilt die je in je antwoord hebt gepost, gebruik dan dit:
>>> [set(s) for s in power_set({1, 2, 3, 4})]
[{3, 4},
{2},
{1, 4},
{2, 3, 4},
{2, 3},
{1, 2, 4},
{1, 2},
{1, 2, 3},
{3},
{2, 4},
{1},
{1, 2, 3, 4},
set(),
{1, 3},
{1, 3, 4},
{4}]
Uitleg
Het is bekend dat het aantal elementen van de vermogensset 2 ** len(A)is, dus dat was duidelijk te zien in de for-lus.
Ik moet de invoer (idealiter een set) converteren naar een lijst omdat een set een gegevensstructuur is van unieke ongeordende elementen, en de volgorde is cruciaal om de subsets te genereren.
selectoris de sleutel in dit algoritme. Merk op dat selectordezelfde lengte heeft als de invoerset, en om dit mogelijk te maken gebruikt het een f-string met opvulling. Kortom, dit stelt me in staat om de elementen te selecteren die tijdens elke iteratie aan elke subset worden toegevoegd. Laten we zeggen dat de invoerset 3 elementen heeft {0, 1, 2}, dus de selector zal waarden aannemen tussen 0 en 7 (inclusief), die binair zijn:
000 # 0
001 # 1
010 # 2
011 # 3
100 # 4
101 # 5
110 # 6
111 # 7
Dus, elk bit kan dienen als een indicator of een element van de originele set moet worden toegevoegd of niet. Kijk naar de binaire getallen en beschouw elk getal als een element van de superset waarin 1betekent dat een element op index jmoet worden toegevoegd, en 0betekent dat dit element niet moet worden toegevoegd.
Ik gebruik een setbegrip om bij elke iteratie een subset te genereren, en ik converteer deze subset naar een frozensetzodat ik deze kan toevoegen aan ps(powerset) . Anders kan ik het niet toevoegen omdat een set in Python alleen uit onveranderlijke objecten bestaat.
Vereenvoudiging
Je kunt de code vereenvoudigen met behulp van enkele python-begrippen, zodat je die for-loops kunt verwijderen. U kunt ook zipgebruiken om het gebruik van de j-index te vermijden en de code zal als volgt eindigen:
def power_set(A):
length = len(A)
return {
frozenset({e for e, b in zip(A, f'{i:{length}b}') if b == '1'})
for i in range(2 ** length)
}
Dat is het. Wat ik leuk vind aan dit algoritme is dat het duidelijker en intuïtiever is dan andere, omdat het er heel magisch uitziet om op itertoolste vertrouwen, ook al werkt het zoals verwacht.
Antwoord 6, autoriteit 5%
Er is een verfijning van de powerset:
def powerset(seq):
"""
Returns all the subsets of this set. This is a generator.
"""
if len(seq) <= 0:
yield []
else:
for item in powerset(seq[1:]):
yield [seq[0]]+item
yield item
Antwoord 7, autoriteit 4%
Ik vond het volgende algoritme heel duidelijk en eenvoudig:
def get_powerset(some_list):
"""Returns all subsets of size 0 - len(some_list) for some_list"""
if len(some_list) == 0:
return [[]]
subsets = []
first_element = some_list[0]
remaining_list = some_list[1:]
# Strategy: get all the subsets of remaining_list. For each
# of those subsets, a full subset list will contain both
# the original subset as well as a version of the subset
# that contains first_element
for partial_subset in get_powerset(remaining_list):
subsets.append(partial_subset)
subsets.append(partial_subset[:] + [first_element])
return subsets
Een andere manier om de powerset te genereren is door alle binaire getallen te genereren die nbits hebben. Als machtsset is het aantal getallen met ncijfers 2 ^ n. Het principe van dit algoritme is dat een element al dan niet aanwezig kan zijn in een subset, aangezien een binair cijfer één of nul kan zijn, maar niet beide.
def power_set(items):
N = len(items)
# enumerate the 2 ** N possible combinations
for i in range(2 ** N):
combo = []
for j in range(N):
# test bit jth of integer i
if (i >> j) % 2 == 1:
combo.append(items[j])
yield combo
Ik vond beide algoritmen toen ik MITx gebruikte: 6.00.2x Inleiding tot Computational Thinking en Data Science, en ik beschouw het als een van de gemakkelijkst te begrijpen algoritmen die ik heb gezien.
Antwoord 8, autoriteit 3%
def get_power_set(s):
power_set=[[]]
for elem in s:
# iterate over the sub sets so far
for sub_set in power_set:
# add a new subset consisting of the subset at hand added elem
power_set=power_set+[list(sub_set)+[elem]]
return power_set
Bijvoorbeeld:
get_power_set([1,2,3])
opbrengst
[[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3]]
Antwoord 9, autoriteit 2%
Ik wilde alleen de meest begrijpelijke oplossing bieden, de anti-code-golfversie.
from itertools import combinations
l = ["x", "y", "z", ]
def powerset(items):
combo = []
for r in range(len(items) + 1):
#use a list to coerce a actual list from the combinations generator
combo.append(list(combinations(items,r)))
return combo
l_powerset = powerset(l)
for i, item in enumerate(l_powerset):
print "All sets of length ", i
print item
De resultaten
Alle sets met lengte 0
[()]
Alle sets van lengte 1
[('x',), ('y',), ('z',)]
Alle sets van lengte 2
[('x', 'y'), ('x', 'z'), ('y', 'z')]
Alle sets van lengte 3
[('x', 'y', 'z')]
Voor meer zie de itertools-documenten, ook de wikipedia vermelding op powersets
Antwoord 10, autoriteit 2%
Dit kan heel natuurlijk worden gedaan met itertools.product:
import itertools
def powerset(l):
for sl in itertools.product(*[[[], [i]] for i in l]):
yield {j for i in sl for j in i}
Antwoord 11
Gewoon een snelle opfrissing van de powerset!
Krachtverzameling van een verzameling X, is gewoon de verzameling van alle deelverzamelingen van X, inclusief
de lege setVoorbeeldset X = (a,b,c)
Power Set = { { a , b , c } , { a , b } , { a , c } , { b , c } , { a } , { b } , { c } , { } }
Hier is een andere manier om de vermogensset te vinden:
def power_set(input):
# returns a list of all subsets of the list a
if (len(input) == 0):
return [[]]
else:
main_subset = [ ]
for small_subset in power_set(input[1:]):
main_subset += [small_subset]
main_subset += [[input[0]] + small_subset]
return main_subset
print(power_set([0,1,2,3]))
volledige lof voor bron
Antwoord 12
Met een lege set, die deel uitmaakt van alle subsets, kun je het volgende gebruiken:
def subsets(iterable):
for n in range(len(iterable) + 1):
yield from combinations(iterable, n)
Antwoord 13
Gebruik functie powerset()uit pakket more_itertools.
Geeft alle mogelijke subsets van de iterabele
>>> list(powerset([1, 2, 3]))
[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
Als je sets wilt, gebruik dan:
list(map(set, powerset(iterable)))
Antwoord 14
Ik weet dat dit te laat is
Er zijn al veel andere oplossingen, maar toch…
def power_set(lst):
pw_set = [[]]
for i in range(0,len(lst)):
for j in range(0,len(pw_set)):
ele = pw_set[j].copy()
ele = ele + [lst[i]]
pw_set = pw_set + [ele]
return pw_set
Antwoord 15
Misschien wordt de vraag oud, maar ik hoop dat mijn code iemand kan helpen.
def powSet(set):
if len(set) == 0:
return [[]]
return addtoAll(set[0],powSet(set[1:])) + powSet(set[1:])
def addtoAll(e, set):
for c in set:
c.append(e)
return set
Antwoord 16
Alle subsets ophalen met recursie. Gekke oneliner
from typing import List
def subsets(xs: list) -> List[list]:
return subsets(xs[1:]) + [x + [xs[0]] for x in subsets(xs[1:])] if xs else [[]]
Gebaseerd op een Haskell-oplossing
subsets :: [a] -> [[a]]
subsets [] = [[]]
subsets (x:xs) = map (x:) (subsets xs) ++ subsets xs
Antwoord 17
def findsubsets(s, n):
return list(itertools.combinations(s, n))
def allsubsets(s) :
a = []
for x in range(1,len(s)+1):
a.append(map(set,findsubsets(s,x)))
return a
Antwoord 18
Als u een bepaalde lengte van subsets wilt, kunt u dat als volgt doen:
from itertools import combinations
someSet = {0, 1, 2, 3}
([x for i in range(len(someSet)+1) for x in combinations(someSet,i)])
Meer in het algemeen voor subsets van willekeurige lengte kunt u het bereikargument wijzigen. De uitvoer is
[(), (0,), (1,), (2,), (3,), (0, 1), (0, 2), (0, 3), (1, 2) , (1, 3), (2, 3), (0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3), (0, 1, 2, 3)]
Antwoord 19
Je kunt het als volgt doen:
def powerset(x):
m=[]
if not x:
m.append(x)
else:
A = x[0]
B = x[1:]
for z in powerset(B):
m.append(z)
r = [A] + z
m.append(r)
return m
print(powerset([1, 2, 3, 4]))
Uitvoer:
[[], [1], [2], [1, 2], [3], [1, 3], [2, 3], [1, 2, 3], [4], [1, 4], [2, 4], [1, 2, 4], [3, 4], [1, 3, 4], [2, 3, 4], [1, 2, 3, 4]]
Antwoord 20
Dit is wild omdat geen van deze antwoorden daadwerkelijk de terugkeer van een echte Python-set oplevert. Hier is een rommelige implementatie die een powerset geeft die eigenlijk een Python setis.
test_set = set(['yo', 'whatup', 'money'])
def powerset( base_set ):
""" modified from pydoc's itertools recipe shown above"""
from itertools import chain, combinations
base_list = list( base_set )
combo_list = [ combinations(base_list, r) for r in range(len(base_set)+1) ]
powerset = set([])
for ll in combo_list:
list_of_frozensets = list( map( frozenset, map( list, ll ) ) )
set_of_frozensets = set( list_of_frozensets )
powerset = powerset.union( set_of_frozensets )
return powerset
print powerset( test_set )
# >>> set([ frozenset(['money','whatup']), frozenset(['money','whatup','yo']),
# frozenset(['whatup']), frozenset(['whatup','yo']), frozenset(['yo']),
# frozenset(['money','yo']), frozenset(['money']), frozenset([]) ])
Ik zou echter graag een betere implementatie zien.
Antwoord 21
Hier is mijn snelle implementatie waarbij ik combinaties gebruik, maar alleen ingebouwde functies.
def powerSet(array):
length = str(len(array))
formatter = '{:0' + length + 'b}'
combinations = []
for i in xrange(2**int(length)):
combinations.append(formatter.format(i))
sets = set()
currentSet = []
for combo in combinations:
for i,val in enumerate(combo):
if val=='1':
currentSet.append(array[i])
sets.add(tuple(sorted(currentSet)))
currentSet = []
return sets
Antwoord 22
Alle subsets in bereik n als set:
n = int(input())
l = [i for i in range (1, n + 1)]
for number in range(2 ** n) :
binary = bin(number)[: 1 : -1]
subset = [l[i] for i in range(len(binary)) if binary[i] == "1"]
print(set(sorted(subset)) if number > 0 else "{}")
Antwoord 23
import math
def printPowerSet(set,set_size):
pow_set_size =int(math.pow(2, set_size))
for counter in range(pow_set_size):
for j in range(set_size):
if((counter & (1 << j)) > 0):
print(set[j], end = "")
print("")
set = ['a', 'b', 'c']
printPowerSet(set,3)
Antwoord 24
Een variatie op de vraag is een oefening die ik zie in het boek “Discovering Computer Science: Interdisciplinary Problems, Principles, and Python Programming. 2015 edition”. In die oefening 10.2.11 is de invoer slechts een geheel getal en moet de uitvoer de vermogenssets zijn. Hier is mijn recursieve oplossing (ik gebruik niets anders dan standaard python3)
def powerSetR(n):
assert n >= 0
if n == 0:
return [[]]
else:
input_set = list(range(1, n+1)) # [1,2,...n]
main_subset = [ ]
for small_subset in powerSetR(n-1):
main_subset += [small_subset]
main_subset += [ [input_set[-1]] + small_subset]
return main_subset
superset = powerSetR(4)
print(superset)
print("Number of sublists:", len(superset))
En de uitvoer is
[[], [4], [3], [4, 3], [2], [4, 2], [3, 2], [4, 3, 2], [1], [ 4, 1], [3, 1], [4, 3, 1], [2, 1], [4, 2, 1], [3, 2, 1], [4, 3, 2, 1] ]
Aantal sublijsten: 16
Antwoord 25
Ik was de functie more_itertools.powersetnog niet tegengekomen en zou aanraden die te gebruiken. Ik raad ook aan om de standaardvolgorde van de uitvoer van itertools.combinationsniet te gebruiken, in plaats daarvan wil je vaak de afstandtussen de posities minimaliseren en de subsets van items met een kortere afstand sorteren tussen hen boven/vóór de items met een grotere afstand ertussen.
De itertoolsreceptenpaginalaat zien dat het chain.from_iterable
. gebruikt
- Merk op dat de
rhier overeenkomt met de standaardnotatie voor het onderste deel van een binomiale coëfficiënt, deswordt gewoonlijkngenoemd in wiskundeteksten en op rekenmachines (“n Kies r”)
def powerset(iterable):
"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
De andere voorbeelden hier geven de powerset van [1,2,3,4]op zo’n manier dat de 2-tupels in “lexicografische” volgorde worden weergegeven (wanneer we de getallen afdrukken als gehele getallen). Als ik de afstand tussen de getallen ernaast schrijf (d.w.z. het verschil), toont het mijn punt:
12 ⇒ 1
13 ⇒ 2
14 ⇒ 3
23 ⇒ 1
24 ⇒ 2
34 ⇒ 1
De juiste volgorde voor subsets zou de volgorde moeten zijn waarin eerst de minimale afstand wordt ‘uitgeput’, zoals:
12 ⇒ 1
23 ⇒ 1
34 ⇒ 1
13 ⇒ 2
24 ⇒ 2
14 ⇒ 3
Het gebruik van nummers hier maakt deze bestellingen uit ‘fout’, maar bekijk bijvoorbeeld de letters ["a","b","c","d"]Het is duidelijker waarom dit mogelijk is nuttig zijn om de PowerSet in deze volgorde te verkrijgen:
ab ⇒ 1
bc ⇒ 1
cd ⇒ 1
ac ⇒ 2
bd ⇒ 2
ad ⇒ 3
Dit effect is meer uitgesproken met meer items, en voor mijn doeleinden maakt het het verschil tussen het kunnen beschrijven van de reeksen van de indexen van de PowerSet zinvol.
(er is een partij geschreven op grijze codes etc. voor de uitgangsvolgorde van algoritmen In combinatoriek zie ik het niet als een nevenprobleem).
Ik heb eigenlijk een vrij betrokken programma geschreven dat deze snelle integer-partitiecode gebruikte om de waarden in de juiste volgorde uit te voeren, maar toen ontdekte ik more_itertools.powerseten voor de meeste toepassingen is het waarschijnlijk wel goed Gebruik die functie zoals SO:
from more_itertools import powerset
from numpy import ediff1d
def ps_sorter(tup):
l = len(tup)
d = ediff1d(tup).tolist()
return l, d
ps = powerset([1,2,3,4])
ps = sorted(ps, key=ps_sorter)
for x in ps:
print(x)
⇣
()
(1,)
(2,)
(3,)
(4,)
(1, 2)
(2, 3)
(3, 4)
(1, 3)
(2, 4)
(1, 4)
(1, 2, 3)
(2, 3, 4)
(1, 2, 4)
(1, 3, 4)
(1, 2, 3, 4)
Ik heb wat meer betrokken code geschreven die de PowerSet mooi zal afdrukken (zie de repo voor mooie drukfuncties die ik hier niet heb opgenomen: print_partitions, print_partitions_by_length, en pprint_tuple).
- Repo: ordered-powerset, specifiek
pset_partitions.py
Dit is allemaal vrij eenvoudig, maar kan toch handig zijn als je wat code wilt waarmee je direct toegang krijgt tot de verschillende niveaus van de powerset:
from itertools import permutations as permute
from numpy import cumsum
# http://jeromekelleher.net/generating-integer-partitions.html
# via
# https://stackoverflow.com/questions/10035752/elegant-python-code-for-integer-partitioning#comment25080713_10036764
def asc_int_partitions(n):
a = [0 for i in range(n + 1)]
k = 1
y = n - 1
while k != 0:
x = a[k - 1] + 1
k -= 1
while 2 * x <= y:
a[k] = x
y -= x
k += 1
l = k + 1
while x <= y:
a[k] = x
a[l] = y
yield tuple(a[:k + 2])
x += 1
y -= 1
a[k] = x + y
y = x + y - 1
yield tuple(a[:k + 1])
# https://stackoverflow.com/a/6285330/2668831
def uniquely_permute(iterable, enforce_sort=False, r=None):
previous = tuple()
if enforce_sort: # potential waste of effort (default: False)
iterable = sorted(iterable)
for p in permute(iterable, r):
if p > previous:
previous = p
yield p
def sum_min(p):
return sum(p), min(p)
def partitions_by_length(max_n, sorting=True, permuting=False):
partition_dict = {0: ()}
for n in range(1,max_n+1):
partition_dict.setdefault(n, [])
partitions = list(asc_int_partitions(n))
for p in partitions:
if permuting:
perms = uniquely_permute(p)
for perm in perms:
partition_dict.get(len(p)).append(perm)
else:
partition_dict.get(len(p)).append(p)
if not sorting:
return partition_dict
for k in partition_dict:
partition_dict.update({k: sorted(partition_dict.get(k), key=sum_min)})
return partition_dict
def print_partitions_by_length(max_n, sorting=True, permuting=True):
partition_dict = partitions_by_length(max_n, sorting=sorting, permuting=permuting)
for k in partition_dict:
if k == 0:
print(tuple(partition_dict.get(k)), end="")
for p in partition_dict.get(k):
print(pprint_tuple(p), end=" ")
print()
return
def generate_powerset(items, subset_handler=tuple, verbose=False):
"""
Generate the powerset of an iterable `items`.
Handling of the elements of the iterable is by whichever function is passed as
`subset_handler`, which must be able to handle the `None` value for the
empty set. The function `string_handler` will join the elements of the subset
with the empty string (useful when `items` is an iterable of `str` variables).
"""
ps = {0: [subset_handler()]}
n = len(items)
p_dict = partitions_by_length(n-1, sorting=True, permuting=True)
for p_len, parts in p_dict.items():
ps.setdefault(p_len, [])
if p_len == 0:
# singletons
for offset in range(n):
subset = subset_handler([items[offset]])
if verbose:
if offset > 0:
print(end=" ")
if offset == n - 1:
print(subset, end="\n")
else:
print(subset, end=",")
ps.get(p_len).append(subset)
for pcount, partition in enumerate(parts):
distance = sum(partition)
indices = (cumsum(partition)).tolist()
for offset in range(n - distance):
subset = subset_handler([items[offset]] + [items[offset:][i] for i in indices])
if verbose:
if offset > 0:
print(end=" ")
if offset == n - distance - 1:
print(subset, end="\n")
else:
print(subset, end=",")
ps.get(p_len).append(subset)
if verbose and p_len < n-1:
print()
return ps
Als een voorbeeld schreef ik een CLI-demo-programma dat een tekenreeks inneemt als een opdrachtregelargument:
python string_powerset.py abcdef
⇣
a, b, c, d, e, f
ab, bc, cd, de, ef
ac, bd, ce, df
ad, be, cf
ae, bf
af
abc, bcd, cde, def
abd, bce, cdf
acd, bde, cef
abe, bcf
ade, bef
ace, bdf
abf
aef
acf
adf
abcd, bcde, cdef
abce, bcdf
abde, bcef
acde, bdef
abcf
abef
adef
abdf
acdf
acef
abcde, bcdef
abcdf
abcef
abdef
acdef
abcdef
26
Hier is mijn oplossingen, het is vergelijkbaar (conceptueel) met de oplossing van LmiguelVargasf.
Laat me dat zeggen
– [MATH ITEM] BY PASSION DE POWERSET Bevat de lege set
– [Persoonlijke smaak] en ook dat ik het niet leuk vind om FrozenSet te gebruiken.
Dus de invoer is een lijst en de uitvoer is een lijst met lijsten. De functie zou eerder kunnen sluiten, maar ik hou van het element van het vermogen om te bestellen , dat betekent in wezen mooi.
def power_set(L):
"""
L is a list.
The function returns the power set, but as a list of lists.
"""
cardinality=len(L)
n=2 ** cardinality
powerset = []
for i in range(n):
a=bin(i)[2:]
subset=[]
for j in range(len(a)):
if a[-j-1]=='1':
subset.append(L[j])
powerset.append(subset)
#the function could stop here closing with
#return powerset
powerset_orderred=[]
for k in range(cardinality+1):
for w in powerset:
if len(w)==k:
powerset_orderred.append(w)
return powerset_orderred
Antwoord 27
def powerset(some_set):
res = [(a,b) for a in some_set for b in some_set]
return res