``

Aralıklı tekrar neden işe yarar?

Hermann Ebbinghaus’un unutma eğrisi, bir bilginin hatırlanma gücünün zamanla üstel biçimde azaldığını öne sürer. Basitleştirilmiş bir model şöyledir:

Burada $R(t)$ hatırlama olasılığını, $t$ son çalışmadan beri geçen süreyi, $S$ ise anının dayanıklılığını temsil eder. Aynı kelimeyi başarıyla hatırladıkça $S$ büyür; böylece tekrarlar arasındaki süre uzatılabilir.

Örneğin “serendipity” kelimesini ilk gün öğrendiğimizi düşünelim. İlk tekrar bir gün sonra, sonraki tekrar üç gün sonra, ardından sekiz veya on gün sonra yapılabilir. Amaç, kartı tamamen unutmadan hemen önce göstermektir. Çok erken tekrar zaman kaybettirir, çok geç tekrar ise öğrenme sürecini başa sarar.

AnkiWeb, Mochi ve Mnemosyne karşılaştırması

Bu araçların ortak hedefi aynı olsa da kullanıcı deneyimleri ve veri modelleri farklıdır:

Anki ekosistem ve özelleştirme konusunda öne çıkar. Mochi, kartları birbirine bağlayarak kişisel bilgi ağı kurmayı kolaylaştırır. Mnemosyne ise daha sade ve akademik bir yaklaşım sunar. Kısacası Anki bir kontrol paneli, Mochi dijital bahçe, Mnemosyne ise sakin bir çalışma masası gibidir.

Temel veri modeli

Kendi sistemimizde her kart için kelime, anlam, örnek cümle, tekrar tarihi, kolaylık katsayısı ve tekrar sayısı saklanabilir. Ayrıca öğrenme yönünü değiştirmek yararlıdır: “apple → elma” kartı tanımayı, “elma → apple” kartı ise aktif hatırlamayı ölçer.

Basit bir kart modeli şu alanları içerebilir:

• front: Sorulan kelime veya ipucu
• back: Anlam ve örnek cümle
• interval: Bir sonraki tekrara kalan gün
• ease: Kartın kişisel zorluk katsayısı
• due: Gösterileceği tarih

Basitleştirilmiş SM-2 zamanlayıcısı

Aşağıdaki Python fonksiyonu, kullanıcının 0 ile 5 arasındaki cevabına göre yeni tekrar aralığını hesaplar:

def schedule_card(quality, repetitions, interval, ease):
    # 3'ten düşük puan, kartın hatırlanamadığını gösterir.
    if quality < 3:
        repetitions = 0
        interval = 1
    else:
        repetitions += 1

        if repetitions == 1:
            interval = 1
        elif repetitions == 2:
            interval = 6
        else:
            interval = round(interval * ease)

    # Başarılı cevap kolaylığı artırır, zor cevap azaltır.
    ease += 0.1 - (5 - quality) * (0.08 + (5 - quality) * 0.02)
    ease = max(1.3, ease)

    return repetitions, interval, ease

print(schedule_card(4, 2, 6, 2.5))

Fonksiyon kart unutulduğunda programı sıfırlar; doğru cevaplarda ise mevcut aralığı kolaylık katsayısıyla büyütür. $I_{yeni} = I_{eski} \times E$ ilişkisi, uzun vadede tekrar sayısını ciddi biçimde azaltır. Gerçek bir uygulamada saat dilimi, günlük kart sınırı, gecikmiş tekrarlar ve kullanıcı alışkanlıkları da hesaba katılmalıdır.

İyi bir sistemin sırrı

Algoritma tek başına mucize yaratmaz. Kartlar kısa olmalı, tek bir bilgiyi sınamalı ve kelimeyi bağlam içinde göstermelidir. Görsel, ses kaydı ve gerçek bir örnek cümle hatırlamayı güçlendirir. En iyi araç; en gelişmiş formüle sahip olan değil, her gün açmayı unutmadığınız araçtır. Beş dakikalık düzenli tekrar, pazar gecesi yapılan iki saatlik kelime maratonunu çoğu zaman rahatça yener.

Bilgisayarların yalnızca sıfır ve birlerle çalışması ilk bakışta teknolojik bir sınırlama gibi görünebilir. Oysa ikili sayı sistemi, klasik mantık bulmacalarında bilgiyi düzenlemek, olasılıkları kodlamak ve en az sayıda işlemle sonuca ulaşmak için kullanılan son derece güçlü bir araçtır. Zehirli şişelerden ağırlık tartma sorularına kadar pek çok problem, doğru açıdan bakıldığında aslında gizlenmiş birer ikili kodlama egzersizidir.

``

İkili sistem neden bu kadar kullanışlı?

Onluk sistemde her basamak 0 ile 9 arasında değer alırken ikili sistemde yalnızca iki durum bulunur: 0 ve 1. Bunlar hayır–evet, kapalı–açık, başarısız–başarılı veya hafif–ağır gibi iki seçenekli durumları temsil edebilir.

Bir ikili sayının değeri şöyle hesaplanır:

Burada her $b_i$ yalnızca 0 veya 1 olabilir. Örneğin $1011_2$ sayısı:

Bu gösterimin problem çözmedeki asıl avantajı, $k$ adet iki durumlu gözlemle $2^k$ farklı olasılığı ayırt edebilmesidir.

Zehirli şişe bulmacası

Klasik soruyu düşünelim: 1000 şişeden biri zehirli ve yalnızca 10 test şeridimiz var. Tek turda zehirli şişeyi nasıl buluruz? Her şişeyi ayrı ayrı test etmek mümkün değildir. Fakat $2^{10}=1024$ olduğu için 10 şerit, 1024 farklı sonucu kodlayabilir.

Şişeleri 0 ile 999 arasında numaralandırır ve numaraları 10 bitlik ikili biçimde yazarız. Bir şişenin ikili gösterimindeki hangi bitler 1 ise o şişeden ilgili test şeritlerine örnek damlatırız. Örneğin 13 numaralı şişenin kodu 0000001101 olur; dolayısıyla 1 değerine sahip bitlerin karşılık geldiği şeritlere eklenir.

Bekleme sonunda pozitif çıkan şeritler 1, negatif çıkanlar 0 kabul edilir. Ortaya çıkan ikili sayı doğrudan zehirli şişenin numarasıdır. Buradaki sihir aslında sihir değil, her şişeye benzersiz bir bit deseni vermektir.

Ağırlıklarla ölçme bulmacası

Elimizde 1, 2, 4 ve 8 kilogramlık ağırlıklar varsa 1 ile 15 kilogram arasındaki her tam değeri ölçebiliriz. Çünkü bu ağırlıklar ikinin kuvvetleridir:

Örneğin 13 kilogram, $1101_2$ biçimindedir. Bu nedenle 8, 4 ve 1 kilogramlık ağırlıklar kullanılır; 2 kilogramlık ağırlık kullanılmaz.

Aynı fikri Python ile görmek

Aşağıdaki kod, bir sayıyı oluşturmak için hangi ikinin kuvvetlerinin seçilmesi gerektiğini bulur:

def secilen_agirliklar(hedef):
    agirliklar = []
    bit = 0

    while hedef > 0:
        if hedef & 1:
            agirliklar.append(2 ** bit)
        hedef >>= 1
        bit += 1

    return agirliklar

print(secilen_agirliklar(13))  # [1, 4, 8]

hedef & 1 işlemi en sağdaki bitin 1 olup olmadığını denetler. hedef >>= 1 ise sayıyı bir bit sağa kaydırarak sıradaki basamağa geçer. Böylece algoritma, sayının ikili gösterimini doğrudan seçilecek ağırlıklara dönüştürür.

Bulmacalarda ikili düşünme yöntemi

Bir soruda çok sayıda aday ve yalnızca iki sonuç üreten testler varsa şu adımlar uygulanabilir:

1. Olasılık sayısını $n$ olarak belirle.
2. $2^k ≥ n$ koşulunu sağlayan en küçük $k$ değerini bul.
3. Her adaya benzersiz bir $k$ bitlik kod ata.
4. Her testi kodun bir basamağıyla ilişkilendir.
5. Sonuç bitlerini birleştirerek doğru adayı belirle.

Kısacası ikili sistem yalnızca bilgisayarların dili değildir; sınırlı gözlemlerden maksimum bilgi çıkarma yöntemidir. Bir bulmacada “açık veya kapalı”, “doğru veya yanlış” gibi iki durumlu sonuçlar görüyorsanız, çözümün bir köşesinde büyük olasılıkla ikinin kuvvetleri gülümsüyordur.

``

Önce asimptotik analiz nedir?

Asimptotik analiz, girdi boyutu $n$ büyürken algoritmanın zaman veya bellek ihtiyacının nasıl değiştiğini inceler. Donanım, programlama dili ve birkaç milisaniyelik sabit farklar yerine büyüme eğilimine odaklanır.

Örneğin çalışma süresi

olan bir algoritmada, büyük $n$ değerleri için $n^2$ terimi baskındır. Sabit katsayılar ve düşük dereceli terimler göz ardı edildiğinde büyüme $n^2$ ile ifade edilir.

Üç notasyonun temel farkı

Büyük O: Üst sınır

$f(n)=O(g(n))$ diyebilmek için yeterince büyük $n$ değerlerinde

olacak pozitif bir $c$ sabiti bulunmalıdır. Örneğin $3n^2+5n+20$, hem $O(n^2)$ hem de teknik olarak $O(n^3)$ içindedir. Fakat $O(n^2)$ daha bilgilendirici ve daha sıkı bir üst sınırdır.

Omega: Alt sınır

$f(n)=\Omega(g(n))$, fonksiyonun en az $g(n)$ kadar hızlı büyüdüğünü belirtir:

Örneğin $3n^2+5n+20$, $\Omega(n^2)$ sınıfındadır. Bu notasyon algoritmanın belirli bir maliyetin altına inemeyeceğini anlatır.

Teta: Sıkı sınır

Teta, alt ve üst sınırın birleşimidir:

Dolayısıyla $f(n)=\Theta(g(n))$ ise fonksiyon hem $O(g(n))$ hem de $\Omega(g(n))$ olur. Örneğimiz için en açıklayıcı ifade $T(n)=\Theta(n^2)$ biçimindedir.

En iyi, ortalama ve en kötü durum

Durumlar, girdinin algoritmayı nasıl etkilediğini; notasyonlar ise seçilen durumdaki büyümeye ilişkin sınırı belirtir.

Burada her durum için Teta kullanabildiğimize dikkat edin. “En kötü durum $O(n)$” doğrudur; fakat sıkı sınır biliniyorsa “en kötü durum $\Theta(n)$” daha güçlü bir ifadedir. Ortalama durum analizi ise girdilerin olasılık dağılımını gerektirir. Her girdinin eşit olasılıklı olduğunu varsaymak her zaman gerçekçi değildir.

Kod üzerinde görelim

Aşağıdaki Python fonksiyonu, doğrusal arama yaparken kaç karşılaştırma gerçekleştirildiğini de döndürür:

def linear_search(values, target):
    comparisons = 0

    for index, value in enumerate(values):
        comparisons += 1
        if value == target:
            return index, comparisons

    return -1, comparisons

numbers = [8, 3, 12, 7, 21]
print(linear_search(numbers, 8))   # En iyi durum: 1 karşılaştırma
print(linear_search(numbers, 21))  # En kötü durum: 5 karşılaştırma

İlk çağrıda maliyet girdi boyutundan bağımsızdır. İkinci çağrıda karşılaştırma sayısı $n$ ile birlikte doğrusal büyür.

Hangisini kullanmalıyız?

Bir algoritmayı tanıtırken analiz edilen durumu açıkça söylemek en güvenli yaklaşımdır: “en kötü durumda $\Theta(n^2)$” gibi. Yalnızca güvenli bir üst sınır biliniyorsa Büyük O, kaçınılmaz bir alt sınır gösteriliyorsa Omega, büyüme kesin biçimde sınırlandırılabiliyorsa Teta kullanılmalıdır. Kısacası notasyonlar yarışmıyor; algoritmanın performansını farklı açılardan aydınlatıyor.

``

Mekanik hesaplamanın doğuşu

Bilgisayarların uzak atalarından biri, 1642 yılında Blaise Pascal tarafından geliştirilen Pascaline adlı mekanik hesap makinesiydi. Dişli çarklar kullanan bu cihaz toplama ve çıkarma yapabiliyordu. Gottfried Wilhelm Leibniz ise 1670’lerde sistemi geliştirerek çarpma ve bölme işlemlerini de mekanikleştirdi.

Bu makinelerin temel fikri, sayıları fiziksel konumlarla temsil etmekti. Örneğin bir çarkın on farklı konumu, 0 ile 9 arasındaki rakamlara karşılık geliyordu. Günümüzde aynı yaklaşım elektrik sinyalleriyle uygulanır; ancak on durum yerine çoğunlukla iki durum kullanılır:

Mekanik sistemlerde hareket eden parçalar bilgiyi taşırken modern bilgisayarlarda bu görevi gerilim seviyeleri üstlenir.

Programlanabilir makine fikri

1800’lerin başında Joseph Marie Jacquard, dokuma tezgâhlarını delikli kartlarla kontrol etti. Kartlardaki delikler bir tür komut dizisi oluşturuyordu. Charles Babbage bu fikirden etkilenerek 1837’de Analitik Makine tasarımını ortaya koydu.

Babbage’ın makinesi tamamlanamamış olsa da işlem birimi, bellek, giriş ve çıkış gibi modern bilgisayar bileşenlerini teorik olarak içeriyordu. Ada Lovelace ise makinenin Bernoulli sayılarını hesaplaması için bir algoritma hazırladı ve tarihin ilk bilgisayar programcısı kabul edildi.

Elektronik bilgisayarlar sahneye çıkıyor

1940’larda mekanik parçaların yerini röleler ve vakum tüpleri aldı. 1946’da tanıtılan ENIAC, yaklaşık 18.000 vakum tüpü kullanıyor ve saniyede binlerce işlem gerçekleştirebiliyordu. Ne var ki devasa boyutlu, enerji oburu ve arızaya yatkındı.

Transistör ve mikroişlemci devrimi

1947’de transistörün geliştirilmesi bilgisayarları küçülttü, hızlandırdı ve daha güvenilir hâle getirdi. Ardından çok sayıda transistörün aynı yüzeye yerleştirildiği entegre devreler ortaya çıktı. 1971’de Intel 4004, ticari açıdan başarılı ilk mikroişlemcilerden biri oldu.

İşlemci performansı kabaca saat frekansı, çekirdek sayısı ve saat başına tamamlanan komut miktarıyla ilişkilendirilebilir:

Burada $f$ frekansı, $C$ çekirdek sayısını, $IPC$ ise döngü başına işlenen komut sayısını temsil eder. Gerçek performans bellek, önbellek ve yazılım tasarımından da etkilenir.

İkili sistemin temel mantığını küçük bir Python örneğiyle görebiliriz:

def ikili_topla(a, b):
    # Metin biçimindeki ikili sayıları onlu sisteme çevirir.
    toplam = int(a, 2) + int(b, 2)

    # Sonucu yeniden ikili gösterime dönüştürür.
    return bin(toplam)[2:]

print(ikili_topla("1010", "0111"))  # 10001

Bu kod, işlemcideki gerçek mantık kapılarının yaptığı işi soyut düzeyde taklit eder. Donanımda toplama; AND, OR ve XOR gibi devrelerle gerçekleştirilir.

Günümüz: Paralellik ve uzmanlaşma

Transistör sayısının yaklaşık iki yılda bir artacağını öngören Moore Yasası, onlarca yıl boyunca sektöre yön verdi. Fiziksel küçülmenin zorlaşmasıyla üreticiler yalnızca frekansı artırmak yerine çok çekirdekli mimarilere yöneldi. GPU’lar grafik işlemlerinin yanında yapay zekâ ve bilimsel hesaplama için kullanılmaya başlandı. NPU gibi özel birimler ise belirli görevleri daha az enerjiyle tamamlıyor.

Kısacası bilgisayarın gelişimi, “daha hızlı hesaplama” arzusundan “doğru işi doğru donanımla yapma” anlayışına evrildi. Pascal’ın çarklarından modern işlemcilerin nanometre ölçeğindeki transistörlerine kadar değişmeyen temel amaç ise aynı kaldı: bilgiyi temsil etmek, kurallara göre işlemek ve anlamlı sonuç üretmek.

``

Aralıklı tekrar neden işe yarar?

İnsan belleği, kullanılmayan bilgiyi zamanla silikleştirir. Basitleştirilmiş bir unutma eğrisi şu şekilde gösterilebilir:

Burada $R(t)$ bilgiyi hatırlama olasılığı, $t$ son tekrardan beri geçen süre, $S$ ise belleğin dayanıklılığıdır. Bir kartı başarıyla hatırladığımızda $S$ büyür; böylece bir sonraki tekrar daha ileri bir tarihe taşınabilir.

Basit bir planlayıcı, yeni aralığı yaklaşık olarak şöyle hesaplayabilir:

$I$ tekrar aralığını, $E$ kartın kolaylık katsayısını, $P$ ise kullanıcının verdiği performans puanını temsil eder. Gerçek uygulamalar başarısızlıkları, gecikmiş tekrarları ve öğrenme geçmişini hesaba katan daha gelişmiş modeller kullanır. Dolayısıyla amaç her kartı her gün göstermek değil, unutmaya yaklaşırken göstermektir.

Üç uygulama, üç farklı karakter

Anki: Ayar panelini sevenlerin laboratuvarı

Anki; kart şablonları, etiketler, medya desteği ve eklentileriyle oldukça esnektir. Modern sürümlerde FSRS gibi, geçmiş tekrar verilerinden yararlanarak daha verimli aralıklar üretmeyi amaçlayan zamanlama seçenekleri bulunur. Buna karşılık ilk deste hazırlamak, alanlarla şablonların farkını anlamak ve ayarları düzenlemek başlangıçta yorucu olabilir.

Dil öğrenenler, tıp öğrencileri ve binlerce kart yöneten kullanıcılar için güçlü bir seçenektir. Fakat her ayarı değiştirmek zorunda değilsiniz; varsayılanlarla başlayıp gerçek ihtiyaca göre ilerlemek daha sağlıklıdır.

Mnemosyne: Gösterişsiz ama disiplinli

Adını Yunan mitolojisindeki hafıza tanrıçasından alan Mnemosyne, aralıklı tekrar dünyasının köklü araçlarındandır. Arayüzü modern uygulamalar kadar parlak görünmeyebilir; buna karşın kart oluşturma ve puanlama akışı nettir. Açık kaynak yaklaşımı ve araştırma odaklı geçmişi önemli avantajlarıdır.

“Not sistemi değil, yalnızca düzgün çalışan bir tekrar aracı istiyorum” diyorsanız Mnemosyne mantıklı bir adaydır. Daha küçük eklenti ekosistemi ve sınırlı görsel cilası ise bazı kullanıcıları Anki veya Mochi’ye yöneltebilir.

Mochi: Not alırken kart üretmek

Mochi, Markdown notları ile flashcard sistemini aynı ortamda buluşturur. Kartlar arasında bağlantı kurabilmek, tek tek gerçekleri ezberlemek yerine kavram ağı oluşturmayı kolaylaştırır. Özellikle yazılım, tarih veya felsefe gibi ilişkisel konularda bu yaklaşım değerlidir.

Ancak zengin bağlantılar kurmak, otomatik olarak iyi öğrenme anlamına gelmez. Kartlar kısa, açık ve tek bir bilgiyi ölçer durumda olmalıdır. Ayrıca çevrim içi özellikler ve ücretlendirme seçenekleri zamanla değişebileceğinden güncel planlar kontrol edilmelidir.

Mini bir zamanlayıcı nasıl çalışır?

Aşağıdaki Python kodu, doğru yanıtta aralığı büyüten, yanlış yanıtta kartı ertesi güne döndüren basitleştirilmiş bir modeldir:

def sonraki_aralik(mevcut_gun, puan, kolaylik=2.2):
    # 0-2 başarısız, 3-5 başarılı kabul edilir.
    if puan < 3:
        return 1

    performans = 0.8 + (puan - 3) * 0.2
    yeni_aralik = mevcut_gun * kolaylik * performans
    return max(1, round(yeni_aralik))

print(sonraki_aralik(7, 4))  # Yaklaşık 15 gün

Bu örnek öğreticidir; gerçek planlayıcılar çok daha fazla veri kullanır. Yine de temel fikir açıktır: başarı aralığı büyütür, başarısızlık kartı yaklaştırır.

Hangisini seçmeli?

Maksimum özelleştirme ve büyük deste yönetimi için Anki, sade ve açık kaynaklı bir çalışma düzeni için Mnemosyne, bağlantılı Markdown notlarıyla öğrenmek için Mochi öne çıkar. En iyi sistem, en gelişmiş algoritmaya sahip olan değil, her gün açmayı sürdürebildiğiniz sistemdir. Önce 20 kartlık küçük bir deste hazırlayın, bir hafta deneyin ve kararınızı gerçek çalışma alışkanlığınıza göre verin.

Ağaçlar; dosya sistemlerinden arama motorlarına, derleyicilerden oyunlardaki karar mekanizmalarına kadar birçok alanda kullanılan hiyerarşik veri yapılarıdır. Ancak düğümleri dallara yerleştirmek tek başına yeterli değildir: Bilgiye ulaşabilmek için ağacı sistemli biçimde dolaşmamız gerekir. İkili ağaçlarda en yaygın derinlik öncelikli yöntemler ön sıra, orta sıra ve son sıra dolaşmadır.

``

İkili ağaç nedir?

İkili ağaçta her düğümün en fazla iki çocuğu bulunur: sol çocuk ve sağ çocuk. En üstteki düğüme kök, çocuğu olmayan düğümlere ise yaprak denir.

Örnek olarak aşağıdaki ağacı düşünelim:

        8
       / \
      3   10
     / \    \
    1   6    14

Dolaşma yöntemleri arasındaki temel fark, kök düğümün ne zaman ziyaret edildiğidir. Buradaki “ziyaret”, değeri yazdırmak, toplamak, karşılaştırmak veya başka bir işlem gerçekleştirmek anlamına gelebilir.

Ön sıra dolaşma

Ön sıra dolaşmada kök, çocuklarından önce işlenir. Bu nedenle hiyerarşik yapıyı dışarı aktarmak veya ağacın bir kopyasını oluşturmak için kullanışlıdır. Kökün önce bilinmesi, alt dalların hangi üst düğüme bağlanacağını belirlemeyi kolaylaştırır.

def preorder(node):
    if node is None:
        return

    print(node.value)       # Önce kökü işle
    preorder(node.left)     # Ardından sol alt ağacı dolaş
    preorder(node.right)    # Son olarak sağ alt ağacı dolaş

Bir klasör yapısında önce klasör adını, ardından içindeki dosya ve alt klasörleri göstermek bu yaklaşıma benzer.

Orta sıra dolaşma

Orta sırada kök, sol ve sağ alt ağaçların arasında ziyaret edilir. Bu yöntem özellikle ikili arama ağaçlarında önemlidir. İkili arama ağacında sol taraftaki değerler kökten küçük, sağ taraftakiler büyüktür. Dolayısıyla orta sıra dolaşma değerleri küçükten büyüğe üretir.

def inorder(node):
    if node is None:
        return

    inorder(node.left)      # Küçük değerleri gez
    print(node.value)       # Kökü işle
    inorder(node.right)     # Büyük değerleri gez

Bu özellik, ayrıca bir sıralama algoritması çalıştırmadan düzenli çıktı alınmasını sağlar. Fakat aynı sonuç sıradan bir ikili ağaç için garanti edilmez; ağacın ikili arama ağacı kurallarına uyması gerekir.

Son sıra dolaşma

Son sıra dolaşmada kök en son işlenir. Başka bir deyişle, ebeveyn üzerinde işlem yapılmadan önce bütün çocuklar tamamlanır.

def postorder(node):
    if node is None:
        return

    postorder(node.left)    # Sol bağımlılıkları tamamla
    postorder(node.right)   # Sağ bağımlılıkları tamamla
    print(node.value)       # En son kökü işle

Bu yöntem ağacı bellekten güvenli biçimde silmek için idealdir. Önce çocuk düğümler kaldırılır, sonra ebeveyn silinir. İfade ağaçlarında hesaplama yapmak da benzer mantıktadır: Operatör uygulanmadan önce iki operandın değeri hesaplanır.

Zaman ve alan karmaşıklığı

Üç yöntem de her düğümü tam bir kez ziyaret eder. Düğüm sayısı $n$ ise çalışma süresi:

Özyinelemeli çağrıların bellek maliyeti ağacın yüksekliğine, yani $h$ değerine bağlı olarak $O(h)$ olur. Dengeli ağaçta $h \approx \log_2 n$ iken tek tarafa yatmış bir ağaçta $h=n$ olabilir.

Kısacası seçim, “kökü ne zaman işlemeliyim?” sorusuna bağlıdır: Yapıyı yukarıdan aşağı kurmak için ön sıra, sıralı veri almak için orta sıra, çocukları ebeveynden önce tamamlamak için son sıra tercih edilir.

``

Klasik çarpmanın maliyeti

Her biri $n$ basamaklı iki sayıyı klasik yöntemle çarptığımızı düşünelim. Birinci sayının her basamağı, ikinci sayının bütün basamaklarıyla çarpılır. Yaklaşık olarak $n \times n = n^2$ tek basamaklı çarpma yapılır. Bu nedenle klasik yöntemin zaman karmaşıklığı $O(n^2)$ olur.

Karatsuba ise sayıları iki parçaya ayırır. Tabanı $B$ olan ve yaklaşık $2m$ basamak taşıyan iki sayı şöyle yazılabilir:

Normal açılım yapıldığında:

Bu ifade doğrudan uygulanırsa $ac$, $ad$, $bc$ ve $bd$ olmak üzere dört çarpma gerekir. Karatsuba’nın numarası tam burada ortaya çıkar: ortadaki terim ayrı ayrı hesaplanmak zorunda değildir.

Böylece yalnızca şu üç çarpım hesaplanır:

• $z_2 = ac$
• $z_0 = bd$
• $z_1 = (a+b)(c+d) - z_2 - z_0$

Sonuç ise $z_2B^{2m} + z_1B^m + z_0$ biçiminde birleştirilir. Dört çarpma yerine üç çarpma yapmak küçük sayılarda önemsiz görünebilir; fakat işlem her seviyede özyinelemeli tekrarlandığında fark kartopu gibi büyür.

Karatsuba’nın bağıntısı $T(n)=3T(n/2)+O(n)$ şeklindedir. Buradan karmaşıklık yaklaşık $O(n^{1.585})$ çıkar. Sayılar büyüdükçe bu üs farkı ciddi bir avantaj sağlar.

Python ile uygulama

Aşağıdaki fonksiyon sayıları onluk tabanda böler. Sayılar yeterince küçük olduğunda özyinelemeyi durdurup Python’ın normal çarpımını kullanır:

def karatsuba(x, y):
    # Küçük değerlerde ek özyineleme maliyetinden kaçın.
    if x < 10 or y < 10:
        return x * y

    n = max(len(str(x)), len(str(y)))
    m = n // 2
    taban = 10 ** m

    a, b = divmod(x, taban)
    c, d = divmod(y, taban)

    z2 = karatsuba(a, c)
    z0 = karatsuba(b, d)
    z1 = karatsuba(a + b, c + d) - z2 - z0

    return z2 * (taban ** 2) + z1 * taban + z0

print(karatsuba(12345678, 87654321))

divmod, bir sayının yüksek ve düşük basamaklarını tek adımda ayırır. Üç özyinelemeli çağrı gerekli ara çarpımları üretir; son satır da basamak kaydırmalarını onluk tabanın kuvvetleriyle gerçekleştirir.

Her durumda daha mı hızlı?

Hayır. Özyinelemeli çağrılar, sayıları parçalama ve ara sonuçları toplama işlemleri ek maliyet oluşturur. Bu yüzden pratik kütüphaneler hibrit davranır: küçük sayılarda klasik çarpma, belirli bir basamak eşiğinden sonra Karatsuba kullanılır.

Karatsuba’nın asıl güzelliği, daha güçlü donanım istemeden cebir sayesinde işi azaltmasıdır. Böl ve fethet yaklaşımının yalnızca problemi küçültmek değil, gereksiz hesaplamaları ortadan kaldırmak anlamına da geldiğini gösteren klasik ve hâlâ etkileyici bir algoritmadır.

Temel fikir: Problem nasıl parçalanıyor?

Bir böl-fethet algoritması genellikle üç adım uygular: problemi alt problemlere böler, bunları özyinelemeli biçimde çözer ve sonuçları birleştirir. Bu sürecin çalışma süresi şu bağıntıyla ifade edilir:

Buradaki değişkenlerin görevleri şöyledir:

Teoremin merkezindeki karşılaştırma, $f(n)$ ile $n^{\log_b a}$ arasındadır. İkinci ifade, özyineleme ağacındaki alt problemlerin ürettiği temel iş yükünü temsil eder. Kısacası şu soruyu sorarız: Maliyeti alt problemler mi, her seviyede yapılan ek iş mi, yoksa ikisi birlikte mi büyütüyor?

Master Teorem’in üç durumu

Buradaki $\varepsilon>0$, fonksiyonlar arasında polinom düzeyinde bir fark bulunduğunu belirtir. Üçüncü durumda ayrıca düzenlilik koşulu aranır: Yeterince büyük $n$ değerleri için $af(n/b)\leq cf(n)$ ve $c<1$ olmalıdır.

Örnek: Merge Sort

Merge Sort diziyi iki eşit parçaya ayırır, iki parçayı ayrı ayrı sıralar ve doğrusal zamanda birleştirir:

Buradan $a=2$, $b=2$ ve $f(n)=n$ elde edilir. Kritik terim:

$f(n)$ ile kritik terim eşit büyüdüğü için ikinci durum geçerlidir. Sonuç:

Aşağıdaki Python kodu bu yapının algoritmadaki karşılığını gösterir:

def merge_sort(items):
    if len(items) <= 1:
        return items

    middle = len(items) // 2
    left = merge_sort(items[:middle])
    right = merge_sort(items[middle:])
    return merge(left, right)

İki özyinelemeli çağrı $2T(n/2)$ terimini, merge işlemi ise doğrusal $n$ maliyetini oluşturur.

İki kısa karşılaştırma

İkili aramada yalnızca bir yarı seçilir:

$a=1$, $b=2$ ve $f(n)=1$ olduğundan $n^{\log_2 1}=1$ bulunur. İkinci durum sonucunda karmaşıklık $\Theta(\log n)$ olur.

Şu bağıntıda ise birleştirme işi daha pahalıdır:

Kritik terim $n$ iken $f(n)=n^2$ daha hızlı büyür. Düzenlilik koşulu da sağlandığından üçüncü durum uygulanır ve sonuç $\Theta(n^2)$ çıkar.

Ne zaman kullanılamaz?

Master Teorem her özyineleme bağıntısına uymaz. Alt problemlerin eşit boyutta olmadığı $T(n)=T(n/3)+T(2n/3)+n$ veya boyutun sabit miktarda azaldığı $T(n)=T(n-1)+n$ biçimleri doğrudan kapsam dışındadır. Böyle durumlarda özyineleme ağacı, yerine koyma yöntemi ya da Akra–Bazzi teoremi tercih edilebilir.

Pratik reçete basittir: Önce $a$, $b$ ve $f(n)$ değerlerini çıkarın; ardından $n^{\log_b a}$ terimini hesaplayın ve $f(n)$ ile karşılaştırın. Üç durumdan doğru olanı seçtiğinizde, karmaşıklık hesabı korkutucu bir denklem olmaktan çıkıp kısa bir eşleştirme oyununa dönüşür.

Fibonacci dizisi, algoritma öğrenirken karşımıza çıkan en ünlü örneklerden biridir. Tanımı son derece basit görünür: Her sayı, kendisinden önce gelen iki sayının toplamıdır. Ancak bu masum tanımı saf özyineleme ile doğrudan koda çevirdiğimizde bilgisayarımız aynı işlemleri tekrar tekrar yapmaya başlar. Gelin bu performans tuzağının neden oluştuğunu ve memoizasyonun onu nasıl ortadan kaldırdığını inceleyelim.

``

Fibonacci dizisinin matematiksel tanımı

Dizinin başlangıç değerlerini $F(0)=0$ ve $F(1)=1$ olarak kabul edelim. Geri kalan terimler şu bağıntıyla hesaplanır:

Böylece dizi $0, 1, 1, 2, 3, 5, 8, 13, \ldots$ biçiminde ilerler. Matematiksel tanımın kendi kendisine başvurması, özyinelemeli bir program yazmayı oldukça doğal hâle getirir.

def fibonacci(n):
    if n <= 1:
        return n

    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55

Bu fonksiyon önce taban durumu kontrol eder. $n$, sıfır veya bir olduğunda doğrudan sonucu döndürür; aksi hâlde önceki iki Fibonacci değerini ayrı çağrılarla hesaplar. Kod kısa, okunabilir ve matematiksel tanıma neredeyse birebir uygundur. Ne yazık ki kısa kod her zaman hızlı kod değildir.

Saf özyineleme neden yavaştır?

$fibonacci(5)$ çağrıldığında fonksiyon hem $fibonacci(4)$ hem de $fibonacci(3)$ çağrılarını oluşturur. Ardından $fibonacci(4)$, kendi içinde $fibonacci(3)$ değerini yeniden hesaplar. Yani aynı alt problem birden fazla kez çözülür.

Çağrı sayısını yaklaşık olarak şu bağıntı ifade eder:

Bu yapı Fibonacci dizisine benzediği için çalışma süresi yaklaşık $O(\varphi^n)$ olur. Buradaki $\varphi \approx 1.618$, altın orandır. Karmaşıklık çoğu zaman daha genel bir üst sınırla $O(2^n)$ şeklinde de gösterilir. Her yeni değer, çağrı ağacını hızla büyütür; bilgisayar adeta daha önce çözdüğü soruların cevaplarını unutup tekrar sınava girer.

Memoizasyon ile sonuçları hatırlamak

Memoizasyon, hesaplanan sonuçları bir önbellekte saklar. Fonksiyon aynı $n$ değeriyle yeniden çağrıldığında bütün çağrı ağacını tekrar kurmak yerine hazır sonucu döndürür.

def fibonacci(n, cache=None):
    # Sözlüğü yalnızca ilk çağrıda oluştururuz.
    if cache is None:
        cache = {0: 0, 1: 1}

    # Daha önce hesaplandıysa doğrudan kullanırız.
    if n in cache:
        return cache[n]

    cache[n] = fibonacci(n - 1, cache) + fibonacci(n - 2, cache)
    return cache[n]

print(fibonacci(40))  # 102334155

Bu sürümde $F(0)$ ile $F(n)$ arasındaki her değer en fazla bir kez hesaplanır. Her hesaplama sabit zamanlı sözlük erişimleri yaptığı için toplam süre $O(n)$ seviyesine iner. Önbellek ve çağrı yığını ise $O(n)$ alan kullanır.

Python, aynı fikri hazır bir dekoratörle uygulamamıza da izin verir:

from functools import cache

@cache
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

Hangi yöntemi seçmeliyiz?

Saf özyineleme, algoritmanın matematiksel yapısını göstermek için harikadır; fakat büyük girdilerde pratik değildir. Memoizasyon, okunabilir özyinelemeli yapıyı korurken performansı dramatik biçimde iyileştirir. Yalnızca sonuca ihtiyaç duyuluyorsa döngüsel yaklaşım daha az bellek tüketebilir. Buradaki temel ders Fibonacci’den büyüktür: Bir problem örtüşen alt problemlere sahipse, daha önce hesaplanan sonuçları saklamak üstel bir algoritmayı doğrusal bir çözüme dönüştürebilir.

``

Rastgelelik gerçekte ne anlama gelir?

Bir sistemde $N$ adet soru varsa ve sınav için bunlardan $k$ tanesi eşit olasılıkla seçiliyorsa, belirli bir sorunun sınava girme olasılığı yaklaşık olarak

olur. Örneğin 100 soruluk havuzdan 20 soru seçildiğinde her sorunun sınavda görünme olasılığı $0.20$ seviyesindedir. Ancak gerçek kalite yalnızca rastgele seçimden gelmez. Zorluk, konu dağılımı ve öğrenme çıktıları da dengelenmelidir.

Daha kontrollü bir modelde sınav; 4 kolay, 4 orta ve 2 zor sorudan oluşturulabilir. Buna katmanlı rastgele seçim denir. Böylece bir öğrenci tamamen kolay, başka biri tamamen zor bir sınavla karşılaşmaz.

Üç yaklaşımın karşılaştırması

H5P ile hızlı etkileşim

H5P; Multiple Choice, Fill in the Blanks ve Question Set gibi içerik türleriyle çalışır. Seçenek sıralaması karıştırılabilir ve bir soru setinden belirli sayıda içerik gösterilebilir. En büyük avantajı, öğrencinin anında geri bildirim almasıdır.

Bununla birlikte H5P çoğunlukla önceden hazırlanmış içerikleri rastgele sunar. Örneğin her seferinde farklı katsayılara sahip bir denklem oluşturmak istiyorsanız ek JavaScript geliştirmesi veya harici bir servis gerekebilir.

Moodle Question Bank ile kontrollü seçim

Moodle soruları kategoriler altında saklayabilir. “Cebir/Kolay” ve “Cebir/Zor” gibi kategoriler oluşturup sınava her kategoriden rastgele soru eklemek mümkündür. Ayrıca Calculated Question türü, değişkenleri belirli aralıklardan seçerek parametrik sorular üretir.

Örneğin $a$ ve $b$ rastgele seçildiğinde öğrenciye $a+b$ sorulabilir. $a \in [2,10]$ ve $b \in [5,20]$ tanımlanırsa sistem çok sayıda varyasyon oluşturur. Tolerans, birim ve ondalık hassasiyeti gibi ayrıntılar da Moodle üzerinden yönetilebilir.

Özel algoritma nasıl kurulur?

Basit bir JavaScript fonksiyonu, iki katsayı seçip birinci dereceden denklem üretebilir:

function denklemUret() {
  const x = Math.floor(Math.random() * 9) + 1;
  const a = Math.floor(Math.random() * 8) + 2;
  const b = Math.floor(Math.random() * 20) + 1;

  return {
    soru: `${a}x + ${b} = ${a * x + b} denkleminde x kaçtır?`,
    cevap: x
  };
}

console.log(denklemUret());

Kod önce doğru cevabı belirler, ardından bu cevaba uygun denklem kurar. Bu yaklaşım önemlidir; rastgele bir soru üretip sonradan çözmeye çalışmak yerine, cevaptan soruya doğru üretim hatalı veya çözümsüz örneklerin önüne geçer.

Adil ve güvenilir bir sistem için

Gerçek sınavlarda sözde rastgele sayı üreteci için bir seed saklamak yararlıdır. Aynı seed kullanıldığında aynı sınav yeniden oluşturulabilir; böylece öğrenci itirazları incelenebilir. Ayrıca algoritma şu kontrollerden geçmelidir:

• Aynı sorunun sınav içinde tekrarlanmaması
• Yanlış seçeneklerin doğru cevaptan farklı olması
• Zorluk dağılımının korunması
• Üretilen değerlerin anlamlı aralıklarda kalması
• Soru sürümlerinin ve seed bilgilerinin kaydedilmesi

Hızlı ve görsel etkinliklerde H5P, kurumsal sınavlarda Moodle, benzersiz ve uyarlanabilir senaryolarda ise özel algoritmalar öne çıkar. En güçlü çözüm çoğu zaman bunları yarıştırmak değil, H5P’nin etkileşimini Moodle’ın soru bankası ve özel bir üretim servisinin esnekliğiyle birleştirmektir.