``

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.

``

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.

``

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.

``

Pozisyonel Olmamak Ne Demektir?

Onluk sistem pozisyoneldir: 325 sayısındaki 3, yüzler basamağında olduğu için $3 \times 100$ değerindedir. Roma sisteminde ise sembollerin temel değerleri konumlarından bağımsızdır.

Bir Roma dizisinin değeri, çıkarma gösterimi yok sayıldığında sembol değerlerinin toplamıdır:

Örneğin VIII, $5+1+1+1=8$ eder. Ancak IV gibi çıkarımlı yazımlarda küçük sembol büyük sembolden önce gelirse çıkarılır: $5-1=4$. Aritmetik algoritmalarında bu istisnayı azaltmak için önce genişletilmiş toplamsal biçim kullanmak oldukça pratiktir. Böylece IV, geçici olarak IIII; IX ise VIIII biçiminde düşünülebilir.

Roma Rakamlarıyla Toplama

XXVII + XVIII işlemini ele alalım. Önce sembolleri toplamsal biçimde yan yana getiririz:

XXVII + XVIII
= XXVIIXVIII
= XXXVVIIII

Ardından aynı sembolleri gruplayıp dönüşüm kurallarını uygularız:

• IIIII → V
• VV → X
• XXXXX → L
• LL → C
• CCCCC → D
• DD → M

XXXVVIIII ifadesinde iki V, bir X olur. Sonuç XXXXV, yani standart yazımla XLV olur. Gerçekten de $27+18=45$.

Bu yaklaşım, elde taşımalı toplamanın Roma usulü kuzenidir. Tek fark, basamaklar yerine sembol paketleri taşınmasıdır.

Çarpma: Tekrarlı Toplamadan Dağıtmaya

En basit yöntem, çarpılan sayıyı tekrar tekrar toplamaktır. Örneğin XII × III, üç tane XII sembol grubunun birleşimidir:

Altı I, VI olarak sadeleşir ve sonuç XXXVI olur. Yani $12 \times 3=36$.

Büyük sayılarda tekrarlı toplama verimsizdir. Bunun yerine çarpanı Roma sembollerinin değerlerine ayırabiliriz. XIV × VI işlemi, dağılım özelliğiyle şöyle ele alınır:

Roma mantığında bu, XIV sayısının beş katı ile bir kopyasını birleştirmek demektir. Sonuç $70+14=84$, yani LXXXIV olur.

Python ile Sembol Tabanlı Toplama

Aşağıdaki kod, çıkarımlı biçimi önce toplamsal biçime genişletir; sembolleri sayar ve ardından değeri standart Roma gösterimine dönüştürür:

values = {
    "I": 1, "V": 5, "X": 10, "L": 50,
    "C": 100, "D": 500, "M": 1000
}

expansions = {
    "IV": "IIII", "IX": "VIIII",
    "XL": "XXXX", "XC": "LXXXX",
    "CD": "CCCC", "CM": "DCCCC"
}

def expand(roman):
    for short, long_form in expansions.items():
        roman = roman.replace(short, long_form)
    return roman

def roman_add(a, b):
    pool = expand(a) + expand(b)
    total = sum(values[symbol] for symbol in pool)
    return to_roman(total)

def to_roman(number):
    table = [
        (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
        (100, "C"), (90, "XC"), (50, "L"), (40, "XL"),
        (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I")
    ]
    result = ""
    for value, symbol in table:
        count, number = divmod(number, value)
        result += symbol * count
    return result

print(roman_add("XXVII", "XVIII"))  # XLV

Roma aritmetiği, bilgisayarların kullandığı modern sayı sistemleri kadar verimli değildir; sıfır ve basamak değeri bulunmaması işleri zorlaştırır. Yine de bu algoritmalar önemli bir fikri gösterir: Aritmetik, yalnızca rakamların biçimine değil, temsil kurallarına dayanır. Kuralları doğru tanımladığınızda, antik bir saat kadranı bile küçük bir hesap makinesine dönüşebilir.

``

Sistemin temel mantığı

Platformu üç katmanlı düşünmek işleri kolaylaştırır. H5P, sorunun kullanıcıya nasıl sunulacağını belirler. Moodle; kullanıcı, ders, yetki, not ve raporlama süreçlerini yönetir. Özel soru bankası ise soruların kategorilerini, zorluk seviyelerini, sürümlerini ve istatistiklerini saklar.

Bir sorunun zorluk değeri yalnızca geliştiricinin tahminiyle belirlenmemelidir. Kullanıcıların başarı oranından yararlanılabilir. Bir soruyu $N$ kişi çözmüş ve $D$ kişi doğru cevaplamışsa kolaylık indeksi şöyle hesaplanır:

$p$ değeri 1’e yaklaştıkça soru kolaylaşır. Zorluk puanını $z = 1-p$ olarak tanımlarsak yüksek değerler daha zor soruları temsil eder. Örneğin 100 kişiden 25’i doğru cevap verdiyse $p=0.25$ ve $z=0.75$ olur.

Hangi bileşen ne yapmalı?

H5P içeriği Moodle içine eklentiyle yerleştirilebilir. Ancak sorular farklı uygulamalarda da kullanılacaksa içerikleri yalnızca H5P dosyalarında tutmak yerine merkezi bir API üzerinden sunmak daha sağlıklıdır. Böylece mobil uygulama, web sitesi ve Moodle aynı kaynaktan beslenir.

Örnek soru veri modeli

Aşağıdaki JavaScript nesnesi, çoktan seçmeli bir mantık sorusunun sadeleştirilmiş veri yapısını gösterir:

const question = {
  id: "logic-1042",
  type: "multiple-choice",
  category: "örüntü",
  difficulty: 0.65,
  prompt: "2, 6, 12, 20 dizisindeki sonraki sayı nedir?",
  options: [28, 30, 32, 36],
  correctIndex: 1,
  explanation: "Terimler n × (n + 1) düzenini izler.",
  timeLimit: 45,
  tags: ["matematik", "örüntü"]
};

Bu modelde difficulty uyarlanabilir test üretmek, explanation öğretici geri bildirim göstermek, timeLimit ise süreye dayalı puanlama yapmak için kullanılır. API, bu veriyi H5P’ye uygun biçime dönüştürebilir veya doğrudan özel arayüzde gösterebilir.

Puanlama ve oyunlaştırma

Sadece doğru cevaba puan vermek, rastgele tahminleri ödüllendirebilir. Süreyi ve ipucu kullanımını hesaba katan bir formül daha dengelidir:

Burada $B$ temel puan, $d$ zorluk çarpanı, $t$ harcanan süre, $T$ süre sınırı ve $h$ kullanılan ipucu sayısıdır. max bölümü, doğru fakat yavaş çözümlerin tamamen puansız kalmasını önler. Rozetler, günlük seriler ve kategori bazlı seviyeler de motivasyonu artırabilir; fakat liderlik tablosu zorunlu olmamalıdır.

Uygulama yol haritası

İlk sürümde Moodle kurulumu, H5P eklentisi, kullanıcı girişi ve temel soru API’si hazırlanmalıdır. İkinci aşamada soru editörü, sürümleme, ayrıntılı çözüm açıklamaları ve zorluk analizi eklenebilir. Son aşamada uyarlanabilir sınav motoru devreye girer: Kullanıcı doğru cevapladıkça daha zor, zorlandıkça daha öğretici sorular seçilir.

Ayrıca soru metinleri kullanıcı girdisi içeriyorsa XSS filtreleri uygulanmalı, API erişimi yetkilendirilmeli ve deneme kayıtları kişisel verilerden ayrıştırılmalıdır. Böylece platform, “birkaç bilmece yayınlayan site” olmaktan çıkıp ölçülebilir, genişletilebilir ve gerçekten öğretici bir öğrenme ekosistemine dönüşür.