7 elemanlı kümenin 5 elemanlı alt kümelerini listeleyen program yazdım fakat

Python
1

öğrenme amacıyla 7 elemanlı bir kümenin 5 elemanlı alt kümelerini bulan bir program yazmaya çalıştım. fakat alt kümeleri yazarken biz insanların bu işi elle yaparken kullandığımız sıralama metodunu kullansın istedim. çok uzun sürede de olsa sonunda istediğim şeyi yaptırmayı başardım.

şimdi ise aklımda birkaç soru var:

  1. bu kodda değişken sayısını ve/veya döngü sayısını azaltamaz mıyım?
  2. bu kodu kullanıcının girdiği x eleman sayılı kümenin y eleman sayılı alt kümelerini yazdıracak hale nasıl getirebilirim?
  3. şu anki yazdığım kodun yaptığını yapacak çok daha başka ve kısa bir yol var mıydı?

yardımlarınız için şimdiden teşekkürler…

Kod:

kume = ["a", "b", "c", "d", "e", "f", "g"]

besliler = []

n, p, q, r = 4, 3, 2, 1

for i in range(0, 3):

        for j in range(r, 4):

                for k in range(q, 5):

                        for t in range(p, 6):

                                for s in range(n, 7):
                                    besliler.append((kume[i], kume[j], kume[k], kume[t], kume[s]))
                                n += 1
                        p += 1
                        n = p + 1
                q += 1
                p = q + 1
                n = q + 2
        r += 1
        q = r + 1
        p = r + 2
        n = r + 3

for h in besliler:
    print(h)

print(len(besliler))

Çıktı:

('a', 'b', 'c', 'd', 'e')
('a', 'b', 'c', 'd', 'f')
('a', 'b', 'c', 'd', 'g')
('a', 'b', 'c', 'e', 'f')
('a', 'b', 'c', 'e', 'g')
('a', 'b', 'c', 'f', 'g')
('a', 'b', 'd', 'e', 'f')
('a', 'b', 'd', 'e', 'g')
('a', 'b', 'd', 'f', 'g')
('a', 'b', 'e', 'f', 'g')
('a', 'c', 'd', 'e', 'f')
('a', 'c', 'd', 'e', 'g')
('a', 'c', 'd', 'f', 'g')
('a', 'c', 'e', 'f', 'g')
('a', 'd', 'e', 'f', 'g')
('b', 'c', 'd', 'e', 'f')
('b', 'c', 'd', 'e', 'g')
('b', 'c', 'd', 'f', 'g')
('b', 'c', 'e', 'f', 'g')
('b', 'd', 'e', 'f', 'g')
('c', 'd', 'e', 'f', 'g')
21
2

itertools modülünde buna benzer bir şey vardı. Araştırıp kaynak kodunu inceleyebilirsiniz.

1 Beğeni
3

çok teşekkür ederim. tavsiyeniz üzerine itertoolsa göz gezdirdim, hazır fonksiyonu varmış. daha da inceleyeceğim.

rica etsem benim bu kodumu iyileştirmek için tavsiyede bulunabilir misiniz? mesela değişken sayısı bir şekilde azaltılabilir gibi geliyor bana ama nasıl olabileceğini bulamadım. n,p,q,r değişkenlerini i’ye bağlı yazmayı denedim beceremedim.

4

@hasser başka birinin itertools kullanarak tanımladığı powerset fonksiyonundan yararlandım. önceki kodumla birebir aynı çıktıyı verecek şekilde eklemeler yaptım. bu kodda değişken sayısı ve döngü sayısı azaldı; böylece kullanıcının girdiği x eleman sayılı kümenin y eleman sayılı alt kümelerini yazdıracak hale getirmek de kolaylaştı.

tecrübeli insanların söylediği bir tek kelime bizim için bazen çok yardımcı olabiliyor. çok teşekkür ederim.

from itertools import chain, combinations

def powerset(iterable):
    """
    powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)
    """
    xs = list(iterable)
    # note we return an iterator rather than a list
    return chain.from_iterable(combinations(xs,n) for n in range(len(xs)+1))

kume = list(powerset(set(["a", "b", "c", "d", "e", "f", "g"])))
besliler = []

s = 0
for i in kume:

    if len(i) == 5:
        s += 1
        i = sorted(i)
        besliler.append(i)

besliler = sorted(besliler)

for k in besliler:
    print(tuple(k))

print(s)
2 Beğeni
5

Ben böyle bir kod yazdım, işine yarar mı acaba;
import itertools
kume=[“a”,“b”,“c”,“d”,“e”,“f”,“g”]
alt_kume=list(itertools.combinations(kume,5))
print(“alt_kume= \t “, alt_kume ,end=”\n” )

2 Beğeni
6

kesinlikle olması gereken buydu. :slight_smile: tabii fonksiyonu kendim yazmaya çalışırken de iyi bir deneyim elde etmiş oldum ama böylesi çok daha temiz. :slight_smile: bu konuyu sizin bir gönderiniz üzerine araştırmaya başlamıştım, neticelendiren de siz oldunuz. :slight_smile: çok teşekkürler.

2 Beğeni