Belli özelliklere sahip sayı kombinasyonlarını Python nasıl bulabilirim?

[efdal1]

selam, aşağıdaki örnektekine benzer sayılar bulmak istiyorum:

A SÜTUNU / B SÜTUNU / TOPLAM

64 380 444
48 276 324
53 300 353
44 324 368
16 150 166
31 200 231
36 225 261

                                                    2147 = 19'a tam bölünüyor. 19x113 = 2147

a ve b sütundaki digitleri tek tek topladığımızda ise 113’e eşit oluyor.

yani: 6+4+3+8+0… = 113

bu 19’un katı olan sayı için. ben bu denklemde 19 değil de örneğin 12’nin 113 katı olan 1356 sayısı için aynı denkliği kurmak istiyorum ve uygun sayıları bana bulması için Python kullanmak istiyorum.

yani

A SÜTUNU / B SÜTUNU / TOPLAM
X Y Z
" " "
" " "
" " "
… = 1356 (12X113)

X+Y… = 113

şeklinde…

[keyshout]

import random

istenen_deger = 113
istenen_sayi = 1356

while True:

    a1 = random.randint(10,99)
    print(a1)
    b1 = random.randint(100,999)
    print(b1)
    c1 = a1 + b1
    print(c1)

    a1 = str(a1)
    b1 = str(b1)
    c1 = str(c1)

    karakter_toplami1 = int(a1[0]) + int(a1[1]) + int(b1[0]) + int(b1[1]) + int(b1[2])

    a2 = random.randint(10,99)
    print(a2)
    b2 = random.randint(100,999)
    print(b2)
    c2 = a2 + b2
    print(c2)

    a2 = str(a2)
    b2 = str(b2)
    c2 = str(c2)

    karakter_toplami2 = int(a2[0]) + int(a2[1]) + int(b2[0]) + int(b2[1]) + int(b2[2])

    a3 = random.randint(10,99)
    print(a3)
    b3 = random.randint(100,999)
    print(b3)
    c3 = a3 + b3
    print(c3)

    a3 = str(a3)
    b3 = str(b3)
    c3 = str(c3)

    karakter_toplami3 = int(a3[0]) + int(a3[1]) + int(b3[0]) + int(b3[1]) + int(b3[2])

    a4 = random.randint(10,99)
    print(a4)
    b4 = random.randint(100,999)
    print(b4)
    c4 = a4 + b4
    print(c4)

    a4 = str(a4)
    b4 = str(b4)
    c4 = str(c4)

    karakter_toplami4 = int(a4[0]) + int(a4[1]) + int(b4[0]) + int(b4[1]) + int(b4[2])

    a5 = random.randint(10,99)
    print(a5)
    b5 = random.randint(100,999)
    print(b5)
    c5 = a5 + b5
    print(c5)

    a5 = str(a5)
    b5 = str(b5)
    c5 = str(c5)

    karakter_toplami5 = int(a5[0]) + int(a5[1]) + int(b5[0]) + int(b5[1]) + int(b5[2])

    a6 = random.randint(10,99)
    print(a6)
    b6 = random.randint(100,999)
    print(b6)
    c6 = a6 + b6
    print(c6)

    a6 = str(a6)
    b6 = str(b6)
    c6 = str(c6)

    karakter_toplami6 = int(a6[0]) + int(a6[1]) + int(b6[0]) + int(b6[1]) + int(b6[2])

    a7 = random.randint(10,99)
    print(a7)
    b7 = random.randint(100,999)
    print(b7)
    c7 = a7 + b7
    print(c7)

    a7 = str(a7)
    b7 = str(b7)
    c7 = str(c7)

    karakter_toplami7 = int(a7[0]) + int(a7[1]) + int(b7[0]) + int(b7[1]) + int(b7[2])

    karakter_toplami = karakter_toplami1 + karakter_toplami2 + karakter_toplami3 + karakter_toplami4 + karakter_toplami5 + karakter_toplami6 + karakter_toplami7

    sayi_toplami = int(c1) + int(c2) + int(c3) + int(c4) + int(c5) + int(c6) + int(c7)

    print(istenen_deger)
    print("bitti")

    if istenen_deger == karakter_toplami:
        if istenen_sayi == sayi_toplami:
            break
        else:
            continue

Rastgele üretilen tüm değerleri görmek için print() fonksiyonu ekledim. İsterseniz onu kaldırabilirsiniz.

[efdal1]

sağ olasın büyük emek…

[sonsuz]

Bir sayının basamaklarını toplamak için şöyle basit bir fonksiyon yazılabilir.

def basamaktopla(sayi):
    toplam = 0
    while sayi>0:
        toplam += sayi % 10
        sayi = sayi // 10
    return toplam

[dildeolupbiten]

Merhaba,

İlginç bir soru. Daha doğrusu, bulmacada kullanılan bazı sabit sayıların özellikle seçilme nedeni var mı öğrenmek isterim. Nedir bu sabit sayılar?

1. Birinci hedef toplam 113
2. Çarpan sayısı 19
3. 7x2’lik bir matris.
4. Birinci sütunda yer alan 2 basamaklı sayılar (Matris içinde 09 gibi sayıların yer alması da bulmacayı çözebilir.)
5. İkinci sütunda yer alan 3 basamaklı sayılar (Matris içinde 009 gibi sayıların yer alması da bulmacayı çözebilir.)

Şimdi, bulmacada yer alan bu özelliklerin, bulmacayı çözülebilir kılan özellikler olup olmadığı konusunda şüphelerim var. Belki yanılıyorum, bilemiyorum gerçekten. Sizin paylaştığınız ilk bulmacayı çözen ve bu yukardaki özelliklere sahip alternatif matrisler oluşturan bir algoritma yazdım. Ancak tesadüfen mi çözüyor yoksa uygun değerler bunlar olduğu için mi çözülüyor emin olamıyorum. Daha sonra da yukardaki özellikleri değiştirerek, hangi özellik kombinasyonunda bulmacaların çözülebilir olduğunu araştırmaya giriştim.

import time
import numpy as np


def random_arr_with_target_sum(targets, timeout):
    array = np.random.randint(1, 9, targets[0] * 5).reshape(targets[0], 5)
    start = time.perf_counter()
    while diff := targets[2] - array.sum():
        if time.perf_counter() - start >= timeout:
            return []
        step = 1 if diff > 0 else -1
        if np.all((array[:, 3] == 0) | (array[:, 0] == 1) | (array[:, 2] == 1)):
            array = np.random.randint(1, 9, targets[0] * 5).reshape(targets[0], 5)
        row = np.random.choice(range(targets[0]))
        if abs(diff) >= 100:
            col = 2
            condition = array[row][col] != (1 if diff < 0 else 9)
        elif 100 > abs(diff) >= 10:
            col = np.random.choice([0, 3])
            condition = array[row][col] != ((0 if col else 1) if diff < 0 else 9)
        else:
            col = np.random.choice([1, 4])
            condition = array[row][col] != (0 if diff < 0 else 9)
        if condition:
            array[row][col] += step
    return array


def merge_columns(arr, col_groups):
    if len(arr):
        return np.column_stack(
            tuple(
                np.array(tuple(map(lambda i: int("".join(map(str, i))), arr[:, group]))).reshape(-1, 1)
                for group in col_groups
            )
        )


def change_random_arr_with_target_sums(targets, timeout):
    array = random_arr_with_target_sum(targets, timeout)
    if not len(array):
        return []
    target_sum = np.prod(targets[1:])
    start = time.perf_counter()
    while diff := target_sum - merge_columns(array, [(0, 1), (2, 3, 4)]).sum():
        if time.perf_counter() - start >= timeout:
            return []
        if np.all((array[:, 0] == 1) & (array[:, 3] == 0) & (array[:, 2])):
            array = random_arr_with_target_sum(targets, timeout)
            if isinstance(array, list):
                return []
        step = 1 if diff > 0 else -1
        if abs(diff) >= 100:
            row1, col1 = np.random.randint(0, targets[0]), 2
            row2, col2 = np.random.randint(0, targets[0]), np.random.choice([1, 4])
            condition = (
                array[row1][col1] != (1 if diff < 0 else 9)
                and
                array[row2][col2] != (9 if diff < 0 else 0)
            )
        else:
            row1, col1 = np.random.randint(0, targets[0]), np.random.choice([0, 3])
            row2, col2 = np.random.randint(0, targets[0]), np.random.choice([1, 4])
            condition = (
                array[row1][col1] != ((0 if col1 else 1) if diff < 0 else 9)
                and
                array[row2][col2] != (9 if diff < 0 else 0)
            )
        if condition:
            array[row1][col1] += step
            array[row2][col2] -= step
    return array

Şimdi, change_random_arr_with_target_sums fonksiyonunu aşağıdaki argümanlarla çağırıyorum:

result = change_random_arr_with_target_sums(targets=[7, 19, 113], timeout=.1)
print(result)
print(merge_columns(result, col_groups=[(0, 1), (2, 3, 4)]))

Şöyle bir çıktı aldım:

[[1 5 5 0 9]
 [1 5 1 0 6]
 [1 9 3 2 9]
 [3 3 1 3 4]
 [1 3 1 0 4]
 [1 4 1 0 3]
 [4 5 7 0 8]]
[[ 15 509]
 [ 15 106]
 [ 19 329]
 [ 33 134]
 [ 13 104]
 [ 14 103]
 [ 45 708]]

Bu parametreler ile fonksiyonu çağırdığımızda, bulmaca her zaman çözülebiliyor. Başlangıçta verdiğimiz koşulları sağlayan, birçok alternatif listeyi hızlıca oluşturuyor.

Mesela bu da, targets=[7, 19, 113] parametrelerine göre üretilen başka bir matris:

[[5 2 6 0 3]
 [1 4 1 0 8]
 [4 5 1 0 6]
 [2 4 7 5 5]
 [2 0 1 0 5]
 [6 6 1 0 7]
 [3 5 1 0 7]]
[[ 52 603]
 [ 14 108]
 [ 45 106]
 [ 24 755]
 [ 20 105]
 [ 66 107]
 [ 35 107]]

Aynı deneyi, targets=[7, 12, 113] parametreleri için tekrarladığımızda boş bir liste alıyoruz.

Peki, targets=[7, 12, ?] listesindeki soru işareti yerine ne gelebilir diye merak ettim. Bunun için aşağıdaki gibi bir kod ekledim:

for i in range(75, 200):
    targets = [7, 12, i]
    result = change_random_arr_with_target_sums(targets=targets, timeout=.5)
    if isinstance(result, np.ndarray):
        print(f"targets = {targets}")

Algoritmanın çözebildiği matrisler için hangi parametreler kullanıldı aşağıda paylaşıyorum:

targets = [7, 12, 81]
targets = [7, 12, 90]
targets = [7, 12, 99]
targets = [7, 12, 108]
targets = [7, 12, 117]
targets = [7, 12, 126]
targets = [7, 12, 135]
targets = [7, 12, 144]
targets = [7, 12, 153]
targets = [7, 12, 162]
targets = [7, 12, 171]
targets = [7, 12, 180]
targets = [7, 12, 189]
targets = [7, 12, 198]

Son parametrede, düzenli bir artış var.

Problem beni, izlediğim algoritmanın farklı parametrelerle oluşturulan matrisleri çözememesinin nedenini düşünmeye itiyor. Yani, targets=[7, 12, 113]'ün oluşturulamaz bir matris olduğunu iddia etmiyorum ama mesela targets=[7, 12, 40] koşullarına uyan bir 7x2’lik matris oluşturmak imkansız. Yani bu sayıların rakamlarını topladığınızda 40 yapacak, 7x2’lik matrisin değerlerini topladığımızda da 12 * 40 olacak. Bu parametreleri verirsek, çözülemez. targets=[7, 12, 113] için durumun böyle olup olmadığından emin olamıyorum. Şu yukardaki parametrelerle, 1000 kez çağırın, 1000 kez de çözülebiliyorlar. Algoritma optimizasyona da ihtiyaç duyuyor olabilir. Hedef toplama ulaşmak için rastgele üretilen matrisler üzerinde düzenleme işlemi başlıyor. Düzenleme çıkmaza girdiğinde de hedef toplama ulaşılamıyor. Çıkmaza girdiği durumları kontrol etmeye çalıştım ancak, değişerek bize ulaşan son matristeki elemanların toplamı ile, hedef toplam arasında öyle bir fark oluşuyor ki, matristeki sayıların ne birler basamağını, ne onlar basamağını, ne de yüzler basamağını değiştirmek, istenen sonucu bir türlü vermiyor. Yani toplam hedeften 1 sayı gerideysek, o hep 1, -8, 1, -8, 1, -8 şeklinde değer almaya devam ediyor. Aldığı değerler arasındaki fark 9 olacak şekilde sonsuz bir döngüde değerler sürekli değişiyor.

Mesela çözülebilir hedeflere göre, toplamın, hedef toplamdan sapma miktarını an ve an izlediğimde, diff, her defasında 9’un katları olacak şekilde yeni bir değer alıyor. En sonunda da 0 oluyor. Ve bulmaca çözülmüş oluyor.

target = [7, 19, ?] için de şöyle çıktılar geldi:

targets = [7, 19, 75]
targets = [7, 19, 76]
targets = [7, 19, 77]
targets = [7, 19, 78]
targets = [7, 19, 79]
targets = [7, 19, 81]
targets = [7, 19, 82]
targets = [7, 19, 84]
targets = [7, 19, 85]
targets = [7, 19, 86]
targets = [7, 19, 87]
targets = [7, 19, 88]
targets = [7, 19, 89]
targets = [7, 19, 90]
targets = [7, 19, 92]
targets = [7, 19, 93]
targets = [7, 19, 94]
targets = [7, 19, 95]
targets = [7, 19, 97]
targets = [7, 19, 98]
targets = [7, 19, 99]
targets = [7, 19, 100]
targets = [7, 19, 101]
targets = [7, 19, 102]
targets = [7, 19, 103]
targets = [7, 19, 104]
targets = [7, 19, 105]
targets = [7, 19, 106]
targets = [7, 19, 108]
targets = [7, 19, 109]
targets = [7, 19, 110]
targets = [7, 19, 111]
targets = [7, 19, 112]
targets = [7, 19, 113]
targets = [7, 19, 114]
targets = [7, 19, 115]
targets = [7, 19, 116]
targets = [7, 19, 117]
targets = [7, 19, 118]
targets = [7, 19, 119]
targets = [7, 19, 120]
targets = [7, 19, 121]
targets = [7, 19, 122]
targets = [7, 19, 123]
targets = [7, 19, 124]
targets = [7, 19, 125]
targets = [7, 19, 126]
targets = [7, 19, 127]
targets = [7, 19, 128]
targets = [7, 19, 129]
targets = [7, 19, 130]
targets = [7, 19, 131]
targets = [7, 19, 132]
targets = [7, 19, 133]
targets = [7, 19, 134]
targets = [7, 19, 135]
targets = [7, 19, 136]
targets = [7, 19, 137]
targets = [7, 19, 138]
targets = [7, 19, 139]
targets = [7, 19, 140]
targets = [7, 19, 141]
targets = [7, 19, 142]
targets = [7, 19, 143]
targets = [7, 19, 144]
targets = [7, 19, 145]
targets = [7, 19, 146]
targets = [7, 19, 147]
targets = [7, 19, 148]
targets = [7, 19, 149]
targets = [7, 19, 150]
targets = [7, 19, 151]
targets = [7, 19, 152]
targets = [7, 19, 153]
targets = [7, 19, 154]
targets = [7, 19, 155]
targets = [7, 19, 156]
targets = [7, 19, 157]
targets = [7, 19, 158]
targets = [7, 19, 159]
targets = [7, 19, 160]
targets = [7, 19, 161]
targets = [7, 19, 162]
targets = [7, 19, 163]
targets = [7, 19, 164]
targets = [7, 19, 165]
targets = [7, 19, 166]
targets = [7, 19, 167]
targets = [7, 19, 168]
targets = [7, 19, 169]
targets = [7, 19, 170]
targets = [7, 19, 171]
targets = [7, 19, 172]
targets = [7, 19, 173]
targets = [7, 19, 174]
targets = [7, 19, 175]
targets = [7, 19, 176]
targets = [7, 19, 177]
targets = [7, 19, 178]
targets = [7, 19, 179]
targets = [7, 19, 180]
targets = [7, 19, 181]
targets = [7, 19, 182]
targets = [7, 19, 183]
targets = [7, 19, 184]
targets = [7, 19, 185]
targets = [7, 19, 186]
targets = [7, 19, 187]
targets = [7, 19, 188]
targets = [7, 19, 189]
targets = [7, 19, 190]
targets = [7, 19, 191]
targets = [7, 19, 192]
targets = [7, 19, 193]
targets = [7, 19, 194]
targets = [7, 19, 195]
targets = [7, 19, 196]
targets = [7, 19, 197]
targets = [7, 19, 198]
targets = [7, 19, 199]

75 ile 200 arasındaki her i hedef toplam değeri için bulmaca çözülebiliyor.

@keyshout’un izlediği algoritmada da, istenen_deger ve karakter_toplamı eşitleniyor eşitlenmesine ancak targets=[7, 12, 113] parametreleriyle if istenen_sayi == sayi_toplami: sorgusunun henüz True verdiğini görmedim.

Enteresan bir konu gerçekten. Henüz çözülemedi.

[efdal1]

Selâm,

gösterdiğiniz çabadan ötürü çok müteşekkirim. ellerinize sağlık bu çabayı nasıl takdir edeceğimi bilmiyorum gerçekten.

probleme gelirsek algoritmayı daha da ilginçleştirecek ikinci bir tablodan da bahsedebiliriz:

A SÜTUNU / B SÜTUNU / TOPLAM

64 380 444
48 276 324
53 300 353
44 324 368
16 150 166
31 200 231
36 225 261

3.sütundan tabloyu ikiye bölersek yani şu şekilde:

A SÜTUNU / B SÜTUNU / TOPLAM

64 380 444
48 276 324
53 300 353
haneleri topla = 59. =1121 (19x59)

44 324 368
16 150 166
31 200 231
36 225 261
haneleri topla = 54 =1026 (19x54)

ana tablo ile ayni özelliği gösteriyor:

ab + cde = t1

fg + hij = t2

kl + mnp =t3

t1+t2+t3 = 0 mod 19

{cde | 100 ≤ b ≤ 999}
{hij | 100 ≤ d ≤ 999}
{mno | 100 ≤ f ≤ 999}

{ab | 10 ≤ a ≤ 99}
{fg | 10 ≤ c ≤ 99}
{kl | 10 ≤ e ≤ 99}

sorun şu ki: a, b’ye eşit ya da olmayabilir… bu tüm basamaklar için geçerli.

bu istem Python’da başarılı bir şekilde yazıldığında sonuç vermesi olası sanıyorum.

bu durumda t1+t2+t3=1121

t1+t2+t3 = 0 mod 19?

19x59 = 1121

a+b+c+d+e+f+g+h+i+j+k+l+m+n+o = 59

bu tablonun ilk kısmıydı diğer kısmı da kendi içinde aynı denklemi sağlıyor:

pq + rst = t4

uv + wxy = t5

öç + üğı = t6 (karakter bittiği için türkçe harf kullandım :)) Unicode da zaten var…

{rst | 100 ≤ b ≤ 999}
{wxy | 100 ≤ d ≤ 999}
{üğı | 100 ≤ f ≤ 999}

{pq | 10 ≤ a ≤ 99}
{uv | 10 ≤ c ≤ 99}
{öç | 10 ≤ e ≤ 99}

bu durumda :

t4+t5+t6 = 1026

19x1026 = 54

t4+t5+t6 = 0 mod 19?

p+q+r+s+t+u+v+w+x+y+ö+ç+ü+ğ+ı = 54

ama ayrıca: t1+t2+t3+t4+t5+t6 = 0 mod 19 olmalı…

t1+t2+t3+t4+t5+t6 = 2147

19x113 = 2147

ve

a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+ö+ç+ü+ğ+ı = 113

şimdi ilk tablodaki basit haliyle iki koşulumuz var…

x1 = 0 mod 19 (x1 = t1 + t2 + t3 + t4 + t5 + t6)

yani x1 sayısı 19’a kalansız bölünebilmeli…

y1 = a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+ö+ç+ü+ğ+ı

y1 = x1/19 olmalı…

tabloyu ikiye böldüğümüzde ortaya çıkan iki tablonun da sisteme uyması içinse:

ilk tablo:

x2= 0 mod 19 (x2 = t1+t2+t3)

y2= a+b+c+d+e+f+g+h+i+j+k+l+m+n+o

y2=x2/19

ikinci tablo:

x3= 0 mod 19 (x3= t4 + t5 + t6)

y3= p+q+r+s+t+u+v+w+x+y+ö+ç+ü+ğ+ı

y3= x3/19

cevap vermem biraz geç olduğu için lütfen kusura bakmayın. verdiğiniz kodu sisteme girdiğimde kararsız sonuçlar veriyor açıkçası anlayamadım… bu verdiğim koşullarla zihninizde daha da berraklaşacağına inanıyorum…