Bir ayçiçeğinin merkezine, çam kozalağının pullarına veya yüzyıllardır hayranlık uyandıran bir tabloya baktığımızda benzer bir düzen hissedebiliriz. Bu düzenin arkasındaki en ünlü matematiksel adaylardan biri altın orandır. Yaklaşık $1.618$ değerindeki bu sayı; geometriyi, Fibonacci dizisini ve estetik tartışmalarını aynı masada buluşturan büyüleyici bir köprüdür.

``

Altın oran nedir?

Bir doğru parçasını uzun ve kısa olmak üzere iki parçaya ayıralım. Bütün uzunluğun uzun parçaya oranı, uzun parçanın kısa parçaya oranına eşitse altın oran ortaya çıkar. Uzun parça $a$, kısa parça $b$ olmak üzere:

Bu eşitlik çözüldüğünde pozitif kök şöyledir:

Altın oranın ilginç özelliklerinden biri, karesi ve tersiyle kurduğu sade ilişkilerdir:

Sanki sayı kendi içinde küçük bir matematiksel yapboz taşıyor!

Fibonacci dizisiyle bağlantısı

Fibonacci dizisinde her sayı kendisinden önce gelen iki sayının toplamıdır:

Ardışık Fibonacci sayılarının büyük olanını küçük olana böldüğümüzde sonuç giderek altın orana yaklaşır. Örneğin $13/8 = 1.625$, $34/21 ≈ 1.619$ ve $89/55 ≈ 1.618$ olur. Bu yakınlaşma, altın oranın doğadaki spiral düzenlerle ilişkilendirilmesinin temel nedenlerinden biridir.

Bu yakınsamayı Python ile gözlemleyebiliriz:

# Fibonacci sayıları arasındaki oranların
# altın orana nasıl yaklaştığını gösterir.
a, b = 1, 1

for adim in range(2, 12):
    a, b = b, a + b
    oran = b / a
    print(f'{adim}. adım: {b}/{a} = {oran:.8f}')

Döngü her adımda yeni Fibonacci sayısını üretir ve ardışık iki değerin oranını yazdırır. Çıktıda oranların bir süre altın değerin üstüne ve altına geçtiğini, ardından $1.618$ çevresinde dengelendiğini görürüz.

Doğadaki izleri

Ayçiçeği çekirdekleri ve çam kozalağı pulları, çoğu zaman birbirine zıt yönlerde ilerleyen spiral aileleri oluşturur. Bu spirallerin sayıları sıklıkla $34$, $55$ veya $89$ gibi Fibonacci sayılarına yakındır. Böyle bir yerleşim, bitkinin sınırlı alana çok sayıda tohum ya da yaprak sığdırmasına yardımcı olabilir.

Yaprakların gövde çevresindeki dizilimi de güneş ışığına erişimi artıran açılar oluşturabilir. Altın açı olarak bilinen değer yaklaşık olarak:

Ancak her spiral altın spiral değildir. Nautilus kabuğu sıkça kusursuz örnek olarak sunulsa da gerçek kabukların büyüme oranları türden türe değişir. Doğa cetvelle çizilmiş tek bir formülden çok, çevresel koşulların ve biyolojik süreçlerin birlikte çalıştığı esnek bir sistemdir.

Sanat ve mimaride altın oran

Altın dikdörtgenin kısa kenarı $1$ ise uzun kenarı yaklaşık $1.618$ olur. Bu biçimin Mona Lisa, Parthenon ve çeşitli Rönesans eserlerinde kullanıldığı sıkça ileri sürülür. Bazı tasarımlarda oran bilinçli biçimde uygulanmış olsa da tarihsel kanıt bulunmayan örnekler de vardır.

Altın oran, güzelliği otomatik olarak üreten sihirli bir düğme değildir. Asıl değeri; büyüme, oran, geometri ve görsel düzen arasındaki bağlantıları incelememizi sağlamasıdır. Kısacası $φ$, doğanın gizli şifresinden ziyade çevremizdeki örüntüleri okumak için kullanabileceğimiz zarif bir matematiksel mercektir.

`` Diziyi oluşturmaya tek bir 0 ile başlayalım. Her adımda mevcut bölümün bitlerini ters çevirip sonuna ekleyelim:

0
01
0110
01101001
0110100110010110

Burada ters çevirme işlemi 0 → 1 ve 1 → 0 biçimindedir. Örneğin 0110 kelimesinin tümleyeni 1001 olur; ikisini birleştirince 01101001 elde edilir. Bu üretim kuralı matematiksel olarak

şeklinde yazılabilir. $\overline{T_k}$, $T_k$ içindeki bütün bitlerin tümleyenini temsil eder. Her turda uzunluk iki katına çıktığı için $k$ adımından sonra $2^k$ eleman bulunur.

Sayıların ikili gösterimiyle bağlantısı

Thue-Morse dizisinin yalnızca önceki parçayı kopyalayarak tanımlanması gerekmez. Sıfırdan başlayan $n$ indeksli terim, $n$ sayısının ikili gösterimindeki 1 sayısının tek veya çift olmasına göre hesaplanabilir.

$n$ içindeki 1 bitlerinin sayısına $s_2(n)$ dersek:

Yani 1 sayısı çiftse sonuç 0, tekse 1 olur.

Bu tanımdan kullanışlı iki bağıntı çıkar:

Çift indeksler önceki değerleri tekrar ederken tek indeksler onların tersini taşır. Dizinin fraktal karakterinin cebirsel özeti tam olarak budur.

Neden fraktala benziyor?

Fraktallarda bütünün daha küçük ölçekli kopyalarını görürüz. Thue-Morse dizisinde de her blok, daha önce oluşmuş bir bloğu ve onun renkleri değiştirilmiş hâlini içerir. Bitleri siyah ve beyaz kareler olarak çizersek farklı ölçeklerde yinelenen desenler ortaya çıkar. Ancak bu tekrar tam anlamıyla periyodik değildir.

Dizi deterministiktir; yani rastgele değildir. Buna karşın sonsuza kadar tekrar eden sabit bir periyoda da sahip değildir. Dahası, belirli türde aşırı tekrarları engelleyen overlap-free özelliğiyle kelime kombinatoriğinde önemli bir yere sahiptir.

Python ile üretelim

Aşağıdaki fonksiyon, her turun sonuna mevcut bitlerin tümleyenini ekler:

def thue_morse(iterations: int) -> str:
    sequence = "0"

    for _ in range(iterations):
        complement = "".join(
            "1" if bit == "0" else "0"
            for bit in sequence
        )
        sequence += complement

    return sequence

print(thue_morse(4))
# 0110100110010110

Tek bir terime ihtiyaç duyulduğunda bütün diziyi üretmek gereksizdir. Python’daki bit_count() yöntemi daha doğrudan bir çözüm sunar:

def thue_morse_term(n: int) -> int:
    # İkili gösterimdeki 1 sayısının paritesini döndürür.
    return n.bit_count() % 2

print([thue_morse_term(n) for n in range(16)])

İlk yöntem görsel deseni ve öz-benzerliği incelemek için, ikinci yöntemse büyük indekslerde hızlı sorgulama yapmak için uygundur.

Thue-Morse ardışıklığı, karmaşıklığın mutlaka karmaşık kurallardan doğmadığını gösteren zarif bir örnektir. Bir bit, bir tümleyen işlemi ve tekrar: Dijital dünyanın bu küçük tarifi, sonsuz ve periyotsuz bir matematik manzarası üretmeye yeter.

``

Königsberg Köprüleri Problemi

Prusya’nın Königsberg şehri, Pregel Nehri’nin ayırdığı dört kara parçası ve bunları birbirine bağlayan yedi köprüden oluşuyordu. Şehir halkının sorusu basitti: Her köprüden tam bir kez geçilen bir yürüyüş yapılabilir miydi?

Euler, kara parçalarının şekli veya köprülerin uzunluğu gibi ayrıntıların önemsiz olduğunu fark etti. Her kara parçasını bir düğüm, her köprüyü ise iki düğümü bağlayan bir kenar olarak temsil etti. Böylece fiziksel şehir, matematiksel bir grafa dönüştü.

Aynı iki kara parçası arasında birden fazla köprü bulunabildiği için ortaya çıkan yapı teknik olarak bir çoklu graftır.

Düğüm Derecesi Neden Önemlidir?

Bir düğümün derecesi, o düğüme bağlı kenarların sayısıdır ve $\deg(v)$ ile gösterilir. Bir yol sırasında ara düğüme bir kenardan girip başka bir kenardan çıkmak gerekir. Dolayısıyla kullanılan kenarlar çiftler hâlinde eşleşir. Tek dereceli düğümler ise bu eşleşmenin bozulduğu başlangıç veya bitiş noktaları olabilir.

Grafın bütün düğüm dereceleri için şu önemli eşitlik geçerlidir:

Her kenar iki uca sahip olduğundan dereceler toplamına iki katkı yapar. Bu sonuç, tek dereceli düğüm sayısının her zaman çift olduğunu da gösterir.

Königsberg grafındaki dört düğümün dereceleri $3, 3, 3$ ve $5$ idi. Yani dört düğüm de tek dereceliydi. Oysa her köprüden yalnızca bir kez geçen bir rota için tek dereceli düğüm sayısı en fazla iki olmalıdır. Sonuç: İstenen yürüyüş imkânsızdı!

Euler Yolu ve Euler Devresi

Bu koşullarda grafın, izole düğümler göz ardı edildiğinde, bağlantılı olduğu kabul edilir. Euler yolu her kenarı tam bir kez kullanır. Bu nedenle her düğümü bir kez ziyaret etmeye çalışan Hamilton yoluyla karıştırılmamalıdır.

Python ile Euler Yolu Kontrolü

Aşağıdaki fonksiyon, komşuluk listesiyle verilen bağlantılı bir grafın Euler özelliğini dereceler üzerinden sınıflandırır:

def euler_durumu(graf):
    tek_dereceliler = []

    for dugum, komsular in graf.items():
        if len(komsular) % 2 == 1:
            tek_dereceliler.append(dugum)

    if len(tek_dereceliler) == 0:
        return "Euler devresi var"
    elif len(tek_dereceliler) == 2:
        return f"Euler yolu var: {tek_dereceliler}"
    else:
        return "Euler yolu yok"

sehir = {
    "A": ["B", "B", "C"],
    "B": ["A", "A", "D"],
    "C": ["A", "D", "D"],
    "D": ["B", "C", "C", "D", "D"]
}

print(euler_durumu(sehir))

Listelerde aynı komşunun tekrarlanması paralel köprüleri temsil eder. Bir öz döngü ise düğüm derecesine iki katkı yaptığı için listede iki kez gösterilmiştir. Gerçek bir uygulamada ayrıca DFS veya BFS kullanarak grafın bağlantılı olup olmadığı doğrulanmalıdır.

Euler’in büyük başarısı belirli bir rotayı denemek değil, böyle bir rotanın var olup olamayacağını yapısal olarak kanıtlamaktı. Bugün aynı fikir; çöp toplama rotaları, ağ analizi, devre tasarımı ve DNA dizileme gibi pek çok alanda karşımıza çıkıyor. Bazen bir köprüden geçmeden önce dereceleri saymak, saatlerce dolaşmaktan çok daha akıllıcadır.

``

Önce grafın temelini kuralım

Bir graf, $G=(V,E)$ biçiminde tanımlanır. Burada $V$ düğümler, $E$ ise düğümler arasındaki kenarlardır. Düğüm sayısını $\vert V\vert =n$, kenar sayısını da $\vert E\vert =m$ ile gösterelim.

Bir grafın sahip olabileceği kenar sayısı, yönsüz ve öz döngüsüz durumda en fazla:

olur. Eğer $m$, bu üst sınıra yakınsa grafa yoğun graf; kenar sayısı düğüm sayısına yakınsa seyrek graf denir. Temsil yöntemi seçilirken asıl belirleyici çoğu zaman bu yoğunluktur.

Komşuluk matrisi

Komşuluk matrisi, $n \times n$ boyutunda iki boyutlu bir tablodur. matris[i][j] değeri, i ile j arasında kenar varsa 1, yoksa 0 olur. Ağırlıklı graflarda bu hücreye kenarın ağırlığı yazılabilir.

# Dört düğümlü yönsüz bir grafın komşuluk matrisi
matris = [
    [0, 1, 1, 0],
    [1, 0, 0, 1],
    [1, 0, 0, 1],
    [0, 1, 1, 0]
]

# 0 ve 2 arasında doğrudan kenar var mı?
print(matris[0][2] == 1)

Bu yöntemin yıldız özelliği, iki düğüm arasında kenar bulunup bulunmadığını $O(1)$ zamanda söylemesidir. Ancak grafın yalnızca birkaç kenarı olsa bile bütün hücreler ayrılır. Dolayısıyla bellek karmaşıklığı her durumda $O(V^2)$ olur.

Bir düğümün tüm komşularını bulmak için ilgili satırın tamamı gezilir. Bu işlem $O(V)$ zaman alır. Matris, özellikle yoğun graflarda ve sık kenar sorgusu yapılan uygulamalarda güçlüdür.

Komşuluk listesi

Komşuluk listesinde her düğüm için yalnızca bağlantılı olduğu düğümler tutulur. Boş bağlantılar bellekte yer kaplamaz; yani kullanılmayan koltuklara bilet kesilmez.

# Aynı grafın komşuluk listesi gösterimi
liste = {
    0: [1, 2],
    1: [0, 3],
    2: [0, 3],
    3: [1, 2]
}

# 0 düğümünün komşularını dolaş
for komsu in liste[0]:
    print(komsu)

Bu yapının bellek maliyeti $O(V+E)$ düzeyindedir. Bir düğümün komşularını dolaşmak, düğümün derecesi $d(v)$ olmak üzere $O(d(v))$ sürer. Buna karşılık belirli iki düğümün komşu olup olmadığını aramak, kullanılan liste yapısına göre $O(d(v))$ zaman alabilir. Komşular bir set içinde saklanırsa ortalama sorgu süresi $O(1)$ seviyesine indirilebilir; fakat ek bellek maliyeti oluşur.

Hızlı karşılaştırma

Hangisini seçmeliyiz?

Grafınızda binlerce düğüm fakat az sayıda bağlantı varsa komşuluk listesi açık ara daha ekonomiktir. Örneğin yol ağları, web bağlantıları ve sosyal ağların büyük bölümü seyrektir. Bu yapılarda BFS ve DFS gibi algoritmalar listeyle $O(V+E)$ zamanda çalışır; matris kullanılırsa süre $O(V^2)$ seviyesine çıkabilir.

Düğüm sayısı küçükse, graf yoğunsa veya uygulama sürekli “Bu iki düğüm bağlı mı?” diye soruyorsa komşuluk matrisi daha pratik olabilir. Floyd–Warshall gibi matris tabanlı algoritmalar da doğal olarak bu gösterimle uyumludur.

Kısacası evrensel bir kazanan yoktur: matris sorgu hızını, liste ise bellek verimliliğini öne çıkarır. Doğru seçim, grafın yoğunluğuna ve en sık yapılacak işleme bağlıdır.

Bir dizinin sonraki elemanını önceki elemanlardan üretmek oldukça doğaldır. Fibonacci dizisinde yaptığımız gibi iki sayıyı toplar, yenisini buluruz. Fakat doğrudan milyonuncu terim sorulduğunda bu yöntem biraz yorulur. Lineer homojen yinelemeli ilişkiler, dizinin bütün davranışını tek bir formülde yakalamamızı sağlayarak yinelemeyi adeta cebirsel bir kestirme yola dönüştürür.

``

Lineer homojen ilişki nedir?

Sabit katsayılı, ikinci dereceden bir lineer homojen yinelemeli ilişki genel olarak

biçimindedir. “Lineer” denmesinin nedeni önceki terimlerin kuvvetlerinin veya birbirleriyle çarpımlarının bulunmamasıdır. “Homojen” ifadesi ise eşitliğe dizi dışından eklenen bağımsız bir fonksiyon olmadığını belirtir.

Örneğin $a_n=3a_{n-1}-2a_{n-2}$ homojendir. Buna karşılık $a_n=3a_{n-1}+n$ homojen değildir; çünkü $n$ biçiminde dışarıdan gelen bir terim vardır.

Karakteristik denklem fikri

Çözümün $a_n=r^n$ biçiminde olduğunu varsayalım. Bu tahmin rastgele değildir: Üstel ifadeler kaydırıldıklarında yalnızca sabit bir çarpan kazanır. Varsayımı genel ilişkiye yerleştirirsek

elde ederiz. $r^{n-2}$ ortak çarpanına böldüğümüzde karakteristik denklem ortaya çıkar:

Denklemin birbirinden farklı iki kökü $r_1$ ve $r_2$ ise genel çözüm

olur. $A$ ve $B$ sabitleri başlangıç koşullarından bulunur. Böylece her terimi sırayla hesaplamak yerine doğrudan istenen indekse gideriz.

Fibonacci’ye uygulayalım

Fibonacci ilişkisi

şeklindedir. $F_n=r^n$ varsayımı karakteristik denklemi verir:

Kökler altın oran $phi$ ve onun eşleniğidir:

Dolayısıyla $F_n=A\phi^n+B\psi^n$ yazılır. $F_0=0$ ve $F_1=1$ koşulları kullanıldığında $A=1/\sqrt{5}$ ve $B=-1/\sqrt{5}$ bulunur. Sonuç, Binet formülü olarak bilinen zarif ifadedir:

İçinde irrasyonel sayılar bulunmasına rağmen sonuç her doğal $n$ için tam sayıdır. Bunun nedeni, iki üstel terimde oluşan irrasyonel parçaların birbirini tam olarak yok etmesidir. Ayrıca $\vert \psi\vert <1$ olduğu için büyük $n$ değerlerinde $\psi^n$ sıfıra yaklaşır. Bu nedenle yaklaşık olarak $F_n\approx \phi^n/\sqrt{5}$ denebilir.

Python ile doğrulama

Aşağıdaki kod hem yinelemeli hesaplamayı hem de kapalı formu uygular. round kullanılması, kayan noktalı işlemlerde oluşabilecek küçük hassasiyet hatalarını temizler.

from math import sqrt

def fibonacci_iteratif(n):
    onceki, simdiki = 0, 1
    for _ in range(n):
        onceki, simdiki = simdiki, onceki + simdiki
    return onceki

def fibonacci_binet(n):
    phi = (1 + sqrt(5)) / 2
    psi = (1 - sqrt(5)) / 2
    return round((phi**n - psi**n) / sqrt(5))

for n in range(11):
    print(n, fibonacci_iteratif(n), fibonacci_binet(n))

Kapalı form teorik olarak doğrudan hesaplama sağlasa da çok büyük indekslerde kayan nokta hassasiyeti sorun çıkarabilir. Bu durumda matris üs alma veya tam sayı aritmetiği daha güvenilirdir. Yine de karakteristik denklem yöntemi, dizinin büyüme hızını ve köklerin davranış üzerindeki etkisini görmenin en güçlü yollarından biridir.

``

Caesar şifresi: Alfabeyi biraz kaydıralım

Adını Roma lideri Julius Caesar’dan alan bu yöntemin askerî yazışmalarda kullanıldığı anlatılır. Her harf, alfabede sabit miktarda ileri kaydırılır. Harfleri $0$ ile $25$ arasında numaralandırırsak şifreleme işlemi şöyle gösterilir:

Şifreyi çözmek için kaydırma geri alınır:

Örneğin $k=3$ olduğunda ABC, DEF olur. Fikir zarif olsa da yalnızca 26 olası anahtar vardır. Saldırgan bütün kaydırmaları deneyerek anlamlı sonucu birkaç saniyede bulabilir. Buna kaba kuvvet saldırısı denir. Uzun metinlerde en sık görülen harfi dildeki yaygın harflerle karşılaştıran frekans analizi de kullanılabilir.

def caesar(metin, kaydirma):
    sonuc = ""
    for karakter in metin.upper():
        if "A" <= karakter <= "Z":
            kod = (ord(karakter) - ord("A") + kaydirma) % 26
            sonuc += chr(kod + ord("A"))
        else:
            sonuc += karakter
    return sonuc

print(caesar("KRIPTOGRAFI", 3))

Bu kod, yalnızca Latin alfabesindeki harfleri kaydırır; boşluk ve noktalama işaretlerini korur. Negatif kaydırma verilerek şifre çözme işlemi de yapılabilir.

Polybius karesi: Harfler koordinata dönüşüyor

MÖ 2. yüzyılda yaşamış Yunan tarihçi Polybius, karakterleri bir tablo üzerindeki koordinatlarla temsil etti. Klasik $5 \times 5$ karede I ve J aynı hücreyi paylaşır. Örneğin A 11, B 12, F ise 21 olarak yazılır.

Bu yaklaşımın önemli özelliği, harfleri sayısal çiftlere dönüştürmesidir. Böylece mesajlar meşale, ses veya işaret kombinasyonlarıyla iletilebilir. Ancak standart kare gizli değilse saldırgan koordinatları doğrudan geri çevirebilir. Karışık anahtarlı bir alfabe kullanılsa bile tek bir harf daima aynı çifte dönüştüğü için frekans analizi hâlâ etkilidir.

Vigenère: Tek kaydırma yetmezse

1. yüzyılda Blaise de Vigenère ile özdeşleşen bu yöntem, tekrar eden bir anahtar kelime kullanarak her karaktere farklı Caesar kaydırması uygular. Matematiksel olarak:

ANAHTAR gibi bir anahtar, mesaj uzunluğunca tekrarlanır. Böylece aynı düz metin harfi farklı konumlarda farklı şifreli harflere dönüşebilir. Bu nedenle Vigenère uzun süre çözülemez şifre olarak ün kazandı.

def vigenere_sifrele(metin, anahtar):
    metin = metin.upper()
    anahtar = anahtar.upper()
    sonuc, sira = "", 0

    for harf in metin:
        if harf.isalpha() and "A" <= harf <= "Z":
            kaydirma = ord(anahtar[sira % len(anahtar)]) - ord("A")
            sonuc += chr((ord(harf) - ord("A") + kaydirma) % 26 + ord("A"))
            sira += 1
        else:
            sonuc += harf
    return sonuc

Şifrenin zayıf noktası anahtarın tekrarlanmasıdır. Kasiski incelemesi, şifreli metindeki yinelenen diziler arasındaki uzaklıkları ölçerek muhtemel anahtar uzunluğunu bulur. Friedman testi ise harflerin çakışma olasılığından yararlanır. Uzunluk belirlendikten sonra metin sütunlara ayrılır ve her sütun ayrı bir Caesar şifresi gibi frekans analiziyle çözülür.

Hızlı karşılaştırma

Bu üç yöntem bize önemli bir ders verir: Bir algoritmanın karmaşık görünmesi güvenli olduğu anlamına gelmez. Küçük anahtar uzayı, tekrar eden desenler ve dilin istatistiksel yapısı saldırgana ipucu verir. Yine de bu klasikler, modern kriptografideki saldırı modelini anlamak ve kendi şifre analiz araçlarımızı geliştirmek için vazgeçilmez başlangıç noktalarıdır.

eşitliği sağlanıyorsa bu sayı bir Armstrong sayısıdır. Bu sayılara narsistik sayılar da denir. Buradaki önemli ayrıntı, her basamağın kuvvetinin sayının toplam basamak sayısına eşit olmasıdır.

Örneğin $153$ üç basamaklıdır. Dolayısıyla her basamağın üçüncü kuvveti alınır:

Sonuç yine $153$ olduğundan sayı Armstrong özelliği taşır. Buna karşılık $123$ için aynı işlem $1+8+27=36$ sonucunu verir; yani sihir gerçekleşmez.

Python ile tek sayı kontrolü

Sayıyı metne dönüştürmek, basamaklara erişmenin en okunabilir yollarından biridir:

def armstrong_mu(sayi):
    basamaklar = str(sayi)
    kuvvet = len(basamaklar)

    toplam = sum(int(basamak) ** kuvvet
                 for basamak in basamaklar)
    return toplam == sayi

for sayi in [153, 123, 370, 9474]:
    print(sayi, armstrong_mu(sayi))

Fonksiyon önce basamak sayısını belirler. Ardından her karakteri tekrar tam sayıya çevirir, uygun kuvveti hesaplar ve sonuçları toplar. Son satırda toplam ile başlangıçtaki sayı karşılaştırılır. Böylece kontrol mantığı yeniden kullanılabilir küçük bir fonksiyona dönüşür.

Metin dönüşümü kullanmadan, yalnızca aritmetik işlemlerle de basamakları ayırabiliriz. $n \bmod 10$ son basamağı verirken, $n // 10$ son basamağı sayıdan çıkarır:

def aralikta_armstrong(baslangic, bitis):
    bulunanlar = []

    for sayi in range(baslangic, bitis + 1):
        kuvvet = len(str(sayi))
        gecici = sayi
        toplam = 0

        while gecici > 0:
            basamak = gecici % 10
            toplam += basamak ** kuvvet
            gecici //= 10

        if toplam == sayi:
            bulunanlar.append(sayi)

    return bulunanlar

print(aralikta_armstrong(1, 10000))

Burada gecici değişkeni önemlidir; doğrudan sayi üzerinde bölme yapsaydık karşılaştıracağımız özgün değeri kaybederdik. Algoritma, verilen aralıktaki her sayıyı tek tek inceler.

Karmaşıklık ve optimizasyon

Üst sınır $N$, sayıların ortalama basamak sayısı da $k$ ise yaklaşık zaman karmaşıklığı $O(Nk)$ olur. Küçük aralıklarda bu son derece yeterlidir. Daha büyük aramalarda $0^k$ ile $9^k$ arasındaki sonuçları önceden bir tabloda saklamak, aynı kuvvet hesaplarını tekrar yapmayı önler.

Aynı şablon; mutlu sayılar, mükemmel sayılar ve rakamları toplamına bölünebilen Harshad sayıları gibi özel sayı problemlerine de uyarlanabilir. Değişen şey çoğunlukla basamaklara uygulanan kuraldır. Kısacası Armstrong sayıları yalnızca matematiksel bir merak değil, problemi parçalama ve temiz fonksiyon tasarlama konusunda eğlenceli bir algoritma laboratuvarıdır.

``

Bölünebilmek ne demektir?

Bir $N$ tam sayısı, $d$ sayısına bölündüğünde kalan sıfırsa $d$ ile tam bölünür. Modüler aritmetik dilinde bunu şöyle yazarız:

Örneğin $42 ≡ 0 \pmod 7$ olduğundan 42, 7’ye tam bölünür. Bir sayının ondalık gösterimi ise basamak değerleri kullanılarak açılabilir:

Bölünebilme kuralları, buradaki $10$, $100$ ve diğer kuvvetlerin ilgili bölen karşısındaki kalanlarını kullanır. Yani mesele rakamları rastgele toplamak değil, onluk sistemin davranışını değerlendirmektir.

Yaygın kurallar ve nedenleri

Neden rakamları topluyoruz?

$5832$ sayısını ele alalım. Çünkü $10 ≡ 1 \pmod 3$ olduğundan, 10’un bütün pozitif kuvvetleri de 3’e göre 1 kalanını verir:

Dolayısıyla sayı 3’e bölünür. Aynı mantık 9 için de geçerlidir. Bu nedenle rakamlar toplamı yöntemi yalnızca pratik bir numara değil, basamak açılımının doğrudan sonucudur.

11 kuralındaki işaret değiştirme

$10 ≡ -1 \pmod {11}$ olduğu için kuvvetler sırayla $1, -1, 1, -1$ biçiminde ilerler. Örneğin 2728 için dönüşümlü toplamı hesaplayalım:

Sonuç 11’in katı olduğu için 2728 de 11’e tam bölünür. Bir bakıma rakamlar matematiksel bir tahterevalliye oturur; denge 11’in katında kurulursa test başarıyla tamamlanır.

Peki ya 7?

7 kuralı biraz daha afacan görünür: Son rakamın iki katını, kalan sayıdan çıkarın. Elde edilen sonuç 7’nin katıysa başlangıçtaki sayı da 7’nin katıdır. Örneğin 203 için:

14, 7’ye bölündüğünden 203 de bölünür. Bu işlem gerekirse sonuç küçülene kadar tekrarlanabilir.

Kuralları kodlamak

Aşağıdaki Python fonksiyonu, seçilen bölen için anlaşılır kontroller uygular. Böylece kuralların bir algoritmaya nasıl dönüştüğünü görebiliriz:

def bolunur_mu(sayi, bolen):
    rakamlar = [int(rakam) for rakam in str(abs(sayi))]

    if bolen in (3, 9):
        return sum(rakamlar) % bolen == 0
    if bolen == 4:
        return abs(sayi) % 100 % 4 == 0
    if bolen == 8:
        return abs(sayi) % 1000 % 8 == 0
    if bolen == 11:
        fark = sum(rakamlar[::2]) - sum(rakamlar[1::2])
        return fark % 11 == 0

    return sayi % bolen == 0

print(bolunur_mu(2728, 11))  # True

Kod, 3 ve 9 için rakamları toplar; 4 ve 8 için yalnızca gerekli son basamakları inceler. Genel durumda ise doğrudan kalan operatörünü kullanır.

Bölünebilme kuralları, zihinden hesaplamayı hızlandırmanın ötesinde modüler aritmetiği somutlaştırır. Kuralları ezberlemek işe yarar; fakat neden çalıştıklarını bilmek, yeni bölenler için kendi yöntemlerinizi geliştirmenizi sağlar.

Catalan sayısının matematiksel tanımı

Sıfırıncı Catalan sayısı $C_0=1$ kabul edilir. Genel formül şöyledir:

Buradaki merkezi binom katsayısı, $2n$ konum içinden $n$ tanesini seçer. Ancak seçilen her dizilim geçerli değildir. Örneğin açılan parantez sayısının hiçbir noktada kapanan parantez sayısından az olmaması gerekir. Formüldeki $n+1$ bölümü, bu geçersiz düzenlemeleri ayıklayan kombinatorik düzeltmedir.

Catalan sayıları özyinelemeli olarak da hesaplanabilir:

Bu bağıntının arkasındaki fikir bölüp birleştirmedir. Bir yapı kökünden iki parçaya ayrılıyorsa sol tarafta $i$, sağ tarafta $n-i$ eleman bulunabilir. Olasılıkların çarpılması ve bütün bölünmelerin toplanması Catalan sonucunu verir.

Dengeli parantezler neden Catalan sayısıdır?

$n$ çift açma ve kapama parantezi içeren bir dizide toplam $2n$ karakter vardır. Geçerli bir dizilim iki kurala uyar:

1. Toplam açma ve kapama parantezi sayıları eşittir.
2. Soldan sağa ilerlerken kapanan parantez sayısı, açılanlardan fazla olamaz.

Örneğin (()()) geçerliyken ())(() geçersizdir. İkinci dizi toplamda eşit sayıda parantez içerse bile üçüncü karakterde henüz açılmamış bir parantezi kapatmaya çalışır. Matematik bile “Önce aç, sonra kapat!” der.

İkili ağaçlarla bağlantısı

$n$ düğümlü farklı ikili ağaç biçimlerinin sayısı da $C_n$ değeridir. Kök düğümü seçtikten sonra kalan düğümler sol ve sağ alt ağaçlar arasında dağıtılır. Sol alt ağaçta $i$ düğüm varsa sağ tarafta $n-1-i$ düğüm bulunur.

Aynı sayıların ortaya çıkmasının nedeni, bu problemlerin yüzeyde farklı olsa da aynı özyinelemeli bölünme yapısını taşımasıdır.

Python ile hesaplama

Aşağıdaki dinamik programlama yaklaşımı, özyinelemeli bağıntıyı kullanır. dp[k], $k$ boyutundaki yapıların sayısını saklar:

def catalan(n):
    dp = [0] * (n + 1)
    dp[0] = 1

    for boyut in range(1, n + 1):
        for sol in range(boyut):
            sag = boyut - 1 - sol
            dp[boyut] += dp[sol] * dp[sag]

    return dp[n]

print([catalan(i) for i in range(8)])
# [1, 1, 2, 5, 14, 42, 132, 429]

Algoritmanın zaman karmaşıklığı $O(n^2)$, alan karmaşıklığı ise $O(n)$ olur. Yalnızca tek bir $C_n$ değeri gerekiyorsa faktöriyel formülü daha hızlı olabilir; dinamik programlama ise dizinin tüm ara terimlerini üretmek ve mantığı görmek için daha öğreticidir.

Catalan sayıları, farklı problemlerin ortak matematiksel iskeletini fark etmenin harika bir örneğidir. Bir soruda dengeli parantez, ikili ağaç, köşegeni aşmayan yol veya çokgen üçgenleme görürseniz, sahne arkasında bir Catalan sayısının kostümünü giymekte olabileceğini unutmayın.

``

Temel fikir: Aynı sayı, farklı saatler

Modüler aritmetiği farklı büyüklüklerde çalışan saatlere benzetebiliriz. Örneğin

ifadesi, $x$ sayısının 3’e bölündüğünde 2 kalanını verdiğini söyler. Benzer biçimde şu sistemi ele alalım:

Burada aynı $x$, üç farklı modüler saatte belirli konumlara gelmektedir. Modüller olan 3, 5 ve 7 ikişer ikişer aralarında asaldır. Yani her farklı çift için $\gcd(m_i,m_j)=1$ koşulu sağlanır.

Çinlilerin Kalan Teoremi şunu garanti eder: Modüller ikişer ikişer aralarında asalsa sistemin, modüllerin çarpımına göre tek bir çözüm sınıfı vardır.

Başka bir deyişle çözüm $M$ aralığında benzersizdir; fakat tam sayılarda sonsuz kez tekrar eder.

Çözüm nasıl inşa edilir?

Her denklem için toplam çarpımdan ilgili modülü çıkaran bir parça oluşturulur:

Ardından $M_i$ sayısının $m_i$ modülündeki çarpımsal tersi bulunur. Bu ters $y_i$ ile gösterilirse

olmalıdır. Son çözüm şu formülle birleştirilir:

Örneğimizde $M=105$ olur. Parçalar sırasıyla 35, 21 ve 15’tir. Bunların ilgili modüllerdeki tersleri 2, 1 ve 1 olarak bulunur. Dolayısıyla

elde edilir. $233$ sayısının 105’e göre kalanı 23 olduğundan en küçük pozitif çözüm $x=23$’tür. Gerçekten de 23; 3’e bölününce 2, 5’e bölününce 3 ve 7’ye bölününce 2 kalanını verir.

Python ile genel çözüm

Aşağıdaki fonksiyon, modüllerin bağımsızlığını kontrol eder ve yapıcı formülü uygular. pow(Mi, -1, mi) ifadesi Python’da modüler tersi hesaplar.

from math import gcd, prod

def crt(kalanlar, moduller):
    # Modüllerin ikişer ikişer aralarında asal olduğunu doğrula.
    for i in range(len(moduller)):
        for j in range(i + 1, len(moduller)):
            if gcd(moduller[i], moduller[j]) != 1:
                raise ValueError('Modüller aralarında asal değil')

    M = prod(moduller)
    toplam = 0

    for ai, mi in zip(kalanlar, moduller):
        Mi = M // mi
        ters = pow(Mi, -1, mi)
        toplam += ai * Mi * ters

    return toplam % M, M

cozum, periyot = crt([2, 3, 2], [3, 5, 7])
print(cozum, periyot)  # 23 105

Fonksiyon (23, 105) döndürür. Bu sonuç yalnızca 23’ü değil, $x=23+105k$ biçimindeki bütün çözümleri temsil eder.

Modüller aralarında asal değilse

Teoremin klasik biçimi doğrudan uygulanamaz; ancak sistem mutlaka çözümsüz değildir. İki denklem için kalanların $\gcd(m_1,m_2)$ modülünde uyumlu olması gerekir. Örneğin $x\equiv1\pmod4$ ve $x\equiv3\pmod6$ sistemi uyumludur; fakat $x\equiv1\pmod4$ ve $x\equiv2\pmod6$ değildir. Kısacası CRT, farklı modüler dünyaların aynı sayıda buluşabilmesi için güçlü ve zarif bir köprü kurar.