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

öğ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

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

1 Beğeni

ç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.

@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

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

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

Merhabalar ben de birşey sorabilir miyim gerçi uzun zaman olmuş ama… Acaba bu kodu matematiksel olarak nasıl yazabiliriz bilginiz var mı

7 elemanlı bir kümenin 5 elemanlı alt kümesinin sayısı, 7’nin 5’li kombinasyonu ile hesaplanır. Bu da 7.6.5.4.3 / 5! şeklinde bulunabilir…

Demek istediğim bu kümeleri sırasıyla yazdıracak bir matemetiksel ifade fonksiyon…
yani sayısını veya 5 elemanlı alt kümelerin kaçında 2 vardır gibi değil de
alt kümeleri sıralasın elemanlarıyla birlikte
(Teşekkür ederim)

Oncelikle kume elemanlari yerine indisler ile calismaniz lazim. { “elma”, “armut”, … } yerine { 0, 1, 2, 3, 4, 5, 6 } dusunebilirsiniz. Indislerden elemanlara gecis icin her elemana bir sayi vermeniz, kumeyi array’e cevirmeniz yeterli.

5 elemanli alt kumeleri alacaksak, 5 tane degiskenimiz olmasi lazim. Bu sayinin da degisken olacagini varsayarak bir array kullanabiliriz.

Gerisi aslinda cok basit: [0, 0, 0, 0, 0]'dan [6, 6, 6, 6, 6]'ya kadar butun array’leri uretiyoruz:

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 1]
[0, 0, 0, 0, 2]
[0, 0, 0, 0, 3]
[0, 0, 0, 0, 4]
[0, 0, 0, 0, 5]
[0, 0, 0, 0, 6]
[0, 0, 0, 1, 0]
[0, 0, 0, 1, 1]

[0, 0, 0, 6, 6]
[0, 0, 1, 0, 0]
[0, 0, 1, 0, 1]

[6, 6, 6, 6, 6]

Bu butun permutasyonlari (miydi?) uretiyor.
Alt kume olabilmesi icin bir takim gereksinimler var. Mesela ayni indisin iki kere gecmemesi lazim. Bu kosula bakip, uygun olmadigi noktadaki permutasyonu atlayabiliriz.
(Baska gereksinim var mi? Onu da kosul olarak ekleyebiliriz)

Bunu yaptiktan sonra optimizasyonlar dusunebiliriz. Idealde, algoritmanin C(7, 5) (miydi?) adimda calismasi lazim; yukaridaki 7.6.5.4.3 / 5! sayisi.

En basidinden indisleri [0, 0, 0, 0, 0] yerine [0, 1, 2, 3, 4]'ten baslatabiliriz.
[2, 2, x, y, z] sayisina geldigimiz noktada butun xyz=000~666 permutasyonlarindan gecmemize gerek yok; [2, 3, 0, 0, 0] sayisina atlayabiliriz. Veya atlayabilecegimiz daha iyi bir sayi var mi?


Veya basit recursion da kullanabiliriz. [0, 1, 2, 3, 4, 5, 6]'nin 5’li kombinasyonlari,
[0] + [1, 2, 3, 4, 5, 6]'nin 4’lu kombinasyonlari +
[1] + [0, 2, 3, 4, 5, 6]'nin 4’lu kombinasyonlari +
… +
[6] + [0, 1, 2, 3, 4, 5]'in 4’lu kombinasyonlarina esit.

[0, 1, 2, 3, 4, 5]'in 4’lu kombinasyonlari,
[0] + [1, 2, 3, 4, 5]'in 3’lu kombinasyonlari +
[1] + [0, 2, 3, 4, 5]'in 3’lu kombinasyonlari +
…'ya esit.

Bunlari egzersiz olarak yapmanizi tavsiye ediyorum. Bir seyler ogretecek kadar karmasik problemler, fakat her adimda yaptiginizin dogrulugunu kontrol etmenizin kolay olacagi kadar basit problemler.

Ustelik 4’un 3’lu kombinasyonlari veya 5’in 2’li kombinasyonlari gibi basit de baslayabilirsiniz.

1 Beğeni

Çok teşekkür ederim bunları bilgisayardan önce matematiksel bir ifadeyle nasıl yazılabileceğini düşünmeye çalışıyorum evet küme elemanları sayılar ve örneğin {1,2,3,4,5,6,7} nin 5 elemanlı alt kümelerinden 6. sını veren bir formül bulmaya çalışıyorum yani n elemenlı kümenin m elemanlı alt kümelerinden p. sini veren bir formül