Pchełki Python: zabawa w gematrię

Gematria, wynalazek pochodzący z czasów starożytnej Babilonii, spopularyzowała się głównie za sprawą Żydów. Oni bowiem zaczęli kombinować nad znaczeniem wartości liczbowych poszczególnych słów i zdań w Biblii wyliczonych jako suma wartości pojedynczych liter.

My się dziś Biblią bawić nie będziemy, ale pomysł z ponumerowaniem liter jest całkiem niezły – spróbujemy sobie dziś znaleźć liczbę, która reprezentuje samą siebie.

Zaczniemy od początku:

  1. Bierzemy alfabet polski (czyli ze wszystkimi ogonkami, ale za to bez q, v i x) – razem 32 litery
  2. Każdej literze przypisujemy wartość będącą numerem kolejnym danej litery w alfabecie. Czyli A=1, Ą=2, B=3 i tak dalej aż do Ż=32
  3. Bierzemy liczbę 1, zapisujemy ją słownie: JEDEN.
  4. Liczymy: J + E + D + E + N = 13 + 7 + 6 + 7 + 18 = 51
  5. Bierzemy następną liczbę: DWA
  6. D + W + A = 6 + 28 + 1 = 35

I tak dalej. Czy trafimy w końcu na liczbę, której suma wartości liter będzie się równać tej właśnie liczbie? Jeżeli tak, co to za liczba?

A czy jest liczba, której suma liter jest dwukrotnie większa od niej samej? A trzykrotnie? A dziesięciokrotnie?

Zaczniemy od przypadku trywialnego, czyli poszukamy liczby, której litery sumują się [1] do niej samej.

[1] Powinienem napisać “której wartości liter sumują się”, ale jestem za leniwy.

Żeby nie wynajdować koła, skorzystamy z gotowej biblioteki przekształcającej liczbę na tekst. Biblioteka autorstwa Jakuba Wilka, instalujemy za pomocą PIP:

Teraz już możemy przystąpić do zabawy właściwej:

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"

for i in range(1000):
    s = slownie(i)
    if(sum([litery.index(litera) for litera in s]) == i):
        print(s)

Objaśnienie dla spostrzegawczych: alfabet zacząłem od spacji, co daje nam podwójną korzyść: po pierwsze spacja ma wartość zero, a po drugie litera “A” ma wartość jeden, czyli dokładnie tak, jak powinno być.

Powyższy kod wyrzuci nam na ekran tylko jedną linijkę:

dwieście dziewięć

Faktycznie:

D + W + I + E + Ś + C + I + E + D + Z + I + E + W + I + Ę + Ć = 6 + 28 + 12 + 7 + 25 + 4 + 12 + 7 + 6 + 30 + 12 + 7 + 28 + 12 + 8 + 5 = 209

Spróbujmy sobie teraz skomplikować życie i poszukajmy liczb, których litery zapisu słownego sumują się do ich wielokrotności. W tym celu wprowadzimy sobie mnożnik od 1 do 200 i posprawdzamy:

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"

for i in range(100000):
    s = slownie(i)
    suma = sum([litery.index(litera) for litera in s])
    for mnoznik in range(1, 201):
        if(suma * mnoznik == i):
            print(s, "=", suma, "*", mnoznik)

Tu już program wypluje nam całkiem sporo bo aż 153 trafienia:

dwieście dziewięć = 209 * 1
tysiąc pięćset trzydzieści dziewięć = 513 * 3
dwa tysiące pięćset dwa = 278 * 9
dwa tysiące dziewięćset czterdzieści = 490 * 6
trzy tysiące sto sześćdziesiąt dwa = 527 * 6
trzy tysiące dwieście osiemdziesiąt dwa = 547 * 6
trzy tysiące sześćset = 360 * 10
cztery tysiące sześćset dziewięćdziesiąt siedem = 671 * 7
pięć tysięcy dwieście osiemdziesiąt trzy = 587 * 9
pięć tysięcy czterysta dwanaście = 451 * 12
(bla, bla, bla...)
dziewięćdziesiąt trzy tysiące pięćset siedemdziesiąt trzy = 843 * 111
dziewięćdziesiąt trzy tysiące osiemset osiem = 656 * 143
dziewięćdziesiąt trzy tysiące dziewięćset pięćdziesiąt pięć = 817 * 115
dziewięćdziesiąt pięć tysięcy trzysta czterdzieści dziewięć = 859 * 111
dziewięćdziesiąt pięć tysięcy pięćset osiemdziesiąt dziewięć = 817 * 117
dziewięćdziesiąt sześć tysięcy sześćset czterdzieści dwa = 819 * 118
dziewięćdziesiąt siedem tysięcy dziewięćset dwadzieścia dziewięć = 837 * 117
dziewięćdziesiąt osiem tysięcy sto trzy = 617 * 159
dziewięćdziesiąt osiem tysięcy pięćset trzydzieści dwa = 782 * 126

A co jeżeli przypiszemy literom wartości w odwrotnej kolejności? Czyli od Ż = 1 do A = 32?

from slownie import slownie

litery = "aąbcćdeęfghijklłmnńoóprsśtuwyzźż "[::-1]

for i in range(10000):
    s = slownie(i)
    suma = sum([litery.index(litera) for litera in s])
    if(suma == i):
        print(s)

Okazuje się, że tu są dwa trafienia:

czterysta dwadzieścia dwa
czterysta dziewięćdziesiąt dwa

Oczywiście możliwości są nieskończone. Można na przykład przypisać kolejnym literom wartości odpowiadające kolejnym liczbom pierwszym, a więc A=2, Ą=3, B=5, C=7, Ć=11 i tak dalej aż do Ż=137:

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"
pierwsze = [0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137]

for i in range(50000):
    s = slownie(i)
    suma = sum([pierwsze[litery.index(litera)] for litera in s])
    if(suma == i):
        print(s)

(zero na początku listy ma tu takie samo działanie jak spacja na początku alfabetu – patrz objaśnienie powyżej)

Wynik:

tysiąc pięćdziesiąt jeden
tysiąc sześćset siedemdziesiąt jeden

Jeżeli odwrócimy alfabet (A=137, Ą=131, B=127 aż do Ż=2), dostaniemy:

from slownie import slownie

litery = "aąbcćdeęfghijklłmnńoóprsśtuwyzźż "[::-1]
pierwsze = [0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137]

for i in range(50000):
    s = slownie(i)
    suma = sum([pierwsze[litery.index(litera)] for litera in s])
    if(suma == i):
        print(s)

Wynik: brak!

Można też całkiem od czapy ponadawać kolejnym literom wartości odpowiadające kolejnym cyfrom liczby Pi:

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"
pi = [0,3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3,3,8,3,2,7,9,5]

for i in range(50000):
    s = slownie(i)
    suma = sum([pi[litery.index(litera)] for litera in s])
    if(suma == i):
        print(s)

Wynik:

dziewięćdziesiąt

… albo zastąpić Pi podstawą logarytmu naturalnego:

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"
e = [0,2,7,1,8,2,8,1,8,2,8,4,5,9,0,4,5,2,3,5,3,6,0,2,8,7,4,7,1,3,5,2,6]

for i in range(50000):
    s = slownie(i)
    suma = sum([e[litery.index(litera)] for litera in s])
    if(suma == i):
        print(s)

Wynik:

osiemdziesiąt siedem

… albo policzyć sumę kwadratów…

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"

for i in range(100000):
    s = slownie(i)
    suma = sum([litery.index(litera)**2 for litera in s])
    if(suma == i):
        print(s)

Wynik:

jedenaście tysięcy osiemset siedemdziesiąt dwa

… albo kwadrat sumy…

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"

for i in range(500000):
    s = slownie(i)
    suma = sum([litery.index(litera) for litera in s])
    if(suma**2 == i):
        print(s)

Wynik:

dwieście pięćdziesiąt jeden tysięcy jeden

… albo poustawiać litery tak, że najpierw idą wszystkie samogłoski a dopiero potem spółgłoski…

from slownie import slownie

litery = " aąeęioóuybcćdfghjklłmnńprsśtwzźż"

for i in range(100000):
    s = slownie(i)
    suma = sum([litery.index(litera) for litera in s])
    if(suma == i):
        print(s)

Wynik:

sto pięć
trzysta siedemdziesiąt pięć
czterysta sześćdziesiąt trzy

… albo na odwrót…

from slownie import slownie

litery = " bcćdfghjklłmnńprsśtwzźżaąeęioóuy"

for i in range(100000):
    s = slownie(i)
    suma = sum([litery.index(litera) for litera in s])
    if(suma == i):
        print(s)

Wynik: brak 🙂

… albo brać liczby parami i sprawdzać czy suma liter w parze jest równa sumie pary:

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"

for i in range(1000):
    for j in range(i, 1000):
        s1 = slownie(i)
        s2 = slownie(j)
        s = s1 + " " + s2
        suma = sum([litery.index(litera) for litera in s])
        if(suma == i + j):
            print(s1, ",", s2)

Wynik:

zero , czterysta sześćdziesiąt
dwa , dwieście siedem
dwa , czterysta dwadzieścia sześć
cztery , czterysta cztery
[...]
czterysta trzydzieści dziewięć , czterysta dziewięćdziesiąt jeden
czterysta czterdzieści trzy , czterysta dziewięćdziesiąt osiem
czterysta czterdzieści osiem , czterysta dziewięćdziesiąt trzy
czterysta czterdzieści dziewięć , czterysta pięćdziesiąt dziewięć
czterysta osiemdziesiąt trzy , czterysta dziewięćdziesiąt dziewięć
czterysta osiemdziesiąt dziewięć , czterysta dziewięćdziesiąt trzy

(łącznie 341 kombinacji)

Ciekawe która z liczb mniejszych od sumy własnych liter jest największa…

from slownie import slownie

litery = " aąbcćdeęfghijklłmnńoóprsśtuwyzźż"
maxsuma, maxi = 0, 0
for i in range(100000):
    s = slownie(i)
    suma = sum([litery.index(litera) for litera in s])
    if(i > maxi and i < suma):
        maxsuma, maxi = suma, i
print(maxi, maxsuma)

Wynik:

499 505

499 czyli “czterysta dziewięćdziesiąt dziewięć” po zsumowaniu wartości liter daje 505 i to jest największa liczba mniejsza od sumy swoich liter. Fascynujące, prawda?

W zasadzie mógłbym ten wpis ciągnąć jeszcze przez dobre trzy godziny (liczby można przedstawiać w różnych językach!), ale mi się już znudziło 🙂

A więc – kończymy.

Albo nie, jeszcze jedno: jaka jest najmniejsza dodatnia liczba, której suma wartości liter daje aktualny numer roku (2020)?

Mi się udało znaleźć 13269499994 (trzynaście miliardów dwieście sześćdziesiąt dziewięć milionów czterysta dziewięćdziesiąt dziewięć tysięcy dziewięćset dziewięćdziesiąt cztery) – ale pewnie przy odrobinie sprytu dałoby się znaleźć mniejszą…

Pomysły?

Zapisz się
Powiadom o
guest
0 komentarzy
Inline Feedbacks
Zobacz wszystkie komentarze
0
Zapraszam do skomentowania wpisu.x
()
x