``

A* algoritmasının temel fikri

A*, ağırlıklı bir graf üzerinde başlangıç düğümünden hedef düğüme giden en düşük maliyetli yolu arar. Her düğüm için üç önemli değer kullanır:

• $g(n)$: Başlangıçtan $n$ düğümüne kadar ödenen gerçek maliyettir.
• $h(n)$: $n$ düğümünden hedefe kalan maliyetin tahminidir.
• $f(n)$: Düğüm üzerinden geçen yolun tahmini toplam maliyetidir.

Algoritma, sıradaki adım olarak $f(n)$ değeri en küçük olan düğümü seçer. Başka bir deyişle geçmişte ödediği maliyet ile gelecekte ödeyeceğini düşündüğü maliyeti birlikte değerlendirir.

Aslında $h(n)=0$ seçilirse A, Dijkstra algoritmasına dönüşür. Dolayısıyla A için Dijkstra’nın hedef bilgisiyle güçlendirilmiş hâli denebilir.

Sezgisel fonksiyon nasıl seçilir?

Kareli ve dört yönde hareket edilen bir haritada Manhattan uzaklığı kullanılabilir:

Çapraz hareket mümkünse Öklid uzaklığı daha uygun olabilir. A*‘ın en kısa yolu garanti etmesi için sezgisel fonksiyonun gerçek kalan maliyeti aşmaması gerekir. Bu özelliğe kabul edilebilirlik denir. Ayrıca tutarlı bir sezgi için her kenarda şu koşul sağlanır:

Tahmin çok küçükse algoritma güvenli fakat Dijkstra’ya yakın çalışır. Tahmin gereğinden büyükse daha hızlı görünebilir, ancak en kısa yol garantisi kaybolabilir.

Python ile A* uygulaması

Aşağıdaki kod, sözlük biçiminde tanımlanmış ağırlıklı bir graf üzerinde çalışır. Öncelik kuyruğu, tahmini toplam maliyeti en düşük düğümü verimli biçimde seçer.

from heapq import heappush, heappop

def a_star(graph, start, goal, heuristic):
    # Kuyruk elemanları: (f maliyeti, düğüm)
    open_set = [(heuristic(start, goal), start)]
    came_from = {}
    g_score = {start: 0}
    visited = set()

    while open_set:
        _, current = heappop(open_set)

        if current in visited:
            continue
        if current == goal:
            path = [current]
            while current in came_from:
                current = came_from[current]
                path.append(current)
            return path[::-1], g_score[goal]

        visited.add(current)

        for neighbor, edge_cost in graph[current]:
            tentative = g_score[current] + edge_cost

            if tentative < g_score.get(neighbor, float("inf")):
                came_from[neighbor] = current
                g_score[neighbor] = tentative
                f_score = tentative + heuristic(neighbor, goal)
                heappush(open_set, (f_score, neighbor))

    return None, float("inf")

Örnek olarak düğümlerin koordinatlarını ve bağlantılarını tanımlayabiliriz:

graph = {
    "A": [("B", 2), ("C", 4)],
    "B": [("A", 2), ("D", 3)],
    "C": [("A", 4), ("D", 1)],
    "D": [("B", 3), ("C", 1), ("E", 2)],
    "E": []
}

coords = {
    "A": (0, 0), "B": (1, 0), "C": (0, 1),
    "D": (1, 1), "E": (2, 1)
}

def manhattan(a, b):
    x1, y1 = coords[a]
    x2, y2 = coords[b]
    return abs(x1 - x2) + abs(y1 - y2)

path, cost = a_star(graph, "A", "E", manhattan)
print(path, cost)

Bu uygulama yolu A, B, D, E veya aynı maliyetli uygun bir alternatif olarak döndürebilir. A* özellikle oyun haritaları, robot navigasyonu ve rota planlama sistemlerinde güçlüdür. Yine de hız avantajı otomatik değildir: kötü bir sezgisel fonksiyon, büyük bellek tüketimi veya düzensiz graf yapısı performansı azaltabilir. İyi bir $h(n)$ seçimi ise A*‘ın gerçek süper gücüdür.

``

Amortize analiz nedir?

Amortize analiz, bir işlemin olasılıksal ortalamasını değil, en kötü durumda oluşabilecek işlem dizisinin ortalama maliyetini inceler. Bu nedenle ortalama durum analizinden farklıdır: Kullanıcı davranışı veya rastgele veri dağılımı hakkında varsayım yapmaz.

$n$ işlemden oluşan bir dizinin toplam maliyeti $T(n)$ ise işlem başına amortize maliyet şöyle hesaplanır:

Örneğin toplam maliyet $T(n)=3n+10$ ise amortize maliyet:

Burada bazı işlemler tek başına pahalı olsa bile uzun vadede her işlem sabit maliyetli kabul edilebilir.

Klasik örnek: Dinamik dizi

Dinamik bir dizinin kapasitesi dolduğunda daha büyük bir alan ayrılır ve eski elemanlar yeni alana kopyalanır. Normal bir ekleme $O(1)$ sürerken yeniden boyutlandırma işlemi $O(n)$ maliyetli olabilir.

class DynamicArray:
    def __init__(self):
        self.capacity = 1
        self.size = 0
        self.data = [None] * self.capacity

    def append(self, value):
        if self.size == self.capacity:
            self._resize()

        self.data[self.size] = value
        self.size += 1

    def _resize(self):
        self.capacity *= 2
        new_data = [None] * self.capacity

        for i in range(self.size):
            new_data[i] = self.data[i]

        self.data = new_data

Bu kodda _resize, mevcut elemanları kopyalayarak kapasiteyi iki katına çıkarır. Boyutlandırmalar $1,2,4,8,\ldots$ elemanda gerçekleşir. $n$ ekleme boyunca yapılan toplam kopyalama sayısı:

Normal eklemelerin maliyeti de $n$ olduğundan toplam maliyet $2n$ civarındadır. Böylece işlem başına maliyet:

Tek bir ekleme $O(n)$ sürebilir; ancak append işleminin amortize maliyeti $O(1)$ olur. Pahalı taşınma masrafı, önceki ucuz eklemelere dağıtılmıştır.

Üç temel amortize analiz yöntemi

1. Toplam maliyet yöntemi

Tüm işlem dizisinin gerçek maliyeti hesaplanır ve işlem sayısına bölünür. Dinamik dizi örneğinde kullandığımız yaklaşım budur.

2. Muhasebe yöntemi

Ucuz işlemlerden gerçek maliyetlerinden biraz daha fazla ücret alınır. Aradaki kredi, gelecekteki pahalı işlemleri karşılamak üzere saklanır. Bir eklemenin gerçek maliyeti $1$ olsa da ona $3$ kredi biçtiğimizi düşünebiliriz. Fazladan kalan krediler yeniden boyutlandırmayı öder; algoritma adeta kendi kumbarasını taşır.

3. Potansiyel yöntemi

Veri yapısında biriken gelecekteki işi matematiksel bir potansiyel fonksiyonuyla gösteririz. Amortize maliyet:

Burada $c_i$ gerçek maliyet, $\Phi(D_i)$ ise işlemden sonraki potansiyeldir. Potansiyel artıyorsa geleceğe kredi bırakılır; azalıyorsa biriktirilen kredi pahalı işlemi karşılar.

Amortize analiz, tek bir kötü ana bakıp paniğe kapılmak yerine filmin tamamını izler. Dinamik diziler, hash tabloları, yığıt işlemleri ve birleşim-bulma yapıları bu yöntemle daha doğru değerlendirilir. Kısacası soru yalnızca “Bu işlem ne kadar pahalı?” değil, “Bu maliyet uzun bir yolculuk boyunca kaç işleme paylaşılıyor?” olmalıdır.

``

Tercihli oylamanın temel fikri

Üç adayımız olsun: Ada, Bora ve Ceren. Seçmenlerden adayları en beğendiklerinden en az beğendiklerine doğru sıralamalarını isteyelim. Sonuçlar şöyle olsun:

Burada yalnızca birinci tercihlere bakarsak Ada 4, Bora 3, Ceren 2 oy alır. Basit çoğulluk yöntemi Ada’yı kazanan ilan eder. Fakat sıralamanın geri kalanını da hesaba katarsak sonuç değişebilir.

Borda sayımı: Her sıraya puan

Borda yönteminde adaylar bulundukları sıraya göre puan kazanır. $m$ aday varsa birinci sıraya $m-1$, ikinci sıraya $m-2$ ve son sıraya $0$ puan verilebilir. Üç aday için puanlar sırasıyla $2$, $1$ ve $0$ olur.

Bir adayın toplam Borda puanı şu şekilde ifade edilir:

Burada $p_i(a)$, $i$ numaralı seçmenin $a$ adayına verdiği sıra puanıdır. Örneğimizde puanlar şöyledir:

Borda kazananı Bora’dır. Ada daha fazla seçmenin ilk tercihi olmasına rağmen birçok seçmen tarafından son sıraya konmuştur. Bora ise geniş bir uzlaşma sağlamıştır. Borda, güçlü sevgiyi ödüllendirirken genel kabulü de önemser.

Condorcet: Bire bir düello

Condorcet yaklaşımı puan toplamak yerine adayları ikili karşılaştırır. Bir aday, diğer bütün adayları bire bir seçimlerde yeniyorsa Condorcet kazananı olur.

Örneğin Bora ile Ada karşılaştırıldığında ilk gruptaki 4 seçmen Ada’yı, diğer 5 seçmen Bora’yı üstün tutar. Bora, Ada’yı $5$–$4$ yener. Bora ile Ceren karşılaşmasında ise ilk iki grup, yani 7 seçmen Bora’yı Ceren’in önüne koyar. Böylece Bora yine kazanır ve Condorcet kazananı olur.

Borda ve Condorcet her zaman aynı sonucu vermez. Ayrıca Condorcet kazananı bulunmayabilir: Ada Bora’yı, Bora Ceren’i, Ceren de Ada’yı yenebilir. Bu duruma Condorcet döngüsü denir; tercihler taş-kâğıt-makas oyununa dönüşür.

Küçük bir Python uygulaması

Aşağıdaki kod, sıralı oyların Borda puanlarını hesaplar:

from collections import defaultdict

oylar = [
    (4, ["Ada", "Bora", "Ceren"]),
    (3, ["Bora", "Ceren", "Ada"]),
    (2, ["Ceren", "Bora", "Ada"]),
]

puanlar = defaultdict(int)
aday_sayisi = len(oylar[0][1])

for secmen, siralama in oylar:
    for sira, aday in enumerate(siralama):
        puanlar[aday] += secmen * (aday_sayisi - sira - 1)

print(dict(puanlar))
print("Kazanan:", max(puanlar, key=puanlar.get))

Döngü, her adayın sıra puanını o tercihi paylaşan seçmen sayısıyla çarpar. Çıktıda Bora 12 puanla kazanır.

Sonuç olarak seçim yöntemi tarafsız bir ayrıntı değil, sonucun parçasıdır. Basit çoğulluk güçlü birinci tercihleri, Borda genel memnuniyeti, Condorcet ise bire bir üstünlüğü ölçer. Bu nedenle “Kim kazandı?” sorusundan önce “Oyları hangi kuralla saydık?” diye sormak gerekir.

``

Problemin kuralları

Dairede $n$ kişi bulunsun. Saymaya birinci kişiden başlayalım ve her $k$ adımda ulaşılan kişiyi eleyelim. Elenen kişinin hemen yanındaki kişiyle saymaya yeniden devam edelim. Amaç iki farklı sonucu hesaplamak olabilir:

1. Kişilerin elenme sırası,
2. Oyunda hayatta kalan son kişi.

Örneğin $n=7$ ve $k=3$ olsun. Kişiler 1, 2, 3, 4, 5, 6, 7 biçiminde numaralandırılır. İlk elenen kişi 3, sonraki kişi 6 olur. Dairenin sonuna gelindiğinde sayma başa döner.

Böylece elenme sırası $[3,6,2,7,5,1]$, kazanan ise 4 olur.

Matematiksel düşünce

Yalnızca kazananı arıyorsak problemi daha küçük problemlere indirebiliriz. Sıfır tabanlı indeks kullanan Josephus bağıntısı şöyledir:

Buradaki mod işlemi, dairenin sonundan sonra tekrar başa dönmemizi sağlar. İnsanları 1’den başlayarak numaralandırmak istediğimiz için nihai sonuca 1 ekleriz:

Bu yaklaşım $O(n)$ zamanda ve $O(1)$ ek bellekte çalışır. Ancak yalnızca kazananı verir; bütün elenme sırasını öğrenmek için daireyi ayrıca simüle etmeliyiz.

Python ile daireyi simüle etmek

Python’daki deque, iki uçtan hızlı ekleme ve çıkarma yapabilen bir kuyruktur. rotate metodu sayesinde sıradaki kişiyi kuyruğun başına taşıyabiliriz.

from collections import deque


def josephus_sirasi(kisi_sayisi, adim):
    if kisi_sayisi < 1 or adim < 1:
        raise ValueError("Kişi sayısı ve adım pozitif olmalıdır.")

    daire = deque(range(1, kisi_sayisi + 1))
    elenenler = []

    while len(daire) > 1:
        # İlk kişi zaten birinci sayıldığı için k-1 konum ilerliyoruz.
        daire.rotate(-(adim - 1))
        elenenler.append(daire.popleft())

    return elenenler, daire[0]


elenenler, kazanan = josephus_sirasi(7, 3)
print("Elenenler:", elenenler)
print("Kazanan:", kazanan)

Programın çıktısı şöyledir:

Elenenler: [3, 6, 2, 7, 5, 1]
Kazanan: 4

rotate(-(adim - 1)) işlemi kuyruğu sola döndürür. Böylece elenecek kişi başa gelir; popleft() da onu daireden çıkarır. Negatif döndürme miktarı büyük olsa bile deque, döngüsel davranışı korur.

Yalnızca kazananı bulmak

Büyük girişlerde elenme listesini saklamak istemiyorsak bağıntıyı döngüyle uygulayabiliriz:

def josephus_kazanan(n, k):
    konum = 0
    for mevcut_boyut in range(2, n + 1):
        konum = (konum + k) % mevcut_boyut
    return konum + 1

Josephus Problemi küçük bir oyun gibi görünse de modüler aritmetik, kuyruklar, yinelemeli bağıntılar ve performans karşılaştırmaları için güçlü bir örnektir. Adım değerini veya başlangıç kişisini değiştirerek farklı senaryolar üretmek, algoritmanın döngüsel mantığını iyice pekiştirir.

Soyut Veri Tipi nedir?

Soyut Veri Tipi veya kısaca ADT (Abstract Data Type), bir veri koleksiyonunu yalnızca değerleri ve izin verilen işlemleri üzerinden tanımlar. ADT, doğrudan bir sınıf ya da belirli bir kod parçası değildir; daha çok uygulanması gereken davranışsal bir sözleşmedir.

Bir ADT kabaca şu bileşenlerle ifade edilebilir:

Burada $D$ olası değerler kümesini, $O$ sunulan işlemleri, $A$ ise bu işlemlerin uyması gereken kuralları belirtir. Örneğin yığın ADT’sinde push, pop, peek ve isEmpty işlemleri bulunur. Ancak elemanların bir diziyle mi, bağlı listeyle mi tutulduğu sözleşmenin parçası değildir.

Temsil bağımsızlığı ve kapsülleme

ADT tasarımının süper gücü temsil bağımsızlığıdır. İstemci kodu iç depolama biçimine erişemiyorsa uygulama daha sonra değiştirilebilir. Başlangıçta dizi kullanan bir yığın, performans ihtiyacı nedeniyle bağlı listeye geçirilebilir; arayüz aynı kaldığı sürece kullanıcı bunu fark etmez.

İç veriyi doğrudan dışarı açmak ise değişmezlerin bozulmasına yol açar. Örneğin istemci yığının eleman dizisini temizleyip sayaç değerini değiştirmezse nesne tutarsız hâle gelir. Bu nedenle veri private, güvenli işlemler ise public tutulmalıdır.

interface Stack<T> {
  push(value: T): void;
  pop(): T;
  peek(): T;
  isEmpty(): boolean;
  size(): number;
}

class ArrayStack<T> implements Stack<T> {
  private items: T[] = [];

  push(value: T): void {
    this.items.push(value);
  }

  pop(): T {
    if (this.isEmpty()) {
      throw new Error("Boş yığından eleman çıkarılamaz");
    }
    return this.items.pop() as T;
  }

  peek(): T {
    if (this.isEmpty()) {
      throw new Error("Boş yığının tepesi yoktur");
    }
    return this.items[this.items.length - 1];
  }

  isEmpty(): boolean {
    return this.items.length === 0;
  }

  size(): number {
    return this.items.length;
  }
}

Bu kodda Stack<T> davranış sözleşmesini, ArrayStack<T> ise dizi tabanlı uygulamayı temsil eder. items alanının özel olması, istemcinin yığını kuralları atlayarak değiştirmesini engeller.

Ön koşullar, son koşullar ve değişmezler

Güvenli bir arayüz tasarlanırken her işlem için üç soru sorulabilir:

• Ön koşul: İşlem çağrılmadan önce ne doğru olmalı?
• Son koşul: İşlem tamamlandığında ne garanti edilir?
• Değişmez: Nesnenin ömrü boyunca hangi kural korunur?

Yığın için pop işleminin ön koşulu $size > 0$ olabilir. Başarılı işlemden sonra:

Ayrıca LIFO kuralı gereği son eklenen eleman ilk çıkar. Ön koşul sağlanmadığında sessizce undefined döndürmek yerine açık bir hata üretmek, hatanın kaynağını görünür kılar.

İyi bir ADT için kısa kontrol listesi

Arayüzü mümkün olduğunca küçük tutun, metotlara niyet belirten adlar verin ve iç nesnelerin değiştirilebilir kopyalarını dışarı sızdırmayın. Geçersiz durumları mümkünse oluşturulamaz hâle getirin; mümkün değilse girişleri doğrulayın. Son olarak testleri iç diziye göre değil, gözlemlenebilir davranışa göre yazın.

Özetle ADT tasarlamak yalnızca veriyi saklamak değildir. Asıl amaç, yanlış kullanımı zorlaştıran ve uygulama ayrıntılarının özgürce değişmesine izin veren bir sözleşme kurmaktır. İyi bir ADT, kullanıcıya düğmeleri gösterir; kablo karmaşasını ise kapağın altında bırakır.

``

Eğriyi oluşturan temel fikir

Bézier eğrisi, Fransız mühendis Pierre Bézier tarafından otomobil gövdelerinin modellenmesinde yaygınlaştırıldı. Temel yaklaşım şaşırtıcı derecede basittir: Eğrinin başlangıç ve bitiş noktalarını belirler, araya da eğriyi kendilerine doğru çeken kontrol noktaları koyarız.

En basit tür olan doğrusal Bézier eğrisinde iki nokta bulunur:

Burada $t$, başlangıçtan sona doğru ilerlemeyi temsil eder. $t=0$ olduğunda $P_0$, $t=1$ olduğunda ise $P_1$ noktasındayız. Aslında bu, iki nokta arasında yapılan doğrusal enterpolasyondur.

Grafik yazılımlarında sık karşılaştığımız kübik Bézier eğrisi ise dört nokta kullanır:

$P_0$ ve $P_3$ eğrinin uçlarıdır. $P_1$ ve $P_2$ ise çoğu tasarım aracında tutamaç olarak gördüğümüz kontrol noktalarıdır. Eğri genellikle bu kontrol noktalarının üzerinden geçmez; yalnızca onların etkisiyle yön değiştirir. Kontrol noktasını çektiğinizde eğrinin lastik gibi uzaması bundandır.

Yumuşaklık nasıl sağlanır?

Birden fazla Bézier parçası uç uca eklenerek karmaşık yollar oluşturulur. Ancak parçaların yalnızca aynı noktada buluşması yeterli değildir. Keskin bir köşe istemiyorsak, birleşim noktasındaki kontrol kollarının aynı doğrultuda olması gerekir. Böylece eğrilerin teğetleri uyumlu olur ve gözümüz geçişi pürüzsüz algılar.

Tasarım programlarındaki simetrik tutamaçlar, iki kolu aynı doğrultuda ve çoğunlukla eşit uzunlukta tutar. Köşe noktası seçildiğinde ise kollar bağımsız hareket eder; böylece sivri dönüşler üretilebilir.

Canvas üzerinde bir Bézier eğrisi

Aşağıdaki JavaScript kodu, HTML Canvas üzerinde kübik bir eğri çizer. Kırmızı noktalar başlangıç ve bitişi, mavi noktalar ise eğrinin yönünü belirleyen kontrol noktalarını gösterir.

const canvas = document.querySelector('canvas');
const ctx = canvas.getContext('2d');

const points = [
  { x: 40,  y: 180 },  // başlangıç
  { x: 100, y: 20 },   // kontrol 1
  { x: 240, y: 260 },  // kontrol 2
  { x: 320, y: 80 }    // bitiş
];

ctx.beginPath();
ctx.moveTo(points[0].x, points[0].y);
ctx.bezierCurveTo(
  points[1].x, points[1].y,
  points[2].x, points[2].y,
  points[3].x, points[3].y
);
ctx.strokeStyle = '#222';
ctx.lineWidth = 4;
ctx.stroke();

points.forEach((p, index) => {
  ctx.beginPath();
  ctx.arc(p.x, p.y, 6, 0, Math.PI * 2);
  ctx.fillStyle = index === 0 || index === 3 ? 'red' : 'blue';
  ctx.fill();
});

Kodda bezierCurveTo, iki kontrol noktasıyla bitiş noktasını alır. Noktaları fareyle sürüklenebilir hâle getirerek küçük bir vektörel çizim aracı bile geliştirebilirsiniz.

Neden vektörel tasarımın yıldızıdır?

Bézier eğrileri çözünürlükten bağımsızdır. Bir logo kartvizit boyutundan bina cephesine büyütülse bile matematiksel tanımı değişmez; eğri yeni ölçekte tekrar hesaplanır. Raster görsellerdeki pikselleşmenin görülmemesi bu yüzdendir.

SVG dosyalarındaki C komutu, fontların dış hatları ve CSS animasyonlarındaki zamanlama fonksiyonları aynı düşünceden yararlanır. Kısacası kontrol noktaları yalnızca çizgileri bükmez; dijital tasarımın ölçeklenebilir, düzenlenebilir ve şaşırtıcı derecede zarif olmasını sağlar.

``

Boole cebri nedir?

George Boole tarafından geliştirilen Boole cebrinde değişkenler yalnızca iki değer alır. Genellikle 0 değeri yanlış, 1 değeri ise doğru anlamına gelir. Elektronik devrelerde bunlar düşük ve yüksek gerilim seviyelerini temsil eder.

Klasik cebirde $2 + 2 = 4$ gibi işlemler yaparken Boole cebrinde sonuçlar doğruluk durumlarına göre belirlenir. Temel işlemler şöyle gösterilebilir:

• AND: $A \cdot B$
• OR: $A + B$
• NOT: $\overline{A}$

Buradaki toplama ve çarpma sembolleri bildiğimiz aritmetik işlemler değildir. Örneğin Boole cebrinde $1 + 1 = 1$ olur; çünkü iki doğru ifadenin OR sonucu yine doğrudur.

Üç temel mantık kapısı

AND kapısı

AND kapısı seçici bir güvenlik görevlisi gibidir: Bütün koşullar sağlanmadan geçişe izin vermez. İki girişli bir AND kapısının denklemi $Y=A \cdot B$ biçimindedir.

Örneğin bir makinenin çalışması için hem güvenlik kapağının kapalı hem de başlatma düğmesinin basılı olması gerekiyorsa AND kapısı kullanılabilir.

OR kapısı

OR kapısı daha hoşgörülüdür. Girişlerden en az biri doğruysa çıkış doğrudur. Denklem $Y=A+B$ şeklindedir. Yalnızca $A=0$ ve $B=0$ olduğunda çıkış 0 olur. Bir binada duman sensörü veya sıcaklık sensörü tehlike algıladığında alarmın çalışması buna örnektir.

NOT kapısı

NOT kapısının tek girişi vardır ve aldığı değeri tersine çevirir:

Giriş 1 ise çıkış 0, giriş 0 ise çıkış 1 olur. Bu nedenle NOT kapısına invertör de denir. Otomatik yanan bir gece lambasında ışık sensörünün sonucu ters çevrilerek karanlıkta enerji verilmesi sağlanabilir.

Kapıları birleştirince ne olur?

Asıl eğlence kapılar birlikte kullanıldığında başlar. Örneğin aşağıdaki ifade, A ve B girişleri doğruyken veya C girişi yanlışken çıkışı etkinleştirir:

Bu ifadeler sadeleştirilerek daha az kapı kullanan devreler üretilebilir. De Morgan kuralları bu noktada oldukça önemlidir:

Daha az kapı; daha düşük maliyet, enerji tüketimi ve gecikme anlamına gelebilir.

Verilog ile küçük bir devre

Mantık devreleri, donanım tanımlama dilleriyle kodlanabilir. Aşağıdaki Verilog modülü aynı birleşik ifadeyi gerçekleştirir:

module mantik_devresi (
    input  wire A,
    input  wire B,
    input  wire C,
    output wire Y
);
    assign Y = (A & B) | ~C;
endmodule

Burada & AND, | OR, ~ ise NOT işlemini temsil eder. assign ifadesi girişlerdeki değişikliklerin çıkışa sürekli yansıtılmasını sağlar. Bu kod bir FPGA üzerinde gerçek fiziksel kapılara dönüştürülebilir.

AND, OR ve NOT kapıları tek başlarına basit görünse de toplayıcılar, işlemciler, bellek denetleyicileri ve karar mekanizmaları bu yapıların birleşiminden doğar. Dijital dünyanın görkemli gökdelenleri, aslında 0 ve 1 biçimindeki küçücük tuğlalar üzerine kuruludur.

Problemin temel modeli

Standart bir satranç tahtası $8 \times 8 = 64$ kareden oluşur. Bir domino taşı yan yana bulunan tam iki kareyi örter. Dolayısıyla tahtanın tamamını kaplamak için

domino gerekir. Bu hesap bize gerekli bir koşul verir: Kaplanacak kare sayısı çift olmalıdır. Fakat çift olması, tek başına kaplanabilirlik garantisi değildir.

Örneğin tahtadan iki kare çıkarırsak geriye 62 kare kalır ve sayı hâlâ çifttir. Yine de çıkarılan karelerin konumu, kaplamayı imkânsız hâle getirebilir. İşin eğlenceli kısmı tam olarak burada başlar.

Siyah-beyaz boyama ve değişmez fikri

Satranç tahtasında her yatay veya dikey komşu kare farklı renktedir. Bu nedenle yerleştirilen her domino mutlaka bir siyah ve bir beyaz kare kaplar. Başlangıçta tahtada 32 siyah ve 32 beyaz kare bulunur.

Karşılıklı iki köşe çıkarılsın. Bu köşeler aynı renktedir; örneğin ikisi de beyaz olsun. Geriye 32 siyah ve 30 beyaz kare kalır. Her domino renklerden birer tane tükettiği için bütün kareleri kaplamak mümkün değildir.

Bu argümanda korunan özelliğe değişmez denir. Domino hangi konuma yerleştirilirse yerleştirilsin kaplanan siyah ve beyaz kare sayıları eşittir.

Burada önemli bir ayrıntı vardır: Renk sayılarının eşitliği gerekli koşuldur, fakat her zaman yeterli değildir. Bazı düzensiz bölgelerde renkler dengeli olsa bile geometrik sıkışmalar kaplamayı engelleyebilir.

Problem bir grafa nasıl dönüşür?

Her kareyi bir düğüm, kenar paylaşan iki kareyi de bir bağlantı olarak düşünelim. Siyah kareler bir grubu, beyaz kareler diğer grubu oluşturur. Böylece iki parçalı graf elde edilir.

Bir domino, bağlı bir siyah-beyaz düğüm çiftini seçer. Tüm tahtayı kaplamak ise her düğümün tam bir kez kullanıldığı mükemmel eşleşme bulmakla aynıdır.

Bu bakış açısı sayesinde problem yalnızca satranç tahtaları için değil, delikli ve düzensiz bölgeler için de algoritmik olarak incelenebilir. Hopcroft–Karp algoritması iki parçalı graflarda eşleşmeyi yaklaşık $O(E\sqrt{V})$ zamanda bulur.

Küçük tahtalarda Python ile arama

Aşağıdaki geri izleme kodu, verilen bölgenin kaplanabilir olup olmadığını sınar. Kod ilk boş kareyi seçer, sağa veya aşağıya domino koymayı dener ve çıkmazda önceki seçime döner.

def kaplanabilir(kareler):
    kareler = set(kareler)

    def ara(kalan):
        if not kalan:
            return True

        r, c = min(kalan)
        for komsu in [(r + 1, c), (r, c + 1)]:
            if komsu in kalan:
                yeni = kalan - {(r, c), komsu}
                if ara(yeni):
                    return True
        return False

    return ara(kareler)

bolge = {(r, c) for r in range(4) for c in range(4)}
print(kaplanabilir(bolge))  # True

Bu yöntem öğreticidir ancak olası yerleşimlerin sayısı hızla büyüdüğü için büyük tahtalarda pahalıdır. Önce renk dengesi gibi ucuz testleri uygulamak, ardından eşleşme algoritmasına geçmek daha akıllıcadır.

Sonuç

Domino kaplama problemi, basit görünen bir sorunun nasıl sayma, boyama ve graf teorisine açıldığını gösterir. En değerli ders şudur: Bazen çözümü inşa etmekten önce, çözümün neden var olamayacağını kanıtlamak çok daha kolaydır. Birkaç renk ve doğru seçilmiş bir değişmez, milyarlarca denemenin yerini tutabilir.

``

Takvim neden matematikle hesaplanabilir?

Hafta, yedi günde bir kendini tekrar eden döngüdür. Bu nedenle hesaplamaların kalbinde modüler aritmetik bulunur. Bir günün sayısal değerini $d$ kabul edersek sonraki gün şu şekilde yazılabilir:

Örneğin pazartesiye 0 değerini verirsek 10 gün sonrası $(0+10) \bmod 7=3$, yani perşembe olur. Takvim algoritmaları da belirli bir başlangıçtan itibaren geçen günleri hesaplayıp sonucu 7’ye böler.

Ancak yıl uzunluğu tam olarak 365 gün değildir. Gregoryen takviminde artık yıl kuralları şöyledir:

• 4’e bölünen yıllar artık yıldır.
• 100’e bölünen yıllar artık yıl değildir.
• 400’e bölünen yıllar yeniden artık yıldır.

Buna göre 2000 artık yılken 1900 değildir. Bu düzeltme, takvimin mevsimlerden uzaklaşmasını önler.

Zeller bağıntısı

En tanınmış ebedi takvim yöntemlerinden biri Zeller bağıntısıdır. Gregoryen takvimi için formül şöyledir:

Buradaki değişkenler:

Buradaki küçük numara hilesi önemlidir: Ocak ve şubat, önceki yılın 13. ve 14. ayı sayılır. Böylece artık gün düzeltmesi formüle daha doğal biçimde katılır. Örneğin Şubat 2024 hesaplanırken yıl 2023 kabul edilir.

Python ile uygulama

Aşağıdaki fonksiyon formülü doğrudan uygular ve sayısal sonucu okunabilir bir gün adına dönüştürür:

def haftanin_gunu(gun, ay, yil):
    # Zeller'de ocak ve şubat önceki yılın aylarıdır.
    if ay < 3:
        ay += 12
        yil -= 1

    K = yil % 100
    J = yil // 100

    h = (
        gun
        + (13 * (ay + 1)) // 5
        + K
        + K // 4
        + J // 4
        + 5 * J
    ) % 7

    gunler = [
        "Cumartesi", "Pazar", "Pazartesi", "Salı",
        "Çarşamba", "Perşembe", "Cuma"
    ]
    return gunler[h]

print(haftanin_gunu(29, 10, 1923))  # Pazartesi
print(haftanin_gunu(1, 1, 2000))    # Cumartesi

Tam sayı bölmesi için // kullanılması kritiktir; formüldeki taban fonksiyonu $\lfloor x \rfloor$, ondalık kısmın atılmasını ister. % 7 işlemi ise büyük toplamı haftanın yedi olası gününden birine indirger.

Hangi yaklaşım ne zaman kullanılmalı?

Algoritmanın çalışma süresi $O(1)$’dir; tarih ne kadar uzak olursa olsun yalnızca birkaç aritmetik işlem yapılır. Yine de tarihsel tarihlerde dikkat gerekir: Bu formül ileriye ve geriye uzatılmış Gregoryen takvimi varsayar. Gregoryen takvimine geçilmeden önce kullanılan Jülyen takvimi veya ülkelerin farklı geçiş tarihleri hesaba katılacaksa ayrıca dönüşüm kuralları uygulanmalıdır. Kısacası ebedi takvim, matematiğin zamanı küçük bir mod 7 döngüsüne nasıl sığdırabildiğinin zarif bir örneğidir.

Bir haritadaki en yakın kafeyi, renk uzayındaki en benzer tonu veya oyun dünyasında karaktere en yakın nesneyi bulmak istediğinizi düşünün. Tüm noktaları tek tek karşılaştırmak kolaydır; ancak veri büyüdüğünde işlem kısa sürede kaplumbağa hızına iner. kD-ağacı, çok boyutlu noktaları akıllıca bölerek arama sırasında ilgisiz bölgeleri elememizi sağlayan uzamsal bir veri yapısıdır.

``

kD-ağacının temel fikri

Buradaki k, noktaların boyut sayısını ifade eder. İki boyutlu bir nokta $(x,y)$, üç boyutlu bir nokta $(x,y,z)$ biçimindedir. Ağaç oluşturulurken her seviyede farklı bir eksen kullanılır. Örneğin iki boyutta kök düğüm $x$ eksenine, çocukları $y$ eksenine, sonraki seviye yeniden $x$ eksenine göre ayrılır.

Derinliği $d$ olan bir düğümün bölme ekseni şöyle seçilebilir:

Dengeli bir ağaç kurmak için noktalar ilgili eksene göre sıralanır ve ortanca nokta düğüm yapılır. Ortancadan küçük değerler sol, büyük değerler sağ alt ağaca gider. Böylece uzay, iç içe geçmiş dikdörtgensel bölgelere ayrılır.

Hash tablosu yakınlık kavramını doğal olarak desteklemez. kD-ağacının avantajı ise geometrik uzaklıktan yararlanmasıdır. Öklid uzaklığının karesi hesaplanarak gereksiz karekök işleminden kaçınılabilir:

Python ile ağacı oluşturalım

Aşağıdaki kod, noktaları ortanca değer çevresinde bölerek dengeli sayılabilecek bir kD-ağacı kurar:

class Node:
    def __init__(self, point, axis, left=None, right=None):
        self.point = point
        self.axis = axis
        self.left = left
        self.right = right


def build_kdtree(points, depth=0):
    if not points:
        return None

    k = len(points[0])
    axis = depth % k
    points = sorted(points, key=lambda p: p[axis])
    middle = len(points) // 2

    return Node(
        point=points[middle],
        axis=axis,
        left=build_kdtree(points[:middle], depth + 1),
        right=build_kdtree(points[middle + 1:], depth + 1)
    )

axis, düğümün uzayı hangi koordinata göre böldüğünü saklar. Her çağrıda veri iki parçaya ayrılır; bu da sonraki sorgularda bütün noktaları dolaşma ihtiyacını azaltır.

En yakın komşuyu aramak

Arama önce hedefin bulunduğu tarafa ilerler. Ardından hedef ile bölme düzlemi arasındaki fark, mevcut en iyi uzaklıktan küçükse diğer dal da incelenir. Bu adıma geri izleme denir.

def nearest(node, target, best=None):
    if node is None:
        return best

    distance = sum((a - b) ** 2
                   for a, b in zip(node.point, target))

    if best is None or distance < best[1]:
        best = (node.point, distance)

    axis = node.axis
    difference = target[axis] - node.point[axis]

    near = node.left if difference < 0 else node.right
    far = node.right if difference < 0 else node.left

    best = nearest(near, target, best)

    if difference ** 2 < best[1]:
        best = nearest(far, target, best)

    return best


points = [(2, 3), (5, 4), (9, 6), (4, 7), (8, 1), (7, 2)]
tree = build_kdtree(points)
point, squared_distance = nearest(tree, (6, 3))
print(point, squared_distance)

Kritik koşul difference ** 2 < best[1] ifadesidir. Bölme düzlemi mevcut adaydan daha uzaktaysa karşı tarafta daha iyi bir nokta bulunamaz; dolayısıyla o dal budanır.

Ne zaman tercih edilmeli?

kD-ağaçları harita uygulamaları, çarpışma tespiti ve düşük boyutlu makine öğrenmesi verileri için uygundur. Ancak boyut sayısı yükseldikçe bölgeler birbirine benzemeye başlar ve daha az dal elenir. “Boyutluluk laneti” olarak bilinen bu durumda sorgu maliyeti yeniden $O(n)$ seviyesine yaklaşabilir. Çok yüksek boyutlarda yaklaşık komşu arama algoritmaları daha iyi bir seçimdir; fakat iki veya üç boyutlu dünyalarda kD-ağacı hâlâ oldukça çevik bir rehberdir.