``

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.

``

Kural tam olarak nedir?

1937 yılında Alman matematikçi Lothar Collatz tarafından ortaya atılan problem, pozitif tam sayılar üzerinde çalışan bir fonksiyonla tanımlanır:

Elde edilen sonuç tekrar aynı fonksiyona verilir. Varsayım, hangi pozitif $n$ değeriyle başlanırsa başlansın dizinin sonunda $1$ sayısına ulaşacağını söyler. Bir kez 1’e gelindiğinde $1 \rightarrow 4 \rightarrow 2 \rightarrow 1$ döngüsü oluşur.

Tek sayıdan sonra sonucun çift olması önemlidir. Çünkü $3n+1$ ifadesinde hem $3n$ hem de $n$ tek olduğundan sonuç çifttir; böylece sonraki adımda bölme işlemi garanti edilir.

Küçük sayı, uzun macera

Örneğin $n=6$ ile başlayalım:

Daha şaşırtıcı bir örnek 27’dir. Dizi hızla küçülmek yerine 9232’ye kadar yükselir ve 1’e ulaşması 111 adım sürer. Yani başlangıç sayısının küçük olması, yolculuğun kısa olacağı anlamına gelmez.

Bu düzensiz davranış, problemi kaotik bir labirente dönüştürür. Bazı adımlar sayıyı küçültürken bazıları aniden büyütür; yerel hareketlere bakarak uzun vadeli sonucu kestirmek kolay değildir.

Neden ispatlamak bu kadar zor?

Deneysel doğrulama ile matematiksel ispat aynı şey değildir. Bir bilgisayar ilk trilyonlarca başlangıç değerini kontrol edebilir; ancak pozitif tam sayılar sonsuzdur. Kontrol edilmeyen tek bir sayı bile sonsuza kaçabilir veya 1’i içermeyen farklı bir döngüye girebilir.

Sezgisel olarak tek bir adımdan ziyade, tek sayıdan sonraki bölmeleri birlikte düşünebiliriz. $3n+1$ sonucu bazen 2’ye, bazen $4$, $8$ veya daha büyük bir iki kuvvetine bölünür. Kabaca rastgelelik varsayılırsa bölmelerin uzun vadede büyümeyi dengelemesi beklenir. Fakat “beklenir” sözcüğü ispat değildir; adımlar birbirinden bağımsız rastgele olaylar değildir.

Python ile Collatz yolculuğu

Aşağıdaki fonksiyon diziyi üretir, tekrar eden bir değer görürse durur. Böylece hem 1 döngüsü hem de varsayımsal başka döngüler yakalanabilir:

def collatz_sequence(start, limit=10_000):
    if start <= 0:
        raise ValueError('Pozitif bir tam sayı girilmeli.')

    sequence = []
    seen = set()
    n = start

    while n not in seen and len(sequence) < limit:
        sequence.append(n)
        seen.add(n)

        if n == 1:
            break
        n = n // 2 if n % 2 == 0 else 3 * n + 1

    return sequence

path = collatz_sequence(27)
print('Adım sayısı:', len(path) - 1)
print('En büyük değer:', max(path))

seen kümesi daha önce ziyaret edilen değerleri hızlıca denetler. limit ise beklenmedik derecede uzun bir yürüyüşün programı süresiz çalıştırmasını engeller. Bu kod örnekleri test eder, fakat genel bir kanıt üretmez.

Basitlik neden yanıltıcıdır?

Collatz problemi, kolay ifade edilmenin kolay çözülmek anlamına gelmediğini gösterir. Ortada yalnızca çarpma, toplama ve bölme vardır; buna rağmen işlemlerin birleşimi öngörülmesi güç küresel bir davranış doğurur. Belki bütün diziler 1’e iner, belki erişilmesi inanılmaz zor bir karşı örnek vardır. İşte bu belirsizlik, $3n+1$ bilmecesini sayı teorisinin en eğlenceli ve inatçı problemlerinden biri yapar.

Bir davette herkes şapkasını vestiyere bırakıyor ve çıkışta şapkalar rastgele dağıtılıyor. Acaba hiç kimsenin kendi şapkasını almadığı kaç farklı dağıtım vardır? Kombinatorikte derangement, Türkçede düzensizleştirme olarak bilinen problem tam olarak bunu sorar. İlk bakışta yalnızca permütasyon üretip kontrol etmek yeterli görünse de teorik yaklaşım çok daha hızlı ve öğreticidir.

``

Problemin matematiksel tanımı

$n$ farklı elemanın bir permütasyonunu düşünelim. Bir eleman başlangıçtaki konumunda kalıyorsa buna sabit nokta denir. Derangement, sabit noktası bulunmayan permütasyondur.

Derangement sayısı genellikle $!n$, $D_n$ veya $d(n)$ ile gösterilir:

Küçük değerler problemi somutlaştırır:

$D_0=1$ tanımı ilk anda garip gelebilir. Ancak boş kümeyi düzenlemenin tek bir yolu vardır ve ortada kendi yerinde kalan eleman bulunmaz. Bu kabul, formüllerin düzgün çalışmasını sağlar.

Dahil etme–hariç tutma ilkesi

Toplam $n!$ permütasyon vardır. $A_i$, $i$ numaralı elemanın kendi yerinde kaldığı permütasyonlar kümesi olsun. İstenen sonuç, hiçbir $A_i$ kümesine girmeyen permütasyonların sayısıdır.

Bir elemanı sabitlersek kalanlar $(n-1)!$ şekilde, iki elemanı sabitlersek $(n-2)!$ şekilde dizilir. Dahil etme–hariç tutma ilkesi uygulandığında:

$\binom{n}{k}(n-k)!=\frac{n!}{k!}$ olduğundan daha kısa formül şöyledir:

Bu toplam, $e^{-1}$ sayısının Taylor açılımını andırır. Dolayısıyla:

Hatta tam sayı sonucu en yakın tam sayıya yuvarlayarak bulabiliriz:

Bunun ilginç sonucu şudur: $n$ büyüdükçe rastgele bir permütasyonda hiç sabit nokta bulunmama olasılığı yaklaşık $1/e$, yani yüzde $36{,}79$ olur.

Daha kullanışlı bağıntı

Derangement sayıları aşağıdaki yinelemeli bağıntıyla da hesaplanabilir:

İlk eleman başka bir konuma gönderilir. O konumdaki eleman ya ilk elemanın yerine gelir ya da üçüncü bir konuma gider. Bu iki durum sırasıyla daha küçük derangement problemlerine dönüşür.

Python ile hesaplama

Aşağıdaki fonksiyon bağıntıyı kullanır. Yalnızca son iki değeri sakladığı için ek diziye ihtiyaç duymaz:

def derangement(n):
    if n < 0:
        raise ValueError("n negatif olamaz")
    if n == 0:
        return 1
    if n == 1:
        return 0

    onceki_iki, onceki = 1, 0  # D0 ve D1

    for i in range(2, n + 1):
        simdiki = (i - 1) * (onceki + onceki_iki)
        onceki_iki, onceki = onceki, simdiki

    return onceki

for n in range(1, 9):
    print(n, derangement(n))

Program sırasıyla 0, 1, 2, 9, 44, 265, 1854, 14833 değerlerini üretir. Python tam sayıları otomatik büyüttüğü için büyük sonuçlarda taşma yaşanmaz.

Derangement; görev atama, gizli hediye çekilişi, test sorularını karıştırma ve kimsenin önceki eşleşmesini almaması gereken planlama problemlerinde kullanılır. Kısacası matematiğin düzen kurmak için bazen herkesi özellikle yanlış yere koyduğu eğlenceli örneklerden biridir.

``

İlkenin matematiksel temeli

Elimizde $n$ adet yuva ve bu yuvalara dağıtılan $n+1$ adet güvercin olsun. Her yuvada en fazla bir güvercin bulunduğunu varsayarsak yerleştirilebilecek toplam güvercin sayısı en fazla $n$ olur. Oysa elimizde $n+1$ güvercin vardır. Varsayımımız çelişkiye ulaştığı için en az bir yuvada iki veya daha fazla güvercin bulunmalıdır.

İlkenin genelleştirilmiş biçimi daha kullanışlıdır: $N$ nesne $k$ kutuya dağıtılırsa kutulardan en az biri en az

nesne içerir. Buradaki $ceil(x)$, sonucu yukarıdaki en yakın tam sayıya yuvarlar. Örneğin 100 dosya 9 sunucuya dağıtılırsa en az bir sunucuda en az $ceil(100/9)=12$ dosya bulunur.

Doğum günü örneği

Bir okulda 367 öğrenci olduğunu düşünelim. Yılın 366 gün sürebileceğini hesaba katsak bile en az iki öğrencinin doğum günü aynıdır. Öğrenciler güvercin, takvim günleri ise yuva rolündedir.

Daha güçlü bir soru soralım: 100 öğrenciden kaçının aynı ayda doğmuş olması garanti edilir? Aylar 12 yuva olduğuna göre:

Dolayısıyla hangi aylarda doğduklarını bilmeden, en az 9 öğrencinin aynı doğum ayını paylaştığını söyleyebiliriz. İlkenin büyüsü burada ortaya çıkar: Dağılımı hesaplamaz, kaçınılmaz sonucu yakalarız.

Sayı teorisinden şaşırtıcı bir kanıt

Herhangi $n+1$ tam sayı seçelim. Bu sayıları $n$ ile böldüğümüzde kalanlar yalnızca

olabilir. Yani $n$ farklı kalan yuvası vardır. Ancak $n+1$ sayı bulunduğu için iki sayı aynı kalanı verir. Bu sayılara $a$ ve $b$ dersek:

Buradan $a-b$ farkının $n$ ile tam bölündüğü sonucu çıkar. Sayıların değerlerini hiç bilmeden, aralarında $n$’nin katı olan bir fark bulunacağını kanıtladık.

Bilgisayar bilimindeki karşılığı

Hash tablolarında çok sayıda anahtar, sınırlı sayıdaki indekse eşlenir. Anahtar sayısı indeks sayısından fazlaysa çakışma kaçınılmazdır. İyi bir hash fonksiyonu çakışmayı yok etmez; dengeli dağıtmaya çalışır.

def pigeonhole_groups(values, bucket_count):
    # Sayıları kalanlarına göre sınıflandırır.
    buckets = [[] for _ in range(bucket_count)]

    for value in values:
        index = value % bucket_count
        buckets[index].append(value)

    return max(buckets, key=len)

numbers = [14, 27, 35, 42, 58, 63]
print(pigeonhole_groups(numbers, 5))

Kod, sayıları beş kalan sınıfına yerleştirir ve en kalabalık sınıfı döndürür. Altı sayı beş sınıfa dağıtıldığı için sınıflardan birinde en az iki sayı bulunacağı daha program çalışmadan garantidir.

Kanıtlarda nasıl fark edilir?

Bir problemde “en az iki tanesi”, “mutlaka aynı”, “garanti edilen minimum” veya “kaçınılmaz çakışma” ifadeleri geçiyorsa güvercin yuvası ilkesini düşünmek yararlıdır. Asıl ustalık, güvercinleri ve yuvaları doğru seçmektir. Bazen yuvalar aylar, bazen kalan sınıfları, bazen de geometrik bölgelerdir.

Bu ilke bize önemli bir matematiksel alışkanlık kazandırır: Her şeyi tek tek bulmak zorunda değiliz. Kapasite ile nesne sayısını karşılaştırmak, karmaşık görünen bir varlık kanıtını birkaç satırlık kaçınılmazlık argümanına dönüştürebilir.

``

Önce matematik: Kaç sonuç bekliyoruz?

$n$ elemanlı bir kümenin $k$ elemanlı alt kümelerinin sayısı binom katsayısıyla hesaplanır:

Örneğin $A={a,b,c,d}$ ve $k=2$ için toplam sonuç sayısı

olur. Üretilecek alt kümeler şunlardır: ${a,b}$, ${a,c}$, ${a,d}$, ${b,c}$, ${b,d}$ ve ${c,d}$.

Bir algoritmanın doğru olduğunu sınarken bu formül iyi bir kontrol mekanizmasıdır. Algoritma tam olarak ${n \choose k}$ sonuç vermeli ve hiçbir sonucu iki kez üretmemelidir.

1. Özyinelemeli geri izleme

En anlaşılır yaklaşım, her adımda bir elemanı seçip seçmemeye karar vermektir. Ancak yalnızca seçme dalını açıkça dolaşarak gereksiz adımları azaltabiliriz.

def kombinasyonlar(elemanlar, k):
    sonuc = []

    def ara(baslangic, secilenler):
        # İstenen büyüklüğe ulaştığımızda kopyayı kaydet.
        if len(secilenler) == k:
            sonuc.append(secilenler.copy())
            return

        gereken = k - len(secilenler)
        son_indeks = len(elemanlar) - gereken

        for i in range(baslangic, son_indeks + 1):
            secilenler.append(elemanlar[i])
            ara(i + 1, secilenler)
            secilenler.pop()  # Geri dön ve başka adayı dene.

    ara(0, [])
    return sonuc

print(kombinasyonlar(["a", "b", "c", "d"], 2))

baslangic değeri, daha önce kullanılan elemanlara geri dönülmesini engeller. Böylece hem tekrar oluşmaz hem de kombinasyonlar sözlük sırasına benzer bir düzende üretilir. son_indeks hesabı ise geride yeterli eleman kalmadığı bilinen dalları budar.

2. İndeksleri sözlük sırasıyla ilerletmek

Bir kombinasyonu elemanların kendisi yerine indeks dizisiyle temsil edebiliriz. Örneğin [0, 1, 3], kümenin birinci, ikinci ve dördüncü elemanlarını seçer. Her turda sağdan başlayarak artırılabilecek ilk indeks bulunur.

def sirali_k_alt_kumeler(veri, k):
    n = len(veri)
    if k < 0 or k > n:
        return

    indeksler = list(range(k))

    while True:
        yield [veri[i] for i in indeksler]

        i = k - 1
        while i >= 0 and indeksler[i] == i + n - k:
            i -= 1

        if i < 0:
            return

        indeksler[i] += 1
        for j in range(i + 1, k):
            indeksler[j] = indeksler[j - 1] + 1

Bu sürüm yield kullandığı için tüm sonuçları bellekte tutmaz. Büyük veri kümelerinde yalnızca sıradaki kombinasyona ihtiyaç duyulduğunda oldukça kullanışlıdır.

3. Bit maskesi yaklaşımı

Her elemanı bir bit ile temsil edebiliriz: 1 seçildiğini, 0 seçilmediğini gösterir. Örneğin 10110 maskesi üç eleman seçer. Dolayısıyla yalnızca içinde tam $k$ tane 1 bulunan maskeler kabul edilir.

def bitmask_kombinasyonlari(veri, k):
    n = len(veri)
    for maske in range(1 << n):
        if maske.bit_count() == k:
            yield [veri[i] for i in range(n) if maske & (1 << i)]

Kod son derece kısa olsa da $0$ ile $2^n-1$ arasındaki bütün maskeleri inceler. Bu nedenle özellikle $k$, $n$ değerine göre küçükken çok sayıda gereksiz maske kontrol edilir.

Yöntemlerin karşılaştırması

Pratikte genel amaçlı kullanım için indeks ilerletme yöntemi iyi bir dengedir. Seçimlere özel kurallar eklenecekse geri izleme daha esnektir. Bit maskesi ise küçük kümelerde, bit düzeyindeki temsiller zaten problemin parçasıysa parlamaya başlar. Hangi yolu seçerseniz seçin, sonuç sayısını ${n \choose k}$ ile doğrulamak algoritmik pusulanız olacaktır.

``

Luhn algoritması ne işe yarar?

IBM araştırmacısı Hans Peter Luhn tarafından geliştirilen algoritma; kredi kartı numaraları, IMEI kodları ve bazı kimlik numaralarındaki yazım hatalarını yakalamak için kullanılır. Temel amacı bir numaranın gerçekten aktif, kullanılabilir veya bir kişiye ait olduğunu kanıtlamak değildir. Yalnızca rakam dizisinin belirlenen sağlama kuralına uyup uymadığını söyler.

Başka bir ifadeyle Luhn kontrolünden geçen rastgele bir sayı üretilebilir. Bu nedenle algoritma bir güvenlik veya yetkilendirme mekanizması olarak görülmemelidir.

Matematiksel mantık

Numaranın rakamları sağdan sola doğru işlenir. En sağdaki rakam kontrol basamağıdır. Sağdan başlayarak her ikinci rakam ikiyle çarpılır. Çarpım 9’dan büyükse sonuçtan 9 çıkarılır. Elde edilen bütün değerler toplanır.

Toplam $S$ ile gösterilirse numara şu koşul sağlandığında Luhn açısından geçerlidir:

Örneğin 79927398713 sayısını düşünelim. Sağdan sola ilerlerken uygun konumlardaki rakamlar iki katına çıkarılır. 8 rakamının iki katı 16 olduğunda $16-9=7$ kullanılır. Bu işlem aslında 16 sayısının basamaklarını toplamakla, yani $1+6=7$ hesaplamakla aynıdır.

Dokuz çıkarma kuralı kodu sadeleştirir; iki basamaklı sonuçları ayrıca metne dönüştürmemize gerek kalmaz.

JavaScript ile uygulama

Aşağıdaki fonksiyon boşluk ve kısa çizgileri temizler, girdinin yalnızca rakamlardan oluştuğunu denetler ve ardından Luhn toplamını hesaplar:

function luhnDogrula(kartNumarasi) {
  const temizNumara = String(kartNumarasi).replace(/[\s-]/g, '');

  if (!/^\d+$/.test(temizNumara) || temizNumara.length < 2) {
    return false;
  }

  let toplam = 0;
  let ikiyleCarp = false;

  for (let i = temizNumara.length - 1; i >= 0; i--) {
    let rakam = Number(temizNumara[i]);

    if (ikiyleCarp) {
      rakam *= 2;
      if (rakam > 9) rakam -= 9;
    }

    toplam += rakam;
    ikiyleCarp = !ikiyleCarp;
  }

  return toplam % 10 === 0;
}

console.log(luhnDogrula('7992 7398 713')); // true
console.log(luhnDogrula('7992 7398 714')); // false

ikiyleCarp değişkeni her turda tersine çevrilerek sıradaki rakama hangi işlemin uygulanacağı belirlenir. Döngünün sağdan başlaması önemlidir; çünkü çiftleme düzeni kontrol basamağına göre kurulmuştur. Boşlukların ve kısa çizgilerin temizlenmesi ise kullanıcıların 1234 5678 gibi okunabilir biçimler girmesine izin verir.

Kullanırken nelere dikkat edilmeli?

Gerçek projelerde Luhn kontrolünü form doğrulamasının yalnızca ilk katmanı olarak kullanın. Kart numarasını günlük dosyalarına yazmayın, gereksiz yere saklamayın ve ödeme işlemlerini PCI DSS uyumlu sağlayıcılara bırakın. İstemci tarafındaki kontrol kullanıcı deneyimini iyileştirir; ancak aynı doğrulama sunucuda da yapılmalıdır, çünkü tarayıcıdaki JavaScript değiştirilebilir.

Sonuç olarak Luhn algoritması güçlü bir şifreleme tekniği değil, hızlı bir hata süzgecidir. Birkaç aritmetik işlemle yaygın yazım yanlışlarını yakalaması, küçük algoritmaların gerçek dünyada ne kadar faydalı olabileceğinin harika bir örneğidir.