Arkadaşlar merhaba. Elimde 34! sayıda ihtimalin denenmesini gerektiren bir proje var. Görüldüğü üzere oldukça fazla. Bunu ben python dilinde kodlattım. 15! adet ihtimalli hesaplamaları kısa sürede yapıyor fakat daha fazlası için saatler geçiyor, fakat biteceği yok. Şimdi sorum şu: Bu kod, daha da hızlandırılabilir mi ? Mesela 15 dakikada 34! adet ihtimali tek tek deneyebilir mi ? Yoksa bu sayı bir kod için gerçekten çok yüksek ve bu konuda yapılabilecek fazla bir şey yok mu ? Konuyla ilgili bir fikri, bilgisi ya da önerisi olan arkadaşlar görüş bildirebilirse çok sevinirim. Herkese iyi günler diliyorum…
"
Merhaba! Projenizde karşılaştığınız bu hesaplama süresi sorunu oldukça yaygındır ve çözümü projenin gereksinimlerine ve hangi algoritmanın kullanıldığına bağlı olacaktır. Python dilinde yazılan kodların hızını artırmak için aşağıda bazı önerilerde bulunabilirim:
-
Optimizasyon Kontrolü: Mevcut kodunuzu inceleyin ve optimize edilebilecek kısımları belirleyin. Veri yapılarınızı ve döngüleri etkin bir şekilde kullanmaya çalışın. Gereksiz hesaplamalardan kaçının.
-
Profiling: Python’da kodunuzun hangi kısımlarının daha fazla zaman harcadığını anlamak için kodunuzun performans analizini yapmak için bir “profiling” aracı kullanın. Böylece en yavaş çalışan kısımları belirleyebilir ve bu kısımları optimize edebilirsiniz.
-
Farklı Bir Yaklaşım: Projenizin özelliğine bağlı olarak, daha hızlı çalışan algoritmalar kullanmayı düşünebilirsiniz. Bazı matematiksel hesaplamalar, daha verimli algoritmalarla çözülebilir.
-
Paralel İşlemler: Eğer mümkünse, proje üzerinde paralel hesaplamalar kullanarak birden fazla işlemci çekirdeği üzerinde işlem yapabilir ve işlem süresini kısaltabilirsiniz.
-
Daha Güçlü Bir Donanım Kullanımı: Eğer mümkünse, daha hızlı bir bilgisayar veya daha yüksek performanslı bir işlemci kullanarak hesaplama süresini azaltabilirsiniz.
Ancak, 34! gibi büyük bir sayıda ihtimali tek tek denemek her durumda uzun süreli bir işlem olabilir. Bu nedenle, projenizin gereksinimlerini gözden geçirerek, belki problemi farklı bir açıdan ele alarak ya da daha az hassas ama hızlı sonuçlar alabileceğiniz alternatif yöntemler düşünerek süreyi kısaltmayı deneyebilirsiniz.
Bir diğer seçenek, Monte Carlo yöntemi gibi rastgelelik temelli yaklaşımları kullanmak olabilir. Bu tür yöntemlerde, bazı ihtimalleri rastgele seçerek sonuçlara yaklaşırsınız ve daha hızlı bir şekilde sonuç alabilirsiniz. Ancak, bu yöntemler sonucun kesinliğini azaltabilir, bu nedenle doğruluk ve hız arasında bir denge kurmanız gerekebilir.
Sonuç olarak, belirli bir çözüm için daha fazla ayrıntıya ihtiyacım var, ancak yukarıdaki öneriler proje hızını artırmak için genel bir başlangıç noktası olabilir. Herhangi bir özel durumda daha fazla yardım ve rehberlik için kodunuzun veya algoritmanızın ayrıntılarını paylaşabilirsiniz. İyi çalışmalar dilerim!
"
Diyor ChatGPT.
Aslında soruyu bilirsek belki o 34! olasılığın büyük bir kısmı elenir bazı matematiksel yöntemlerle.
Her biri 15! ihtimali bir saniyede hesaplayan 15! bilgisayar olsa bile 34! ihtimali hesaplamak 5.5 milyon yil suruyor.
Saniyede 4 920 546 650 660 069 014 126 976 827 392 000 000 ihtimal ediyor.
Dunya uzerindeki tahmini 7.5e18 kum tanesinin hepsini bilgisayara cevirirsek ve hepsi 15! ihtimali 2 mikrosaniyede hesaplayacak kadar hizlandirilirsa 34! ihtimali 15 dakkada hesaplayabiliriz.
…ve her zamanki gibi chatbota cahilce sorulan sorunun cevabi yanlis. GIGO.
1 Beğeni
34! İle atom dizilimi olasılığına mı bakıyorsunuz merak ettim.
1 Beğeni
Aşağıda meseleyi kısaca özetliyorum anlamanız için. 34! Sayıda ihtimalin kökeni buradan kaynaklanıyor.
kume_1 = [ [20,3,7,4,5,11], “cift”]
kume_2 = [ [1,2,3,5,7,15], “tek”]
kume_3 = [ [17,3,6,1,2,4], “cift”]
kume_4 = [ [20,7,3], “cift”]
Bir küme 5 veya 6 adet “A” harfinden+bazı rakamsal ifadelerden oluşur. “cift” şeklinde belirtilenler 6, “tek” şeklinde belirtilenler ise 5 adet “A” harfinden oluşur. Yapılması gereken bu rakamsal değerleri tek tek ve gruplar halinde, tüm kombinasyonları deneyerek “A” harfine dönüştürerek, her bir kümedeki “A” sayısını çift rakama tamamlamaya çalışacağız. (Ör; Küme 2’ de 5 adet A var. Eğer farzedelim 15 rakamını “A” yaparsak toplamda 6 adet A olur ve orası “çift” olur). Kümelerin ve elemanlara ilişkin önemli noktalar aşağıda verilmiştir:
- Rakamlar sayıdan ziyade sadece birer simge oldukları için, aritmetik sıraya göre yer almak zorunda değildir.
- Bir kümede yer alan bir rakamı “A” yaptığımızda, aynı rakamın yer aldığı diğer kümelerde de aynı değişiklik yapılmalıdır. Ör; Küme 2’ de 3 rakamını A yaptık ve “çift” oldu. Eş zamanlı olarak diğer üç kümede de 3 rakamı A olmalı. Tabi bu değişiklik Küme 2’ yi çift yaparken diğer kümelerdeki “çift” durumunu bozar.
- Öyle rakamları seçip değiştirmeliyiz ki tüm kümeler “çift” olsun.
Yukarıda dört adet kümeyi örnek olsun diye verdim. Normalde 28 adet küme ve 34 adet rakam var. Tüm rakamları tek tek ve gruplar halinde değiştirip 28 kümenin de “çift” olacağı durumu bulmamız gerek. Mesela 8 adet rakam vardır,işte onları A yapınca 28 küme de çift olacaktır. Bunu bulmak için tüm ihtimaller denenmeli.
Elimdeki kod, 15 rakam varsa, hızlı hesaplıyor. Fakat 34 adet rakamın sonu gelmiyor.
Rakam mı sayı mı? A olacak şeyler.
Parantez içinde verilen rakamları A’ ya dönüştüreceğiz. Aslında onları “sayı” veya “rakam” değil de bir simge olarak düşünün. Orada rakam yerine farklı karakterler de kullanılabilirdi.
Yani bu
kume_1 = [A,A,A,A,A,A,“cift”] haline mi gelecek? (A lar tırnak içinde)
Pratik olacak derken biraz karışık anlatmış olabilirim olayı, bu yüzden kusura bakmayın. Çift yazıyorsa 6 adet, tek yazıyorsa 5 adet A var elimizde. Bir de buna ilaveten rakamsal simgeler. Mesela bakın kume 1’ de 6 adet rakamsal simge var. Bunlarda 0,2,4 veya 6 adedini "A yapalım ki, toplam A sayısı çift sayıda olsun. Mesela sadece 3 adetini A yaparsak, 9 adet A olur ve tek sayı olacağı için olmaz. Biz diyelim ki 20 ve 3’ü A yaptık. A yaptığımız değerleri listeden sileriz. Ve yine 20 ve 3’ ün yer aldığı diğer kümelerden de sileriz. Sonuç olarak orada da tek-çift durumları değişecektir haliyle. İşte biz öyle rakamlar seçmeliyiz ki her yer aynı anda çift olsun. Bunun için 34 adet rakamı tek tek ve gruplar halinde deneyerek doğru kombinasyona ulşamaya çalışırız. Yukarıda verdiğiniz şematik örnekteki gibi değil, dediğim gibi sadece seçtiğimiz rakamları listeden çıkartırız, program en sonunda bize “çıkartılacaklar” listesi verir. Benim elimde bir kod var ama 34!’ ün üstesinden gelemiyor, 15 rakamlı kümeler grubunda ise oldukça hızlı. İsterseniz kodu sizinle paylaşabilirim incelemeniz için.
kume_4’teki 6 tane A harfi nerede? Ben uc tane sayi gorebiliyorum sadece.
Hatta hic bir kumede A harfi goremiyorum. Gorunmez bir dizi A harfleri oldugunu varsayiyorum.
"cift"lere bir sey yapmamiza gerek yok, zaten 6 adet A harfleri var.
Tek kumelerdeki 1, 3, 5, vs. tane sayiyi A harfine donusturdugumuzde 5 tane gizli + {1,3,5} tane donusturulmus = {6,8,10} tane A harfi oluyor.
Es kaza cift kumelerdeki bir sayiyi A harfine donusturursek, bir tane daha (veya 3, veya 5) sayiyi A harfine donusturerek cifte tamamlamamiz gerekiyor.
Benim anlamadigim, cift/tek yerine neden bes/alti demiyoruz, veya daha iyisi neden gizli A sayisini 0 ve 1 yapmiyoruz? Veya kumeye yerlestirelim:
kume_1 = [20,3,7,4,5,11]
kume_2 = [“A”,1,2,3,5,7,15]
kume_3 = [17,3,6,1,2,4]
kume_4 = [20,7,3]
Bu sorunun cozumu orijinal sorununkiyle ayni.
Sorun degil, siralarini degistirebiliriz
Buradaki ihtimal 34! degil, 2^34.
Ben anlatmayi deneyeyim:
1 ile N arasinda sayilardan olusan K tane kumemiz var. Bu kumeler keyfi bir sekilde “tek” veya “cift” olarak siniflandiriliyorlar:
kume_1 = [[20,3,7,4,5,11], “cift”]
kume_2 = [[1,2,3,5,7,15], “tek”]
kume_3 = [[17,3,6,1,2,4], “cift”]
kume_4 = [[20,7,3], “cift”]
Tek kumeler tek, cift kumeler cift sayida A elemanina sahip olmak istiyor. Bizim yapacagimiz, sayilarin herhangi bir kismini butun kumelerde A harfine donusturerek butun kumelerin isteklerini yerine getirmek.
Ornegin 3 sayisini A yaparsak tum kumelerde bir adet A harfi oluyor. Ikinci kume istedigi gibi tek sayida A’ya sahip olurken digerleri cift sayida istedikleri icin bozuluyorlar. 20’yi de A yapmaya karar verirsek 1. ve 4. duzeliyor, sadece 3 bozuk kaliyor.
2 Beğeni
@aib in yazdıklarına katılıyorum. Eğer yanlış anlamadıysam (veya daha kötüsü soruyu anlamadıysam) o kadar çok olasılık değil hesaplanması gereken. Baştan çiftlere dokunmadan tek kümeler üzerinde çalışmak. Tek kümeleri çift yaparken bozulan çift kümeleri düzeltmek gibi daha az enerji harcanacak yollara gidilebilir tek tek bütün sayıları denemektense.
Sorunun tamamını atarsanız veya kodunuzu daha iyi çözümler üretilecektir diye düşünüyorum.
kume_1 = [[20,3,7,4,5,11], “cift”]
kume_2 = [[1,2,3,5,7,15], “tek”]
kume_3 = [[17,3,6,1,2,4], “cift”]
kume_4 = [[20,7,3], “cift”]
Örneğin bu soruda 15 i A yapsak problem bitiyor değil mi? (doğru anlamış mıyım kontrolü)
Backtracking / DFS ile sonuca hizli ulasilabilir sanki, ama yine de O(2^N) oldugunu degistirmeyecektir.
Bu arada soru hizli bir sekilde BSAT’e cevrilebiliyor:
x20 ^ x3 ^ x7 ^ x4 ^ x5 ^ x11 = 0
x1 ^ x2 ^ x3 ^ x5 ^ x7 ^ x15 = 1
…
¬(x20 ⊻ x3 ⊻ x7 ⊻ x4 ⊻ x5 ⊻ x11) ∧ (x1 ⊻ x2 ⊻ x3 ⊻ x5 ⊻ x7 ⊻ x15) ∧ …
O yuzden en kotu ihtimalle NP-complete ama o kadar cok simetri var ki, P zamanda bir cozumu oldugundan supheleniyorum.
Lineer cebir usulu matrix yapip oyle incelemek de bir opsiyon.
Ben de oyle anladim
Evet yazdıklarınızı okudum, meseleyi kavramışsınız. Yine dediğiniz gibi sadece 15’ i A yapsak üç kümeli soru çözülmüş oluyor. Bu arada tekrardan kusura bakmayın ben basitleştireceğim derken biraz zor bir tarifte bulunmuş olabilirim fakat sonuç olarak konu anlaşılmış. Dediğim gibi kod çok ama çok yavaş kalıyor. Öyle bir yol lazım ki daha çabuk bir şekilde istenileni toparlasın ve sonuçları listelesin. Bu arada sudoku benzeri bir mantık işletilirse çözümü daha kolay olabilir kanaatimce.
Merhaba,
Aşağıdaki gibi bir algoritma izledim. Hız konusunda sizi tatmin eder mi emin değilim ama verdiğiniz örneği ve daha sonradan yapmış olduğum değişik örneklerin çözümünü buluyor. Daha fazla test üretmek için zamanım olmadı açıkçası. İsterseniz bir deneyin, sonra da yorumunuzu yapın.
def find_missing_chars(arr2d: list[list[list, int]], char: str) -> list:
modify = False
current = 0
for i in range(len(arr2d)):
arr1d, state = arr2d[i]
if arr1d.count(char) != state:
for index, j in enumerate(arr1d):
if j != char and all(j not in k[0] for k in arr2d[:i] + arr2d[i + 1:]):
modify = True
current = arr1d[index]
break
if modify:
break
for j in arr1d:
if j != char:
arr2d_without_j = [[[i if i != j else char for i in arr[0]], arr[1]] for arr in arr2d]
if all(len(set(i[0])) == 1 for i in arr2d_without_j):
break
else:
result = find_missing_chars(arr2d_without_j, char)
if all(i[0].count(char) % 2 == i[1] for i in result):
return result
if modify:
return find_missing_chars([[[j if j != current else char for j in i[0]], i[1]] for i in arr2d], char)
else:
return arr2d
Aşağıdaki test örneklerine bir bakın önce, sonra da onların çıktılarını inceleyin.
test_lst1 = [
[[20, 3, 7, 4, 5, 11], 0],
[[1, 2, 3, 5, 7, 15], 1],
[[17, 3, 6, 1, 2, 4], 0],
[[20, 7, 3], 0]
]
print(*find_missing_chars(test_lst1, "A"))
# [[20, 3, 7, 4, 5, 11], 0] [[1, 2, 3, 5, 7, 'A'], 1] [[17, 3, 6, 1, 2, 4], 0] [[20, 7, 3], 0]
test_lst2 = [
[[20, 3, 7, 4, 5, 11], 0],
[[1, 2, 3, 5, 7, 6], 1],
[[17, 3, 6, 1, 2, 4], 0],
[[20, 7, 3], 0]
]
print(*find_missing_chars(test_lst2, "A"))
# [[20, 'A', 'A', 'A', 5, 'A'], 0] [['A', 'A', 'A', 5, 'A', 'A'], 1] [['A', 'A', 'A', 'A', 'A', 'A'], 0] [[20, 'A', 'A'], 0]
test_lst3 = [
[[20, 3, 7, 4, 5, 11, 2], 1],
[[1, 2, 3, 5, 7], 1],
[[17, 3, 6, 1, 2, 4], 0],
[[20, 7, 3], 0]
]
print(*find_missing_chars(test_lst3, "A"))
# [['A', 'A', 7, 'A', 5, 'A', 'A'], 1] [['A', 'A', 'A', 5, 7], 1] [['A', 'A', 'A', 'A', 'A', 'A'], 0] [['A', 7, 'A'], 0]
test_lst4 = [
[[20, 3, 7, 4, 5, 11, 2], 1],
[[1, 2, 3, 5, 7], 1],
[[17, 3, 6, 1, 2, 4], 0],
[[5, 7, 3], 1]
]
print(*find_missing_chars(test_lst4, "A"))
# [['A', 'A', 7, 'A', 5, 'A', 'A'], 1] [['A', 'A', 'A', 5, 7], 1] [['A', 'A', 'A', 'A', 'A', 'A'], 0] [[5, 7, 'A'], 1]
test_lst5 = [
[[20, 3, 7, 4, 5, 11, 2, 17], 1],
[[1, 2, 3, 5, 7], 1],
[[17, 3, 6, 1, 2, 5], 0],
[[5, 7, 3], 1]
]
print(*find_missing_chars(test_lst5, "A"))
# [['A', 'A', 7, 'A', 5, 'A', 'A', 17], 1] [['A', 'A', 'A', 5, 7], 1] [[17, 'A', 'A', 'A', 'A', 5], 0] [[5, 7, 'A'], 1]
test_lst6 = [
[[20, 3, 7, 4, 5, 11, 2, 17], 1],
[[1, 2, 3, 5, 7], 1],
[[17, 3, 6, 1, 2, 5], 0],
[[5, 7, 3], 1],
[[1, 25, 7, 3], 0]
]
print(*find_missing_chars(test_lst6, "A"))
# [['A', 3, 7, 'A', 'A', 'A', 'A', 17], 1] [['A', 'A', 3, 'A', 7], 1] [[17, 3, 'A', 'A', 'A', 'A'], 0] [['A', 7, 3], 1] [['A', 'A', 7, 3], 0]
Kodu paylasirsaniz burada cozum denemek isteyen birkac insan cikacaktir. Pratik oluyor bize de.
Cozum uzayinin 34! yerine 2^34 oldugunu anlamak bile inanilmaz bir hiz farki yaratiyor.
Yukarida yazdiklarimi tekrar okumak ve arastirmak isteyebilirsiniz.
Kodu paylasirsaniz burada cozum denemek isteyen birkac insan cikacaktir. Pratik oluyor bize de.
Evet bunu yapan cikti bile (ben bu cevabi yazarken, @dildeolupbiten ). Fakat dandik (ve cozumu kolay) 4 kume ornegi uzerinden gitmis. Artik daha guzel ornekler bulmak veya uretmek farz oldu.
Haklısın, örnekler biraz saçma olmuş.
Bu arada fonksiyonu şöyle değiştiriyorum, gereksiz yere uzatmışım.
def find_missing_chars(arr2d: list[list[list, int]], char: str) -> list:
for arr in arr2d:
arr1d, state = arr
if arr1d.count(char) != state:
for j in arr1d:
if j != char:
arr2d_without_j = [[[i if i != j else char for i in arr[0]], arr[1]] for arr in arr2d]
if not all(len(set(i[0])) == 1 for i in arr2d_without_j):
result = find_missing_chars(arr2d_without_j, char)
if all(i[0].count(char) % 2 == i[1] for i in result):
return result
return arr2d
Şöyle yapalım:
import random
test = [
[
[random.randint(1, 20) for j in range(random.randint(2, 6))],
random.randint(0, 1)
]
for i in range(8)
]
print(test)
print(*find_missing_chars(test, "A"))
[[[7, 8, 13, 2, 2, 15], 1], [[9, 1], 1], [[5, 4, 12, 19], 0], [[3, 20], 0], [[14, 3], 0], [[3, 6, 6], 1], [[17, 1, 19], 1], [[19, 20, 14, 6, 5, 18], 0]]
[['A', 8, 13, 2, 2, 15], 1] [['A', 1], 1] [[5, 4, 12, 19], 0] [['A', 'A'], 0] [['A', 'A'], 0] [['A', 'A', 'A'], 1] [['A', 1, 19], 1] [[19, 'A', 'A', 'A', 5, 'A'], 0]
import random
test = [
[
[random.randint(1, 20) for j in range(random.randint(1, 6))],
random.randint(0, 1)
]
for i in range(8)
]
print(test)
print(*find_missing_chars(test, "A"))
[[[13, 8, 13], 1], [[18, 11, 6, 4, 4], 1], [[16, 15, 18, 7, 12], 1], [[12, 1, 18], 0], [[18, 17, 5, 7], 0], [[16, 4, 9, 12], 0], [[14, 10, 1], 1], [[17, 9, 19, 13, 17, 19], 1]]
[['A', 'A', 'A'], 1] [['A', 11, 6, 4, 4], 1] [['A', 'A', 'A', 'A', 'A'], 1] [['A', 1, 'A'], 0] [['A', 'A', 'A', 'A'], 0] [['A', 4, 9, 'A'], 0] [['A', 10, 1], 1] [['A', 9, 'A', 'A', 'A', 'A'], 1]
import random
test = [
[
[random.randint(1, 20) for j in range(random.randint(1, 6))],
random.randint(0, 1)
]
for i in range(10)
]
print(test)
print(*find_missing_chars(test, "A"))
[[[3, 13, 4, 3, 16], 1], [[13, 6, 4, 10, 1], 1], [[15], 1], [[18], 1], [[3, 16], 0], [[2], 0], [[5, 20, 20], 0], [[12, 9, 15, 1, 17, 19], 0], [[8, 5, 12], 1], [[11, 4], 1]]
[['A', 'A', 'A', 'A', 'A'], 1] [['A', 'A', 'A', 'A', 'A'], 1] [['A'], 1] [['A'], 1] [['A', 'A'], 0] [[2], 0] [[5, 20, 20], 0] [['A', 'A', 'A', 'A', 'A', 'A'], 0] [[8, 5, 'A'], 1] [[11, 'A'], 1]
Yani, random olarak üretilen her test verisi de çözülebilir olmayabilir(?). Bu yukardakiler çözülebilmiş olanlar.
Senin yaptigini elestirmiyorum; sartlar altinda yapabileceginin en iyisi. Hatta ekstra adim gidip rastgele ornek uretmissin.
Fakat bazen cogu zaman guzel ornekler de zor Sudoku puzzle’lari gibi tasarlanmis oluyor.
Su zor 34’lu ornegi gorseydim ve senin-benim kodlarimizla cozulmeseydi CNF’e cevirip SAT solver’a vermeyi deneyebilirdim mesela.
Yok, eleştiriden ben kendi adıma pay çıkarıyorum sadece. Evet, elimizde deneyeceğimiz bir test yok. Ya OP’un paylaştığı testi çözmekten ya da çözülmeme riskini alarak random testler oluşturmaktan başka bir şey yapamıyoruz. Ben de, hem orijinal puzzle’ı, hem de OP’un da nasıl bir yöntem izlediğini merak ediyorum doğrusu.
Maalesef bahsettiğin kavramlar hakkında pek bilgim yok ama merak ettim ne olduklarını. Şöyle kısa bir göz atınca CNF’in Boolean Logic’e ait bir kavram olduğuna dair yazılar okudum. Bilmiyorum, bir ara fırsatım olursa daha fazla araştırırım.
from itertools import combinations
import pandas as pd
import numpy as np
from google.colab import files
# Veriler------------------------------
# Sadece aşağıdaki rakamlar ve çift tek kısımları değişltirilecek.
# Sonra yukarıdaki menüde Çalışma Zamanı --> Tümünü Çalıştır.
kume_1 = [[ 9,6,9,9,7,7,], "cift"]
kume_2 = [[ 9,9,6,6,9,9,7,10,], "tek"]
kume_3 = [[ 9,9,9,11,7,], "cift"]
kume_4 = [[ 7,9,9,9,7,9,9,10,10,], "cift"]
kume_5 = [[ 4,14,4,14,10,14,13,14,13,], "cift"]
kume_6 = [[ 14,13,14,13,10,14,13,13,], "cift"]
kume_7 = [[ 6,4,6,6,5,14,], "tek"]
kume_8 = [[ 8,14,8,5,4,14,13,], "tek"]
# -------------------------------------
tum_kumeler = [kume_1, kume_2, kume_3, kume_4, kume_5, kume_6, kume_7, kume_8]
kullanilan_sayilar = []
for kume in tum_kumeler:
for sayi in kume[0]:
if sayi not in kullanilan_sayilar:
kullanilan_sayilar.append(sayi)
kullanilan_sayilar.sort()
print("Kullanılan Sayılar: ",kullanilan_sayilar )
def sub_lists (l):
comb = []
for i in range(len(l)+1):
comb += [list(j) for j in combinations(l, i)]
return comb[1:]
def conver_str(l):
result_list = []
for x in l:
string = ""
for y in x:
string +=str(y) + ','
result_list.append(string[:-1])
return (result_list)
df = pd.DataFrame(columns = ["Küme 1 " + kume_1[1], "Küme 2 " + kume_2[1], "Küme 3 " + kume_3[1], "Küme 4 " + kume_4[1], "Küme 5 " + kume_5[1], "Küme 6 " + kume_6[1], "Küme 7 " + kume_7[1], "Küme 8 " + kume_8[1]],
index = conver_str(sub_lists(kullanilan_sayilar)))
df.head(5)
for x in range(len(df.index)):
for y in range(len(df.columns)):
sum = 0
for z in df.index[x].split(','):
sum += tum_kumeler[y][0].count(int(z))
df.iloc[x,y] = sum
df.head(5)
df_result = pd.DataFrame(index = df.index,
columns = list(df.columns) + ["Sonuç"])
for row in df.index:
for col in df.columns:
if (df.loc[row, col] % 2 == 0 and col[-1] == "t") or (df.loc[row, col] % 2 != 0 and col[-1] == "k"):
df_result.loc[row,col] = 'P'
else:
df_result.loc[row,col] = 'N'
row_result = list(df_result.loc[row])
if row_result.count('P') == 4:
df_result.loc[row, "Sonuç"] = 'A'
elif (row_result[2] == 'N' or row_result[3] == 'N'):
df_result.loc[row, "Sonuç"] = 'B'
elif (row_result[0] == 'P' and row_result[1] == 'P'):
df_result.loc[row, "Sonuç"] = 'C'
elif (row_result[0] == 'N' or row_result[1] == 'N'):
df_result.loc[row, "Sonuç"] = 'D'
elif (row_result[0] == 'P' or row_result[1] == 'P'):
df_result.loc[row, "Sonuç"] = 'E'
elif row_result.count('B') == 4:
df_result.loc[row, "Sonuç"] = 'F'
df_result.sort_values(by=['Sonuç']).head()
df_result.sort_values(by=['Sonuç']).to_excel("Sonuçlar.xlsx")
files.download('Sonuçlar.xlsx')
Paylaştığım kodu Google Colab üzerinden bir arkadaşım oluşturmuştu. Kod, çıktı olarak her bir küme için P ve N durumları üretiyor. P, bir kümede hangi rakamları değiştirirsek şartı sağlıyor; N ise hangi rakamları değiştirirsek şartları sağlamıyor, onu gösterir. Ben çıktıdaki sonuçları “PPPPP” veya “PNPPPP” formatında birleştiriyorum excelde. Sonra "Z’ den A’ ya sırala"yıp, PPPPP durumunu sağlayan rakamlar listesine ulaşıyorum. Yani bu rakamları değiştirirsek, tüm kümeler için aynı anda “çifte tamamlama” durumu sağlanıyor. Tabi her zaman PPPPP durumu olmayabiliyor. Bazen tüm seçenekleri de deneseniz, tüm kümelerde aynı anda şart sağlanamıyor. Mesela en fazla PNPPP gibi bir şey ortaya çıkıyor ki bu da olağan bir sonuç. Kısacası tüm kümelerde aynı anda şartı sağlayan rakamlar bütünü yoksa bile, bir sonraki en yakın seçeneği esas alıyoruz. Kod, bu şekilde çalışıyor. Aslında istenildiği gibi çalışıyor fakat 28 küme ve toplam 34 rakam olunca iş hiç bitmeyecek kadar uzun sürüyor. İlginçtir ki bu konuya çözüm bulana da bugüne kadar rastlamadm, ilk kez siz bir şeyler ortaya koyabiliyorsunuz.