Mirasın temelinde is-a ilişkisi vardır. Yani “Büyücü bir Karakterdir” diyebiliyorsak, Wizard sınıfı Character sınıfından türeyebilir. Matematiksel olarak bunu kümeler gibi düşünebiliriz: Wizard \subset Character değil, daha doğru ifadeyle Wizard nesneleri Character arayüzünü de taşır. Bir taban sınıfın özellik kümesi $B$, türetilmiş sınıfın eklediği özellikler $E$ ise, türetilmiş sınıfın toplam yeteneği yaklaşık olarak $D = B \cup E$ şeklinde düşünülebilir.

Temel Miras Söz Dizimi

C++’ta miras şu şekilde tanımlanır:

class Character {
public:
    string name;
    int health;

    void move() {
        cout << name << " hareket ediyor." << endl;
    }
};

class Wizard : public Character {
public:
    void castSpell() {
        cout << name << " büyü yapıyor!" << endl;
    }
};

Burada Wizard, Character sınıfından public miras alır. Bu sayede Wizard nesnesi hem name, health, move() üyelerine hem de kendi castSpell() fonksiyonuna sahip olur.

int main() {
    Wizard merlin;
    merlin.name = "Merlin";
    merlin.health = 100;
    merlin.move();
    merlin.castSpell();
}

Bu kodda move() fonksiyonu Wizard içinde yazılmadığı halde çalışır; çünkü taban sınıftan devralınmıştır. Bu, mirasın en pratik tarafıdır: ortak davranışları merkezileştirmek.

Public, Protected ve Private Miras

C++’ta miras türü, taban sınıftaki erişim seviyelerinin türetilmiş sınıfa nasıl aktarılacağını belirler.

Günlük kullanımda en sık public miras tercih edilir. Çünkü nesne yönelimli tasarımda türetilmiş sınıfın taban sınıf yerine geçebilmesi beklenir. Buna Liskov Yerine Geçme Prensibi denir: Eğer Wizard bir Character ise, Character* bekleyen bir fonksiyona Wizard* gönderebilmeliyiz.

Protected: Aile Sırrı

private üyeler sadece sınıfın kendisi tarafından erişilebilir. Ancak bazen türetilmiş sınıfların da bazı verilere erişmesi gerekir. Bu durumda protected kullanılır.

class Character {
protected:
    int health;

public:
    Character(int h) : health(h) {}

    void showHealth() {
        cout << "Can: " << health << endl;
    }
};

class Warrior : public Character {
public:
    Warrior() : Character(150) {}

    void takeDamage(int amount) {
        health -= amount;
    }
};

Burada health, dış dünyaya kapalıdır ama Warrior tarafından erişilebilir. Bu, kapsüllemeyi tamamen bozmadan esneklik sağlar.

Fonksiyon Ezme ve Sanal Fonksiyonlar

Mirasın asıl yıldızı polimorfizm ile parlar. Taban sınıftaki bir davranışı türetilmiş sınıfta farklılaştırmak için virtual kullanılır.

class Character {
public:
    virtual void attack() {
        cout << "Karakter saldırıyor." << endl;
    }
};

class Archer : public Character {
public:
    void attack() override {
        cout << "Okçu ok fırlatıyor!" << endl;
    }
};

virtual, çalışma zamanında doğru fonksiyonun seçilmesini sağlar. Bu mekanizma dinamik bağlama olarak bilinir. Basitçe maliyetini şöyle düşünebiliriz: normal fonksiyon çağrısı $O(1)$ iken sanal çağrı da pratikte $O(1)$ kabul edilir, fakat küçük bir yönlendirme maliyeti vardır.

Yapıcı ve Yıkıcı Fonksiyonlara Dikkat

Türetilmiş sınıf oluşturulurken önce taban sınıfın yapıcısı, sonra türetilmiş sınıfın yapıcısı çalışır. Yıkımda ise sıra tersinedir. Eğer taban sınıf üzerinden türetilmiş nesneleri sileceksen, yıkıcı fonksiyon virtual olmalıdır.

class Character {
public:
    virtual ~Character() {
        cout << "Character yok edildi." << endl;
    }
};

Aksi halde bellek sızıntısı veya eksik temizlik gibi tatsız sürprizlerle karşılaşabilirsin.

Ne Zaman Miras Kullanılmalı?

Miras her derde deva değildir. Eğer ilişki “bir şeydir” değil de “bir şeye sahiptir” şeklindeyse, kompozisyon daha iyi olabilir. Örneğin Car sınıfı Engine sınıfından miras almamalı; onun yerine bir Engine nesnesine sahip olmalıdır.

Sonuç olarak C++ sınıf mirası, doğru kullanıldığında kod tekrarını azaltır, tasarımı anlaşılır kılar ve polimorfizmle güçlü mimariler kurmanı sağlar. Ama unutma: Miras aile bağı gibidir; doğru akrabayı seçersen huzur, yanlış akrabayı seçersen sonsuz refactoring getirir!

Asal Sayı Nedir?

Asal sayı, sadece 1’e ve kendisine tam bölünebilen 1’den büyük doğal sayıdır.

Örnek asal sayılar:

2, 3, 5, 7, 11, 13, 17, 19, 23

Asal olmayan sayılara asal olmayan sayı veya bileşik sayı denir.

Örneğin:

• 4 asal değildir çünkü 1, 2 ve 4’e bölünür.
• 9 asal değildir çünkü 1, 3 ve 9’a bölünür.
• 10 asal değildir çünkü 1, 2, 5 ve 10’a bölünür.

Önemli bilgi: 1 asal sayı değildir.

1. Bir Sayının Asal Olup Olmadığını Bulma

İlk olarak kullanıcıdan bir sayı alalım ve bu sayının asal olup olmadığını kontrol edelim.

sayi = int(input("Bir sayı giriniz: "))

asal_mi = True

if sayi <= 1:
    asal_mi = False
else:
    for i in range(2, sayi):
        if sayi % i == 0:
            asal_mi = False
            break

if asal_mi:
    print(sayi, "asal sayıdır.")
else:
    print(sayi, "asal sayı değildir.")

Program Nasıl Çalışır?

Bu programda şu adımlar gerçekleşir:

1. Kullanıcıdan bir sayı alınır.
2. Başlangıçta sayının asal olduğu varsayılır.
3. Eğer sayı 1 veya daha küçükse asal değildir.
4. Sayı, 2’den başlayarak kendisinden bir önceki sayıya kadar bölünmeye çalışılır.
5. Eğer tam bölünürse asal değildir.
6. Hiçbir sayıya tam bölünmezse asaldır.

Örnek Çalışma

Bir sayı giriniz: 7
7 asal sayıdır.

Bir sayı giriniz: 12
12 asal sayı değildir.

2. Daha Kolay Anlamak İçin Bölme Kontrolü

Python’da % işareti mod alma anlamına gelir. Yani bölme işleminden kalan sayıyı verir.

Örnek:

print(10 % 2)  # 0
print(10 % 3)  # 1
print(15 % 5)  # 0

Eğer bir sayının başka bir sayıya bölümünden kalan 0 ise, bu sayı tam bölünür.

Örneğin:

12 % 3 == 0

Bu ifade doğrudur çünkü 12, 3’e tam bölünür.

3. Fonksiyon Kullanarak Asal Sayı Kontrolü

Şimdi aynı işlemi bir fonksiyon ile yapalım.

Fonksiyonlar, aynı kodu tekrar tekrar yazmamızı engeller.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, sayi):
        if sayi % i == 0:
            return False

    return True

numara = int(input("Bir sayı giriniz: "))

if asal_mi(numara):
    print(numara, "asal sayıdır.")
else:
    print(numara, "asal sayı değildir.")

Fonksiyon Ne İşe Yarar?

Bu bölümde asal_mi adında bir fonksiyon yazdık.

def asal_mi(sayi):

Bu fonksiyon içine bir sayı gönderiyoruz. Fonksiyon bize True veya False döndürüyor.

4. 1’den N’e Kadar Olan Asal Sayıları Bulma

Şimdi kullanıcıdan bir üst sınır alalım. Örneğin kullanıcı 50 girerse, 1’den 50’ye kadar olan asal sayıları ekrana yazdıralım.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, sayi):
        if sayi % i == 0:
            return False

    return True

ust_sinir = int(input("Üst sınırı giriniz: "))

print("Asal sayılar:")

for sayi in range(1, ust_sinir + 1):
    if asal_mi(sayi):
        print(sayi)

Örnek Çalışma

Üst sınırı giriniz: 20
Asal sayılar:
2
3
5
7
11
13
17
19

Bu program 1’den başlayıp kullanıcının girdiği sayıya kadar tüm sayıları kontrol eder.

5. Asal Sayıları Liste İçinde Saklama

Bazen asal sayıları sadece ekrana yazdırmak yerine bir listede saklamak isteyebiliriz.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, sayi):
        if sayi % i == 0:
            return False

    return True

ust_sinir = int(input("Üst sınırı giriniz: "))
asal_sayilar = []

for sayi in range(1, ust_sinir + 1):
    if asal_mi(sayi):
        asal_sayilar.append(sayi)

print("Asal sayılar:", asal_sayilar)
print("Toplam asal sayı adedi:", len(asal_sayilar))

Örnek Çalışma

Üst sınırı giriniz: 30
Asal sayılar: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
Toplam asal sayı adedi: 10

Burada iki yeni şey kullandık:

• append() listeye yeni eleman ekler.
• len() listenin kaç elemanlı olduğunu verir.

6. Daha Hızlı Asal Sayı Kontrolü

Bir sayının asal olup olmadığını anlamak için her zaman 2’den sayının kendisine kadar kontrol yapmamıza gerek yoktur.

Örneğin 36 sayısını düşünelim:

1 x 36
2 x 18
3 x 12
4 x 9
6 x 6
9 x 4
12 x 3
18 x 2
36 x 1

Gördüğün gibi çarpanlar bir noktadan sonra tekrar etmeye başlıyor. Bu yüzden bir sayının kareköküne kadar kontrol etmek yeterlidir.

Basitçe söylemek gerekirse:

Bir sayı asal değilse, en az bir böleni karekökünden küçük veya ona eşittir.

Python’da karekök almak için ** 0.5 kullanabiliriz.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

sayi = int(input("Bir sayı giriniz: "))

if asal_mi(sayi):
    print(sayi, "asal sayıdır.")
else:
    print(sayi, "asal sayı değildir.")

Neden Daha Hızlı?

Diyelim ki sayı 100 olsun.

İlk yöntemde 2’den 99’a kadar kontrol yapılır.

Daha hızlı yöntemde ise sadece 2’den 10’a kadar kontrol yapılır çünkü:

100'ün karekökü = 10

Bu yöntem büyük sayılarda daha hızlı çalışır.

7. Belirli Bir Aralıktaki Asal Sayıları Bulma

Şimdi kullanıcıdan başlangıç ve bitiş değerleri alalım. Bu iki sayı arasındaki asal sayıları bulalım.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

baslangic = int(input("Başlangıç sayısını giriniz: "))
bitis = int(input("Bitiş sayısını giriniz: "))

print(baslangic, "ile", bitis, "arasındaki asal sayılar:")

for sayi in range(baslangic, bitis + 1):
    if asal_mi(sayi):
        print(sayi)

Örnek Çalışma

Başlangıç sayısını giriniz: 10
Bitiş sayısını giriniz: 50
10 ile 50 arasındaki asal sayılar:
11
13
17
19
23
29
31
37
41
43
47

8. İlk N Tane Asal Sayıyı Bulma

Bu kez kullanıcı kaç tane asal sayı görmek istediğini girsin.

Örneğin kullanıcı 10 girerse, ilk 10 asal sayıyı yazdıralım.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

adet = int(input("Kaç tane asal sayı yazdırılsın? "))
bulunan = 0
sayi = 2

while bulunan < adet:
    if asal_mi(sayi):
        print(sayi)
        bulunan += 1

    sayi += 1

Bu Programda Ne Öğrendik?

Bu programda while döngüsü kullandık.

while döngüsü, bir koşul doğru olduğu sürece çalışır.

while bulunan < adet:

Bu satırın anlamı şudur:

Bulunan asal sayı miktarı, istenen adetten küçük olduğu sürece devam et.

9. Mini Proje: Asal Sayı Menüsü

Şimdi öğrendiklerimizi küçük bir programa dönüştürelim. Kullanıcı menüden seçim yapsın.

def asal_mi(sayi):
    if sayi <= 1:
        return False

    for i in range(2, int(sayi ** 0.5) + 1):
        if sayi % i == 0:
            return False

    return True

while True:
    print("\n--- Asal Sayı Programı ---")
    print("1 - Bir sayının asal olup olmadığını kontrol et")
    print("2 - 1'den N'e kadar asal sayıları yazdır")
    print("3 - Belirli aralıktaki asal sayıları yazdır")
    print("4 - Çıkış")

    secim = input("Seçiminiz: ")

    if secim == "1":
        sayi = int(input("Sayı giriniz: "))
        if asal_mi(sayi):
            print(sayi, "asal sayıdır.")
        else:
            print(sayi, "asal sayı değildir.")

    elif secim == "2":
        ust_sinir = int(input("Üst sınır giriniz: "))
        for sayi in range(1, ust_sinir + 1):
            if asal_mi(sayi):
                print(sayi)

    elif secim == "3":
        baslangic = int(input("Başlangıç sayısı: "))
        bitis = int(input("Bitiş sayısı: "))
        for sayi in range(baslangic, bitis + 1):
            if asal_mi(sayi):
                print(sayi)

    elif secim == "4":
        print("Programdan çıkılıyor...")
        break

    else:
        print("Hatalı seçim yaptınız.")

Bu mini proje ile şunları kullanmış olduk:

• if-elif-else
• for döngüsü
• while döngüsü
• fonksiyonlar
• listeler ve sayılarla işlem yapma

Sık Yapılan Hatalar

1. 1 Sayısını Asal Kabul Etmek

Yanlış:

if sayi == 1:
    print("Asal")

Doğru:

if sayi <= 1:
    print("Asal değil")

2. break Kullanmayı Unutmak

Bir sayı asal değilse, bölen bulunduğu anda döngüyü durdurabiliriz.

if sayi % i == 0:
    asal_mi = False
    break

Bu programı daha hızlı yapar.

3. Girilen Değeri Sayıya Çevirmemek

input() her zaman metin yani string döndürür. Matematik işlemleri için int() kullanmalıyız.

sayi = int(input("Sayı giriniz: "))

Alıştırmalar

Aşağıdaki alıştırmaları yaparak konuyu daha iyi öğrenebilirsin:

1. Kullanıcıdan 5 sayı alıp hangilerinin asal olduğunu yazdıran program yaz.
2. 1 ile 100 arasındaki asal sayıları bir listeye ekle ve listeyi yazdır.
3. Kullanıcının girdiği iki sayı arasındaki asal sayıların toplamını bulan program yaz.
4. İlk 20 asal sayıyı ekrana yazdır.
5. Asal sayıları yan yana yazdıran bir program yaz.

Örnek yan yana yazdırma:

print(sayi, end=" ")

Sonuç

Bu yazıda Python ile asal sayıları bulmayı öğrendik. Önce bir sayının asal olup olmadığını kontrol ettik, sonra belirli aralıklardaki asal sayıları bulduk ve en sonunda menülü küçük bir program yaptık.

Asal sayı programları, algoritma mantığını geliştirmek için çok güzel örneklerdir. Çünkü bu programlarda döngüler, koşullar, fonksiyonlar ve listeler birlikte kullanılır.

En basit haliyle bir görüntü, sayılardan oluşan bir matristir. Gri tonlamalı bir resimde her piksel 0 ile 255 arasında değer alır. 0 siyahı, 255 beyazı temsil eder. Renkli görüntülerde ise genellikle üç kanal bulunur: kırmızı, yeşil ve mavi. Yani bir piksel aslında şöyle düşünülebilir: $(R, G, B)$.

``

Görüntü İşleme İçin Popüler Python Kütüphaneleri

Python ekosisteminde görüntü işleme için birçok araç var. En sık kullanılanları şöyle özetleyebiliriz:

OpenCV, özellikle kamera görüntüsü alma, filtre uygulama, nesne tespiti ve video işleme gibi konularda oldukça güçlüdür. NumPy ise görüntüyü bir sayı dizisi olarak manipüle etmemizi sağlar.

İlk Adım: Resmi Okuma ve Gösterme

Aşağıdaki örnekte bir görseli okuyup gri tonlamaya çeviriyoruz:

import cv2
import matplotlib.pyplot as plt

img = cv2.imread('kedi.jpg')
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

plt.subplot(1, 2, 1)
plt.title('Renkli')
plt.imshow(img_rgb)
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Gri Tonlama')
plt.imshow(gray, cmap='gray')
plt.axis('off')

plt.show()

Burada dikkat edilmesi gereken minik bir tuzak var: OpenCV görselleri varsayılan olarak BGR formatında okur, Matplotlib ise RGB bekler. Yani kırmızı kediniz bir anda mavi uzaylıya dönüşmesin diye cv2.cvtColor kullanıyoruz.

Piksel Mantığı: Matematik Nerede Devreye Girer?

Görüntü işleme aslında bol bol matematik içerir. Örneğin gri tonlama dönüşümü çoğu zaman renk kanallarının ağırlıklı toplamıyla yapılır:

Bu formül insan gözünün yeşile daha duyarlı olmasını hesaba katar. Yani her kanal eşit önemde değildir. Bir başka temel işlem de eşikleme, yani thresholding işlemidir:

Burada $T$ eşik değeridir. Piksel değeri bu eşiğin üzerindeyse beyaz, altındaysa siyah yapılır. Bu yöntem belge tarama, plaka okuma ve basit nesne ayırma işlemlerinde sıkça kullanılır.

Basit Bir Filtre Uygulayalım

Bulanıklaştırma, gürültü azaltmak için kullanılan temel işlemlerden biridir. OpenCV ile birkaç satır yeterlidir:

import cv2

img = cv2.imread('sokak.jpg')
blur = cv2.GaussianBlur(img, (7, 7), 0)
edge = cv2.Canny(blur, 100, 200)

cv2.imwrite('bulanık.jpg', blur)
cv2.imwrite('kenarlar.jpg', edge)
print('Görüntüler kaydedildi!')

GaussianBlur, görüntüyü yumuşatır. Canny ise kenarları tespit eder. Böylece bir görüntüdeki şekiller, sınırlar ve nesne hatları daha belirgin hale gelir.

Mini Proje Fikri: Otomatik Belge Tarayıcı

Python ile eğlenceli bir proje yapmak istersen telefonla çekilmiş belge fotoğraflarını taranmış gibi düzelten bir uygulama geliştirebilirsin. Genel adımlar şöyle olur:

1. Görüntüyü oku.
2. Gri tonlamaya çevir.
3. Gürültüyü azalt.
4. Kenarları bul.
5. En büyük dörtgeni tespit et.
6. Perspektif dönüşümü uygula.
7. Sonucu siyah-beyaz belge gibi kaydet.

Bu proje hem OpenCV pratiği kazandırır hem de gerçek hayatta işe yarar. Üstelik arkadaşlarına ‘Ben scanner yaptım’ deme lüksü sağlar.

Sonuç

Python ile görüntü işleme, ilk bakışta karmaşık görünse de temel mantık oldukça basittir: görüntüleri matris olarak düşün, pikseller üzerinde işlem yap ve sonucu görselleştir. OpenCV, NumPy ve Matplotlib üçlüsüyle kısa sürede etkileyici uygulamalar geliştirebilirsin. Bir sonraki adımda kamera akışından canlı görüntü işleme, yüz algılama veya nesne takibi gibi daha havalı konulara geçebilirsin. Kısacası, pikseller seni bekliyor!

Minimax algoritmasının temel fikri şudur: Biz skoru maksimize etmeye çalışırız, rakip ise bizim skorumuza göre en kötü sonucu seçer. Yani bot kendi açısından en iyi hamleyi ararken, rakibin de en iyi savunmayı yapacağını varsayar. Matematiksel olarak:

rakibin sırası geldiğinde ise:

Burada $s$ konumu, $a$ hamleyi, $A(s)$ mevcut hamleleri ve $V(s)$ konumun değerini temsil eder.

Python’da satranç kurallarını sıfırdan yazmak yerine python-chess kütüphanesini kullanabiliriz. Böylece rok, şah, mat, geçerken alma gibi detaylarla boğuşmadan algoritmaya odaklanırız.

import chess

piece_values = {
    chess.PAWN: 100,
    chess.KNIGHT: 320,
    chess.BISHOP: 330,
    chess.ROOK: 500,
    chess.QUEEN: 900,
    chess.KING: 0
}

def evaluate(board):
    if board.is_checkmate():
        return -99999 if board.turn else 99999
    if board.is_stalemate() or board.is_insufficient_material():
        return 0

    score = 0
    for square, piece in board.piece_map().items():
        value = piece_values[piece.piece_type]
        score += value if piece.color == chess.WHITE else -value
    return score

Bu fonksiyon oldukça basit çalışır: Tahtadaki taşları dolaşır, beyaz taşları artı, siyah taşları eksi puan olarak yazar. Eğer botumuz beyaz oynuyorsa pozitif skor iyi, siyah oynuyorsa negatif skor iyidir. Elbette gerçek motorlar yalnızca taş saymaz; merkez kontrolü, şah güvenliği, piyon yapısı gibi konuları da değerlendirir.

Şimdi minimax fonksiyonunu yazalım:

def minimax(board, depth, maximizing):
    if depth == 0 or board.is_game_over():
        return evaluate(board)

    if maximizing:
        best_score = -float('inf')
        for move in board.legal_moves:
            board.push(move)
            score = minimax(board, depth - 1, False)
            board.pop()
            best_score = max(best_score, score)
        return best_score
    else:
        best_score = float('inf')
        for move in board.legal_moves:
            board.push(move)
            score = minimax(board, depth - 1, True)
            board.pop()
            best_score = min(best_score, score)
        return best_score

Burada push hamleyi tahtaya uygular, pop ise geri alır. Bu ikili, karar ağacında ileri gidip geri dönmemizi sağlar. Yani bot küçük bir zaman yolculuğu yapar: “Bu hamleyi oynarsam, sonra şu olur, rakip bunu yapar…” diye düşünür.

En iyi hamleyi seçmek için tüm yasal hamleleri deneriz:

def find_best_move(board, depth):
    best_move = None
    best_score = -float('inf') if board.turn == chess.WHITE else float('inf')

    for move in board.legal_moves:
        board.push(move)
        score = minimax(board, depth - 1, board.turn == chess.WHITE)
        board.pop()

        if board.turn == chess.WHITE and score > best_score:
            best_score = score
            best_move = move
        elif board.turn == chess.BLACK and score < best_score:
            best_score = score
            best_move = move

    return best_move

Minimax’ın en büyük sorunu dallanma faktörüdür. Ortalama her konumda yaklaşık 30 yasal hamle varsa, derinlik $d$ için karmaşıklık yaklaşık $O(30^d)$ olur. Bu nedenle gerçek motorlarda alpha-beta budama kullanılır. Alpha-beta, sonucu değiştirmeyecek dalları keserek aynı kararı daha hızlı verir.

Sonuç olarak bu proje, sadece satranç botu yazmak değildir; aynı zamanda özyineleme, karar ağaçları, sezgisel değerlendirme ve oyun teorisini pratikte öğrenmektir. İlk motorunuz dünya şampiyonunu yenemeyebilir ama bir taşı bedavaya bırakmadığında duyacağınız mutluluk paha biçilemez. Sonraki adım olarak alpha-beta budama, açılış kitabı ve taş-kare tabloları ekleyerek botunuzu küçük bir dijital büyükustaya dönüştürebilirsiniz.

Temel Kavramlar

Yapay Zeka Nedir — Ne Değildir?

Yapay zeka (YZ), geniş anlamda makinelerin akıllıca görünen kararlar almasını sağlayan her türlü tekniği kapsar. Dar anlamda ise bugün çoğunlukla istatistiksel örüntü eşleştirme demektir.

Bir YZ sistemi “anlamıyor”. Veriyle örüntü öğreniyor. Anlam ile örüntü arasındaki mesafe, alanın en büyük tartışmasıdır.

Popüler ayrım:

Makine Öğrenmesi

Klasik programlamada kuralları insan yazar; makine öğrenmesinde (ML) kuralları veriden çıkarırsın.

Klasik : Veri + Kurallar → Çıktı
ML     : Veri + Çıktı   → Kurallar

Üç ana öğrenme paradigması:

• Gözetimli öğrenme — Etiketli veri. “Bu kedi, bu değil.” Model doğru etiketi tahmin etmeyi öğrenir.
• Gözetimsiz öğrenme — Etiketsiz veri. Model kendi başına küme ve yapı arar.
• Pekiştirmeli öğrenme — Ödül/ceza sinyali. Satranç oynayan, oyun kazanmayı öğrenen ajan bu yoldan yetişir.

Gradient Descent — Modelin Yanılgıdan Öğrenmesi

Model bir tahmin yapar, tahmin yanlışsa hata hesaplanır; hata küçültülecek şekilde model parametreleri güncellenir. Bu döngü milyonlarca kez tekrarlanır.

Görsel olarak: düz olmayan bir arazide gözleri bağlı birinin vadiye inmesi. Her adımda “hangi yöne eğim var?” sorusunu sorar, o yönde küçük bir adım atar.

kayıp = tahmin ile gerçek arasındaki fark
gradyan = bu kaybın parametrelere göre türevi
güncelleme = parametre - öğrenme_hızı × gradyan

Öğrenme hızı çok büyük olursa vadi atlanır; çok küçük olursa yüzyıllar sürer.

Overfitting — Ezbercinin Trajedisi

Model eğitim verisini çok iyi öğrenirse test verisinde berbat sonuç verir. Sınav sorularını değil, tam o soruların cevaplarını ezberleyen öğrenci gibi.

Çözümler: daha fazla veri, dropout, regularization, erken durdurma.

Sinir Ağları ve Derin Öğrenme

Sinir ağları, birden fazla katmanla hiyerarşik özellik öğrenir. İlk katmanlar kenar ve doku öğrenirken, derin katmanlar “kedi kulağı” gibi soyut kavramları öğrenir.

Derin öğrenme, çok katmanlı sinir ağlarından başka bir şey değildir — ama bu “başka bir şey değil” cümlesi, son 15 yılın bütün devrimini küçümsemek olur.

Transformer Mimarisi ve Büyük Dil Modelleri

2017’de yayımlanan “Attention Is All You Need” makalesi mimarisi değiştirdi. Transformer, metindeki her kelimenin diğer tüm kelimelerle ilişkisini paralel hesaplar — sıra takip etmez, bağlamı bir bütün olarak kavrar.

Büyük Dil Modelleri (LLM), bu mimari üstüne trilyonlarca kelimeyle eğitilir. Sonuç: “bir sonraki kelimeyi tahmin et” gibi basit bir görevden, kod yazan, şiir kuran, argüman üreten sistemler çıkar.

Bir LLM’in “anlayıp anlamadığı” sorusu hâlâ açıktır. Ama bu soruyu sormak zorunda hissettiriyorsa, o da küçük bir mucizedir.

Prompt Mühendisliği

LLM’lere verilen giriş metnine prompt denir. İyi bir prompt, modeli doğru çıktıya yönlendiren bir kaldıraçtır.

Temel teknikler:

• Zero-shot — Hiç örnek vermeden doğrudan sormak.
• Few-shot — 2–3 örnek gösterip aynı formatı istemek.
• Chain-of-thought — “Adım adım düşün” diyerek mantık zinciri kurmak.
• Role prompting — “Sen bir uzman fizikçisin” diyerek bağlam vermek.

Kısa Sözlük

Bir Adım Geri

Yapay zeka bir araçtır — çekiç kadar tarafsız, kullanıcısı kadar niyetli. Ondan korkmak ne kadar anlamsızsa, ona körce güvenmek de o kadar tehlikelidir. En sağlıklı yaklaşım şu olabilir: nasıl çalıştığını yeterince anlamak ki ne yapamayacağını da bilesin.

Satranç tahtasında her taşın değerini bilmek oyunu kazandırmaz — ama bilmemek kesinlikle kaybettirir.

Kaynak: Bu yazı; Deep Learning (Goodfellow vd.), Attention Is All You Need (Vaswani vd., 2017) ve çeşitli birincil araştırma makalelerinden derlenerek özgün olarak yazılmıştır.

Pratik sıralama: SELECT → FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT hesapları → ORDER BY → LIMIT. SQL yazarken bu mantıksal akışı akılda tutmak hata sayısını ciddi azaltır.

Bölüm 1 — Temel ve Orta Seviye Konular

1. SELECT

Ne işe yarar? Tablodan hangi kolonları okuyacağını seçersin.

Ne zaman kullanılır? Raporlama, kontrol ve analiz sorgularının başlangıcıdır.

SELECT ad, soyad, sehir
FROM musteriler;

SELECT * hızlı deneme için iyidir; kalıcı sorgularda ihtiyacın olan kolonları yazmak daha temizdir.

2. WHERE

Ne işe yarar? Satırları koşula göre filtreler.

Ne zaman kullanılır? Büyük tabloda doğru satırlara odaklanmanı sağlar.

SELECT *
FROM siparisler
WHERE toplam_tutar > 1000;

WHERE satır seviyesinde çalışır; GROUP BY sonrası filtreleme için HAVING kullanılır.

3. JOIN

Ne işe yarar? İlişkili tabloları ortak alan üzerinden birleştirir.

Ne zaman kullanılır? Müşteri-sipariş, ürün-kategori gibi parçalanmış veriyi anlamlı hale getirir.

SELECT m.ad, s.toplam_tutar
FROM musteriler m
JOIN siparisler s ON s.musteri_id = m.id;

JOIN koşulunu yazmayı unutmak çarpım etkisi oluşturabilir ve satır sayısını patlatır.

4. GROUP BY

Ne işe yarar? Satırları gruplar ve grup bazlı özet üretir.

Ne zaman kullanılır? Şehir bazlı müşteri sayısı, ürün bazlı satış gibi özetlerde kullanılır.

SELECT sehir, COUNT(*) AS musteri_sayisi
FROM musteriler
GROUP BY sehir;

SELECT içinde aggregate olmayan her kolon genelde GROUP BY içinde de yer almalıdır.

5. ORDER BY

Ne işe yarar? Sonuçları artan veya azalan sıralar.

Ne zaman kullanılır? En pahalı ürünler, en yeni siparişler, en çok satanlar gibi listelerde kullanılır.

SELECT ad, fiyat
FROM urunler
ORDER BY fiyat DESC;

DESC azalan, ASC artan sıralama yapar. ASC varsayılandır.

6. INDEX

Ne işe yarar? Arama ve JOIN performansını artıran veri yapısıdır.

Ne zaman kullanılır? WHERE, JOIN, ORDER BY alanlarında sık kullanılan kolonlarda faydalıdır.

CREATE INDEX idx_siparis_musteri
ON siparisler(musteri_id);

Index okumayı hızlandırır ama INSERT/UPDATE/DELETE işlemlerini biraz yavaşlatabilir.

7. PRIMARY KEY

Ne işe yarar? Tablodaki her satırı benzersiz tanımlar.

Ne zaman kullanılır? id gibi tekrar etmeyen ana kimlik alanıdır.

CREATE TABLE musteriler (
  id SERIAL PRIMARY KEY,
  ad TEXT NOT NULL
);

Primary key hem benzersizlik sağlar hem de NULL olamaz.

8. FOREIGN KEY

Ne işe yarar? Bir tablodaki alanın başka tablodaki anahtara bağlı olmasını sağlar.

Ne zaman kullanılır? Veri tutarlılığı için kullanılır; olmayan müşterinin siparişi girilemez.

CREATE TABLE siparisler (
  id SERIAL PRIMARY KEY,
  musteri_id INT REFERENCES musteriler(id)
);

Foreign key veri kalitesini korur; silme/güncelleme davranışları için ON DELETE / ON UPDATE düşünülür.

9. INSERT

Ne işe yarar? Tabloya yeni satır ekler.

Ne zaman kullanılır? Yeni müşteri, yeni sipariş, yeni log kaydı oluştururken kullanılır.

INSERT INTO musteriler(ad, sehir)
VALUES ('Ali', 'Ankara');

Kolon listesini yazmak güvenlidir; tablo yapısı değişse de sorgu daha okunur kalır.

10. UPDATE

Ne işe yarar? Var olan satırları günceller.

Ne zaman kullanılır? Adres, fiyat, durum, stok gibi değerleri değiştirmek için kullanılır.

UPDATE urunler
SET fiyat = fiyat * 1.10
WHERE kategori = 'Elektronik';

WHERE unutulursa tablodaki tüm satırlar güncellenir. Önce SELECT ile kontrol etmek iyi alışkanlıktır.

11. DELETE

Ne işe yarar? Satır siler.

Ne zaman kullanılır? Yanlış, geçersiz veya artık gerekli olmayan kayıtları kaldırır.

DELETE FROM sepet
WHERE kullanici_id = 10 AND urun_id = 5;

DELETE de WHERE ister. Kalıcı silme yerine bazı sistemlerde soft delete kullanılır.

12. HAVING

Ne işe yarar? Gruplandırılmış sonuçları filtreler.

Ne zaman kullanılır? COUNT, SUM, AVG gibi özet sonuçlar üzerinden koşul kurarsın.

SELECT musteri_id, SUM(toplam_tutar) AS toplam
FROM siparisler
GROUP BY musteri_id
HAVING SUM(toplam_tutar) > 5000;

WHERE gruplamadan önce, HAVING gruplamadan sonra çalışır.

13. SUBQUERY

Ne işe yarar? Bir sorgunun içinde başka sorgu kullanmaktır.

Ne zaman kullanılır? Önce bir liste/sonuç bulup dış sorguda kullanmak için kullanılır.

SELECT ad
FROM musteriler
WHERE id IN (
  SELECT musteri_id FROM siparisler
);

Subquery okunabilir olabilir; performans için bazen JOIN veya EXISTS daha iyi olur.

14. DISTINCT

Ne işe yarar? Tekrar eden değerleri teke indirir.

Ne zaman kullanılır? Tekil şehirler, tekil kategoriler, tekrar etmeyen kullanıcı listeleri için kullanılır.

SELECT DISTINCT sehir
FROM musteriler;

DISTINCT tüm seçilen kolon kombinasyonuna bakar; sadece tek kolona değil.

15. LIMIT

Ne işe yarar? Döndürülecek satır sayısını sınırlar.

Ne zaman kullanılır? Deneme, sayfalama ve ilk N sonucu görmek için kullanılır.

SELECT *
FROM siparisler
ORDER BY created_at DESC
LIMIT 10;

LIMIT genelde ORDER BY ile birlikte anlamlıdır; aksi halde hangi 10 satırın geleceği belirsiz olabilir.

16. UNION

Ne işe yarar? İki sorgu sonucunu alt alta birleştirir.

Ne zaman kullanılır? Benzer kolon yapısına sahip listeleri tek sonuç setinde toplar.

SELECT email FROM musteriler
UNION
SELECT email FROM tedarikciler;

UNION tekrarlı satırları kaldırır. Hepsini korumak için UNION ALL kullanılır.

17. CASE

Ne işe yarar? SQL içinde if-else benzeri koşullu ifade yazar.

Ne zaman kullanılır? Raporlarda sınıflandırma ve etiketleme için çok kullanılır.

SELECT ad,
  CASE
    WHEN toplam_harcama >= 10000 THEN 'VIP'
    ELSE 'Standart'
  END AS musteri_tipi
FROM musteriler;

CASE kolon üretir; WHERE, SELECT, ORDER BY içinde kullanılabilir.

18. VIEW

Ne işe yarar? Kaydedilmiş sorgu gibi davranan sanal tablodur.

Ne zaman kullanılır? Karmaşık sorguları basitleştirmek ve raporları standartlaştırmak için kullanılır.

CREATE VIEW aktif_musteriler AS
SELECT * FROM musteriler
WHERE aktif = TRUE;

View veri kopyalamaz; sorgulandığında alttaki tablolardan okur.

19. TRIGGER

Ne işe yarar? Tabloda olay olunca otomatik çalışan mekanizmadır.

Ne zaman kullanılır? Log tutma, denetim, otomatik alan güncelleme gibi işlerde kullanılır.

-- PostgreSQL'de önce function, sonra trigger yazılır
CREATE TRIGGER trg_log
AFTER INSERT ON siparisler
FOR EACH ROW EXECUTE FUNCTION log_siparis();

Trigger güçlüdür ama gizli iş mantığı yaratabilir; dikkatli ve dökümante kullanılmalıdır.

20. TRANSACTION

Ne işe yarar? Birden fazla işlemi tek bir bütün olarak çalıştırır.

Ne zaman kullanılır? Para transferi gibi yarım kalmaması gereken işlemlerde kullanılır.

BEGIN;
UPDATE hesaplar SET bakiye = bakiye - 100 WHERE id = 1;
UPDATE hesaplar SET bakiye = bakiye + 100 WHERE id = 2;
COMMIT;

Hata olursa ROLLBACK ile tüm işlemleri geri alırsın.

21. INNER JOIN

Ne işe yarar? Sadece iki tabloda da eşleşen satırları getirir.

Ne zaman kullanılır? Siparişi olan müşterileri görmek gibi eşleşme şart olan raporlarda kullanılır.

SELECT m.ad, s.id
FROM musteriler m
INNER JOIN siparisler s ON s.musteri_id = m.id;

JOIN yazdığında çoğu veritabanında varsayılan INNER JOIN‘dir.

22. LEFT JOIN

Ne işe yarar? Sol tablodaki tüm satırları, sağdan eşleşenleri getirir.

Ne zaman kullanılır? Siparişi olmayan müşterileri de görmek istediğinde kullanılır.

SELECT m.ad, s.id AS siparis_id
FROM musteriler m
LEFT JOIN siparisler s ON s.musteri_id = m.id;

Sağ tarafta eşleşme yoksa kolonlar NULL gelir.

23. RIGHT JOIN

Ne işe yarar? Sağ tablodaki tüm satırları, soldan eşleşenleri getirir.

Ne zaman kullanılır? LEFT JOIN‘in ters yönlüsüdür.

SELECT m.ad, s.id
FROM musteriler m
RIGHT JOIN siparisler s ON s.musteri_id = m.id;

Okunabilirlik için çoğu ekip RIGHT JOIN yerine tablo sıralamasını değiştirip LEFT JOIN kullanır.

24. FULL OUTER JOIN

Ne işe yarar? İki tablodaki tüm satırları getirir; eşleşenleri yan yana koyar.

Ne zaman kullanılır? İki kaynağı karşılaştırma ve eksik eşleşmeleri bulma işlerinde kullanılır.

SELECT a.id, b.id
FROM kaynak_a a
FULL OUTER JOIN kaynak_b b ON b.id = a.id;

Her veritabanında desteklenmeyebilir; MySQL’de alternatif çözüm gerekir.

25. COUNT

Ne işe yarar? Satır veya değer sayar.

Ne zaman kullanılır? Raporların en temel aggregate fonksiyonudur.

SELECT COUNT(*) AS toplam_siparis
FROM siparisler;

COUNT(*) satır sayar; COUNT(kolon) NULL olmayan değerleri sayar.

26. SUM

Ne işe yarar? Sayısal değerleri toplar.

Ne zaman kullanılır? Ciro, toplam stok, toplam ödeme gibi hesaplarda kullanılır.

SELECT SUM(toplam_tutar) AS ciro
FROM siparisler
WHERE durum = 'tamamlandi';

NULL değerler toplama dahil edilmez; gerekirse COALESCE kullanılır.

27. AVG

Ne işe yarar? Ortalama hesaplar.

Ne zaman kullanılır? Ortalama sepet tutarı, ortalama yaş, ortalama puan gibi raporlarda kullanılır.

SELECT AVG(toplam_tutar) AS ortalama_sepet
FROM siparisler;

AVG NULL değerleri yok sayar.

28. MIN / MAX

Ne işe yarar? En küçük ve en büyük değeri bulur.

Ne zaman kullanılır? En erken tarih, en son sipariş, en ucuz ürün gibi sorgularda kullanılır.

SELECT MIN(fiyat) AS en_ucuz, MAX(fiyat) AS en_pahali
FROM urunler;

Tarihlerde MIN en eskiyi, MAX en yeni tarihi verir.

29. BETWEEN

Ne işe yarar? İki sınır arasını filtreler.

Ne zaman kullanılır? Tarih, fiyat, yaş aralıklarında pratik kullanılır.

SELECT *
FROM siparisler
WHERE toplam_tutar BETWEEN 100 AND 500;

BETWEEN iki sınırı da dahil eder.

30. IN

Ne işe yarar? Bir kolonun verilen listede olup olmadığını kontrol eder.

Ne zaman kullanılır? Birden fazla eşitlik koşulunu temiz yazmak için kullanılır.

SELECT *
FROM musteriler
WHERE sehir IN ('Ankara', 'Istanbul', 'Izmir');

IN listesi subquery ile de doldurulabilir.

31. LIKE

Ne işe yarar? Metin desenine göre arama yapar.

Ne zaman kullanılır? İsim, email, açıklama gibi alanlarda basit arama yapar.

SELECT *
FROM musteriler
WHERE ad LIKE 'A%';

% herhangi uzunlukta karakter, _ tek karakter anlamına gelir.

32. IS NULL

Ne işe yarar? NULL değeri kontrol eder.

Ne zaman kullanılır? Eksik telefon, atanmış olmayan teslimat tarihi gibi kayıtları bulur.

SELECT *
FROM musteriler
WHERE telefon IS NULL;

NULL = NULL yazılmaz; IS NULL veya IS NOT NULL kullanılır.

33. EXISTS

Ne işe yarar? Alt sorguda en az bir satır var mı diye bakar.

Ne zaman kullanılır? İlişkili kaydın varlığını kontrol etmek için güçlüdür.

SELECT m.ad
FROM musteriler m
WHERE EXISTS (
  SELECT 1 FROM siparisler s WHERE s.musteri_id = m.id
);

EXISTS genelde varlık kontrolünde IN‘e göre daha niyet belirgin ve performanslı olabilir.

34. ALTER TABLE

Ne işe yarar? Tablo yapısını değiştirir.

Ne zaman kullanılır? Kolon ekleme, kolon tipi değiştirme, constraint ekleme gibi işlerde kullanılır.

ALTER TABLE musteriler
ADD COLUMN dogum_tarihi DATE;

Canlı sistemde ALTER TABLE dikkat ister; büyük tabloda kilit ve süre sorunu yaratabilir.

35. DROP TABLE

Ne işe yarar? Tabloyu tamamen siler.

Ne zaman kullanılır? Test tablosunu kaldırmak veya eski yapıları temizlemek için kullanılır.

DROP TABLE eski_raporlar;

DROP geri dönüşü zor bir işlemdir. Üretimde mutlaka yedek ve yetki kontrolü gerekir.

36. CREATE TABLE

Ne işe yarar? Yeni tablo oluşturur.

Ne zaman kullanılır? Veriyi düzenli saklamak için kolonlar ve veri tipleri belirlenir.

CREATE TABLE urunler (
  id SERIAL PRIMARY KEY,
  ad TEXT NOT NULL,
  fiyat NUMERIC(10,2)
);

Tablo tasarımı sonradan tüm sorgu kalitesini etkiler.

37. DEFAULT

Ne işe yarar? Kolon için varsayılan değer tanımlar.

Ne zaman kullanılır? Kayıt eklerken belirtilmeyen alanlara otomatik değer vermek için kullanılır.

CREATE TABLE kullanicilar (
  id SERIAL PRIMARY KEY,
  aktif BOOLEAN DEFAULT TRUE
);

created_at için DEFAULT now() çok yaygın kullanılır.

38. UNIQUE

Ne işe yarar? Aynı değerin tekrar girmesini engeller.

Ne zaman kullanılır? Email, kullanıcı adı, fatura no gibi tekil olması gereken alanlarda kullanılır.

CREATE TABLE kullanicilar (
  id SERIAL PRIMARY KEY,
  email TEXT UNIQUE
);

UNIQUE constraint veri kalitesini uygulama koduna bırakmadan veritabanında korur.

39. CHECK

Ne işe yarar? Kolona veya satıra kural koyar.

Ne zaman kullanılır? Negatif fiyat, geçersiz yaş gibi hatalı verileri engeller.

CREATE TABLE urunler (
  fiyat NUMERIC CHECK (fiyat >= 0)
);

CHECK, veri kurallarını merkezi ve güvenli hale getirir.

40. SERIAL / AUTO INCREMENT

Ne işe yarar? Otomatik artan id üretir.

Ne zaman kullanılır? Her kayda benzersiz sayısal kimlik vermek için kullanılır.

CREATE TABLE musteriler (
  id SERIAL PRIMARY KEY,
  ad TEXT NOT NULL
);

PostgreSQL’de modern alternatif GENERATED AS IDENTITY yapısıdır.

Bölüm 2 — Orta-İleri ve İleri SQL Konuları

41. CTE — WITH

Ne işe yarar? Sorgu içinde geçici isimlendirilmiş sonuç oluşturur.

Ne zaman kullanılır? Karmaşık sorguları adım adım okunur hale getirir.

WITH aylik_satis AS (
  SELECT date_trunc('month', created_at) AS ay, SUM(toplam_tutar) AS ciro
  FROM siparisler
  GROUP BY 1
)
SELECT * FROM aylik_satis
ORDER BY ay;

CTE, sorguyu bölümlere ayırmak için harikadır. Bazı veritabanlarında optimizasyon davranışı değişebilir.

42. Recursive CTE

Ne işe yarar? Kendi sonucuna tekrar başvuran CTE’dir.

Ne zaman kullanılır? Kategori ağacı, organizasyon şeması, graph benzeri hiyerarşilerde kullanılır.

WITH RECURSIVE kategori_agaci AS (
  SELECT id, parent_id, ad, 1 AS seviye
  FROM kategoriler WHERE parent_id IS NULL
  UNION ALL
  SELECT k.id, k.parent_id, k.ad, ka.seviye + 1
  FROM kategoriler k
  JOIN kategori_agaci ka ON k.parent_id = ka.id
)
SELECT * FROM kategori_agaci;

Recursive sorgularda sonsuz döngü riskine karşı seviye sınırı veya veri kontrolü düşünülmelidir.

43. Window Functions

Ne işe yarar? Satırları kaybetmeden grup bazlı hesap yapar.

Ne zaman kullanılır? Sıralama, küme içinde toplam, hareketli ortalama gibi analizlerde kullanılır.

SELECT musteri_id, created_at, toplam_tutar,
  SUM(toplam_tutar) OVER (PARTITION BY musteri_id ORDER BY created_at) AS kume_toplam
FROM siparisler;

GROUP BY satırları özetler; window function satırları korur.

44. ROW_NUMBER

Ne işe yarar? Her grup içinde sıralı numara verir.

Ne zaman kullanılır? Her müşterinin en son siparişini bulmak gibi işlerde kullanılır.

WITH sirali AS (
  SELECT *, ROW_NUMBER() OVER (PARTITION BY musteri_id ORDER BY created_at DESC) AS rn
  FROM siparisler
)
SELECT * FROM sirali WHERE rn = 1;

Aynı sıralama değerlerinde sonuç deterministik olsun diye ORDER BY‘a ikinci kolon eklenebilir.

45. RANK / DENSE_RANK

Ne işe yarar? Eşitlik durumunu dikkate alan sıralama fonksiyonlarıdır.

Ne zaman kullanılır? Puan tablosu, satış liderleri gibi listelerde kullanılır.

SELECT urun_id, toplam_satis,
  RANK() OVER (ORDER BY toplam_satis DESC) AS sira
FROM urun_satis_ozet;

RANK eşitlikte boşluk bırakır; DENSE_RANK boşluk bırakmaz.

46. LAG / LEAD

Ne işe yarar? Önceki veya sonraki satırdaki değeri okur.

Ne zaman kullanılır? Aydan aya değişim, önceki fiyatla karşılaştırma gibi analizlerde kullanılır.

SELECT ay, ciro,
  ciro - LAG(ciro) OVER (ORDER BY ay) AS onceki_aya_gore_fark
FROM aylik_ciro;

Zaman serisi analizlerinde çok kullanışlıdır.

47. COALESCE

Ne işe yarar? İlk NULL olmayan değeri döndürür.

Ne zaman kullanılır? NULL değerleri raporda anlamlı varsayılanlarla göstermek için kullanılır.

SELECT ad, COALESCE(telefon, 'Telefon yok') AS telefon
FROM musteriler;

COALESCE SQL’in en pratik NULL yönetimi araçlarından biridir.

48. NULLIF

Ne işe yarar? İki ifade eşitse NULL döndürür.

Ne zaman kullanılır? Sıfıra bölme hatasını önlemek gibi durumlarda kullanılır.

SELECT toplam_tutar / NULLIF(urun_adedi, 0) AS ortalama_birim_tutar
FROM siparisler;

NULLIF(a,b) → a = b ise NULL; değilse a döndürür.

49. CAST / Type Conversion

Ne işe yarar? Bir veri tipini başka tipe çevirir.

Ne zaman kullanılır? Metni sayıya, tarihi metne veya sayıyı metne çevirmek gerekebilir.

SELECT CAST('2026-05-07' AS DATE) AS tarih;

Yanlış format cast hatası üretir. Veri temizliği önemlidir.

50. Date Functions

Ne işe yarar? Tarihleri parçala, yuvarla veya aralık hesapla.

Ne zaman kullanılır? Günlük/aylık raporlama ve zaman filtreleri için kullanılır.

SELECT date_trunc('month', created_at) AS ay, COUNT(*)
FROM siparisler
GROUP BY 1
ORDER BY 1;

Tarih fonksiyonları veritabanına göre değişir; PostgreSQL, MySQL, SQL Server farklıdır.

51. String Functions

Ne işe yarar? Metinleri birleştirme, parçalama, küçültme/büyütme gibi işlemler yapar.

Ne zaman kullanılır? Arama, temizlik ve raporlama formatları için kullanılır.

SELECT LOWER(TRIM(email)) AS temiz_email
FROM kullanicilar;

Metin temizliği yaparken index kullanımı etkilenebilir; expression index gerekebilir.

52. Aggregate Filtering

Ne işe yarar? Aggregate hesaba koşullu veri dahil eder.

Ne zaman kullanılır? Aynı sorguda farklı sayım ve toplamları üretmek için kullanılır.

SELECT
  COUNT(*) AS toplam,
  COUNT(*) FILTER (WHERE durum = 'tamamlandi') AS tamamlanan
FROM siparisler;

FILTER PostgreSQL’de çok temizdir; diğer sistemlerde CASE ile yazılabilir.

53. Conditional Aggregation

Ne işe yarar? SUM/COUNT içinde CASE kullanarak koşullu özet üretir.

Ne zaman kullanılır? Pivot benzeri raporlarda ve dashboard metriklerinde çok kullanılır.

SELECT
  SUM(CASE WHEN durum = 'tamamlandi' THEN 1 ELSE 0 END) AS tamamlanan,
  SUM(CASE WHEN durum = 'iptal' THEN 1 ELSE 0 END) AS iptal
FROM siparisler;

Tek sorguda birden fazla metriği hesaplamak için çok pratiktir.

54. UNION ALL

Ne işe yarar? İki sonucu tekrar kontrolü yapmadan birleştirir.

Ne zaman kullanılır? Log, arşiv ve canlı tabloyu birlikte okumak gibi durumlarda kullanılır.

SELECT id, created_at FROM siparisler_2025
UNION ALL
SELECT id, created_at FROM siparisler_2026;

UNION ALL genelde UNION‘dan daha hızlıdır çünkü tekrar silme maliyeti yoktur.

55. INTERSECT / EXCEPT

Ne işe yarar? Kesişim ve fark işlemleri yapar.

Ne zaman kullanılır? İki liste arasında ortak veya eksik kayıtları bulmak için kullanılır.

-- Kesişim
SELECT email FROM liste_a
INTERSECT
SELECT email FROM liste_b;

-- Fark
SELECT email FROM liste_a
EXCEPT
SELECT email FROM liste_b;

Veri karşılaştırma ve mutabakat işlerinde çok kullanışlıdır.

56. UPSERT

Ne işe yarar? Kayıt varsa güncelle, yoksa ekle mantığıdır.

Ne zaman kullanılır? Tekil anahtara göre tekrarlı veri girişini yönetir.

INSERT INTO urun_stok(urun_id, adet)
VALUES (10, 5)
ON CONFLICT (urun_id)
DO UPDATE SET adet = urun_stok.adet + EXCLUDED.adet;

PostgreSQL’de ON CONFLICT kullanılır. SQL Server’da MERGE alternatif olabilir.

57. Stored Procedure

Ne işe yarar? Veritabanında saklanan işlem bloklarıdır.

Ne zaman kullanılır? Tekrarlanan iş kurallarını veritabanında çalıştırmak için kullanılır.

CALL siparis_kapat(123);

Procedure kullanımı ekip ve mimariye bağlıdır. Aşırı iş mantığı veritabanını karmaşıklaştırabilir.

58. User Defined Function

Ne işe yarar? Veritabanında kendi fonksiyonunu tanımlarsın.

Ne zaman kullanılır? Tekrar eden hesaplamaları merkezi hale getirir.

CREATE FUNCTION kdvli_fiyat(fiyat NUMERIC)
RETURNS NUMERIC AS $$
  SELECT fiyat * 1.20;
$$ LANGUAGE SQL;

Fonksiyonlar okunabilirlik sağlar; ama performans ve yan etki konularına dikkat edilir.

59. Materialized View

Ne işe yarar? View sonucunu fiziksel olarak saklar.

Ne zaman kullanılır? Ağır raporları hızlandırmak için kullanılır.

CREATE MATERIALIZED VIEW aylik_ciro AS
SELECT date_trunc('month', created_at) AS ay, SUM(toplam_tutar) AS ciro
FROM siparisler
GROUP BY 1;

REFRESH MATERIALIZED VIEW aylik_ciro;

Normal view her okumada hesaplar; materialized view saklar ama güncelleme ister.

60. Normalization

Ne işe yarar? Veriyi tekrar azaltacak şekilde tablolara ayırma prensibidir.

Ne zaman kullanılır? Müşteri, sipariş, ürün gibi varlıkları doğru modellemek için kullanılır.

-- Müşteri bilgisi sipariş tablosunda tekrar tekrar tutulmaz
-- siparisler.musteri_id -> musteriler.id

Aşırı normalizasyon sorguları zorlaştırabilir; raporlama için bazen denormalizasyon kullanılır.

61. Denormalization

Ne işe yarar? Performans veya raporlama için bazı verileri bilinçli tekrar tutmaktır.

Ne zaman kullanılır? Dashboard, analitik tablo, cache tablo gibi yerlerde kullanılır.

-- siparis_ozet tablosunda musteri_adi ve toplam_tutar hazır tutulabilir

Tutarlılık riski vardır; verinin nasıl güncelleneceği net olmalıdır.

62. Query Optimization

Ne işe yarar? Sorguyu daha hızlı ve az maliyetli çalışacak hale getirmektir.

Ne zaman kullanılır? Yavaş raporlar, ağır JOIN‘ler, büyük tablolarla çalışırken gerekir.

EXPLAIN ANALYZE
SELECT * FROM siparisler WHERE musteri_id = 10;

Optimizasyon tahminle değil ölçümle yapılır. EXPLAIN ana araçtır.

63. Execution Plan — EXPLAIN

Ne işe yarar? Veritabanının sorguyu nasıl çalıştıracağını gösterir.

Ne zaman kullanılır? Index kullanıldı mı, full scan mı yapıldı, JOIN sırası ne gibi sorulara cevap verir.

EXPLAIN ANALYZE
SELECT *
FROM siparisler
WHERE created_at >= CURRENT_DATE - INTERVAL '30 days';

ANALYZE sorguyu gerçekten çalıştırır; üretimde dikkatli kullanılır.

64. Partitioning

Ne işe yarar? Büyük tabloyu mantıksal/fiziksel parçalara ayırır.

Ne zaman kullanılır? Yıllık/aylık log veya sipariş tablolarında performans ve bakım kolaylığı sağlar.

CREATE TABLE siparisler (
  id BIGINT,
  created_at DATE NOT NULL
) PARTITION BY RANGE (created_at);

Doğru partition anahtarı seçilmezse faydası azalır.

65. ACID

Ne işe yarar? Transaction güvenilirliğinin dört temel ilkesidir.

Ne zaman kullanılır? Finans, stok, sipariş gibi tutarlılık gereken sistemlerde kritiktir.

Atomicity  : Ya hepsi olur ya hiçbiri
Consistency: Kurallar bozulmaz
Isolation  : İşlemler birbirini bozmaz
Durability : Commit edilen veri kalıcıdır

ACID mantığını bilmek transaction, lock ve hata yönetimini anlamayı kolaylaştırır.

66. Isolation Levels

Ne işe yarar? Aynı anda çalışan transaction’ların birbirini nasıl göreceğini belirler.

Ne zaman kullanılır? Dirty read, non-repeatable read, phantom read gibi problemleri kontrol eder.

SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN;
-- islemler
COMMIT;

Yüksek izolasyon daha fazla güvenlik ama daha fazla kilit/performans maliyeti getirebilir.

67. Locks

Ne işe yarar? Veriye aynı anda erişimde tutarlılık için kilit mekanizmasıdır.

Ne zaman kullanılır? Aynı kaydı iki kişi güncellerken çarpışmayı önler.

SELECT *
FROM hesaplar
WHERE id = 1
FOR UPDATE;

Kilitler doğaldır; uzun transaction deadlock ve bekleme sorunu yaratabilir.

68. Deadlock

Ne işe yarar? İki transaction birbirinin kilidini bekleyince oluşur.

Ne zaman kullanılır? Yoğun güncelleme yapan sistemlerde karşına çıkabilir.

-- Çözüm prensibi:
-- Kayıtları her transaction'da aynı sırayla kilitle.

Deadlock tamamen yok edilemeyebilir; uygulama retry mantığı içermelidir.

69. JSON SQL

Ne işe yarar? JSON alanları içindeki veriyi sorgular.

Ne zaman kullanılır? Esnek şemalı ek bilgiler, event payload’ları, API cevapları için kullanılır.

SELECT data->>'email' AS email
FROM events
WHERE data->>'type' = 'signup';

JSON esneklik sağlar ama her şeyi JSON yapmak relational gücü azaltır.

70. Full Text Search

Ne işe yarar? Metin içinde kelime bazlı etkili arama yapar.

Ne zaman kullanılır? Makale, ürün açıklaması, destek kaydı gibi alanlarda kullanılır.

SELECT *
FROM makaleler
WHERE to_tsvector('simple', baslik || ' ' || icerik) @@ plainto_tsquery('sql');

LIKE '%kelime%' basit arama için yeterli olabilir; ciddi arama için full text search düşünülür.

Mini Cheat Sheet

Çalışma önerisi: Her konu için önce örneği çalıştır, sonra tablo ve kolon adlarını kendi verine göre değiştir. En hızlı öğrenme yolu, aynı kavramı farklı senaryolarda tekrar yazmaktır.

Motivasyon örneği: $n$ çalışanı olan bir ofiste her çalışanın giriş ve çıkış saatleri bilinmektedir. Herhangi bir anda ofiste bulunan en fazla çalışan sayısını bul.

Her çalışan iki olay üretir: giriş (+1) ve çıkış (−1). Olaylar zamana göre sıralanır ve bir sayaç tutulur: ``

Olaylar soldan sağa işlendiğinde sayaç değerleri:

\(+\ +\quad +\quad -\ -\ +\ -\ -\) \(1\ \ 2\quad 3\quad 2\ \ 1\ \ 2\ \ 1\ \ 0\)

Maksimum değer 3 olup John’un gelişi ile Maria’nın çıkışı arasındaki aralıktır.

Karmaşıklık: Olayları sıralamak $O(n \log n)$, tarama $O(n)$ → toplam $O(n \log n)$.

30.1 Kesişim Noktaları

$n$ yatay veya dikey çizginin toplam kesişim noktası sayısını bul.

Kaba kuvvetle tüm çift çiftler $O(n^2)$’de incelenebilir. Çizgi süpürme + aralık sorgu veri yapısıyla bu $O(n \log n)$‘e iner.

Olay Türleri

Her çizgi en fazla iki olay üretir:

Algoritmanın İşleyişi

Olaylar $x$ koordinatına göre soldan sağa sıralanır. Aktif yatay çizgilerin $y$ koordinatları sıralı bir veri yapısında (ikili indeksli ağaç veya segment ağacı) tutulur.

Dikey çizgi geldiğinde:
  → [y1, y2] aralığındaki aktif y koordinatlarını say
  → Bu sayıyı toplam kesişim sayısına ekle

İndis sıkıştırması: $y$ koordinatları $[0, m]$ aralığına eşlenerek segment ağacı verimli kullanılır.

Her olayı işlemek $O(\log n)$ → toplam $O(n \log n)$.

Görsel örnek:

      |          |
------+----------+------   ← yatay çizgi 1
      |          |
      |    ------+------   ← yatay çizgi 2
      |          |
  dikey 1    dikey 2

• Dikey 1 geldiğinde aktif kümede yatay çizgi 1 var → 1 kesişim
• Dikey 2 geldiğinde aktif kümede yatay çizgi 1 ve 2 var → 2 kesişim
• Toplam: 3 kesişim ✓

30.2 En Yakın Çift Problemi

$n$ nokta arasında Öklid uzaklığı en küçük olan iki noktayı bul.

Kaba kuvvetle tüm çiftler $O(n^2)$’de incelenebilir. Çizgi süpürme ile $O(n \log n)$ mümkündür (böl ve yönet yöntemi de aynı karmaşıklığı verir).

Algoritma

Değişkenler:

• Noktalar $x$ koordinatına göre soldan sağa sıralanır.
• $d$: şu ana kadar bulunan minimum mesafe.
• Aktif küme: $x$ koordinatı $[x - d, x]$ aralığında olan noktalar (y’ye göre sıralı tutulur).

Her yeni $p = (x, y)$ noktası için:

1. Aktif kümeden $x$ koordinatı $x - d$’den küçük olanları çıkar.
2. Aktif kümede $y$ koordinatı $[y - d,\ y + d]$ aralığındaki noktaları tara; hepsine uzaklığı hesapla.
3. $d$ güncellendi mi? Güncellendiyse aktif küme yeniden ayarlanır.
4. $p$’yi aktif kümeye ekle.

Neden Verimli?

Kilit gözlem: Taranan $d \times 2d$’lik dikdörtgen bölge her zaman $O(1)$ nokta içerir.

     2d
   ┌────────────┐
 d │            │
   │    p →     │
 d │            │
   └────────────┘
       ← d →

Bu bölgede $d$ eşiği nedeniyle noktalar birbirinden en az $d$ uzaklıktadır; dolayısıyla $2d \times d$’lik alana sığabilecek maksimum nokta sayısı sabittir (yaklaşık 6–8).

Noktalar $y$’ye göre sıralı kümede tutulduğundan $[y-d, y+d]$ aralığı $O(\log n)$’de sorgulanır.

Toplam karmaşıklık: $n$ nokta × $O(\log n)$ sorgu = $O(n \log n)$

C++ İskeleti

set<pair<long long,long long>> active; // {y, x} sıralı küme
sort(points.begin(), points.end());    // x'e göre sırala
long long d = INF;
int left = 0;

for (auto [x, y] : points) {
    // Sola çok uzaklaşanları çıkar
    while (points[left].x < x - d) {
        active.erase({points[left].y, points[left].x});
        left++;
    }
    // [y-d, y+d] aralığını tara
    for (auto it  = active.lower_bound({y - d, LLONG_MIN});
              it != active.end() && it->first <= y + d; ++it) {
        d = min(d, dist({x, y}, {it->second, it->first}));
    }
    active.insert({y, x});
}

30.3 Convex Hull

Convex hull (dışbükey zarf), bir nokta kümesindeki tüm noktaları kapsayan en küçük dışbükey çokgendir. Dışbükeylik: çokgendeki herhangi iki nokta arasındaki doğru parçası tamamen çokgenin içinde kalır.

Andrew’in Algoritması $O(n \log n)$’de convex hull oluşturur.

Fikir: İki Yarı

Convex hull üst hull ve alt hull olmak üzere iki parçaya ayrılır. Her iki parça da benzer şekilde hesaplanır; burada yalnızca üst hull ele alınır.

Algoritma Adımları

1. Noktaları önce $x$’e göre, eşit $x$’lerde $y$’ye göre sırala.
2. Sıralı noktalardan geçerek her noktayı hull’a ekle.
3. Her eklemede son üç nokta sola mı dönüyor? Kontrol et:
   • Sola dönüş varsa → ortadaki noktayı hull’dan sil (dışbükey değil).
   • Ta ki sola dönüş kalmayana dek tekrarla.

Yön kontrolü: Vektörel çarpımla yapılır. $A$, $B$, $C$ üç noktasında:

Adım Adım Görselleştirme

Başlangıç noktaları (x'e göre sıralı):
  1   2   3   4   5   6   7
  ·   ·   ·   ·   ·   ·   ·

Üst hull oluşturma (sola dönen noktalar elenir):
  Adım 1: [1]
  Adım 2: [1, 2]
  Adım 3: [1, 2, 3]  → 2 sola dönüş yaratıyor mu? Evet → sil
           [1, 3]
  Adım 4: [1, 3, 4]  → kontrol et...
  ...
  Son: [1, 5, 7]  (üst hull)

Karmaşıklık

C++ Kodu (Üst Hull)

// Noktalar x'e göre sıralanmış varsayılır
vector<P> upper_hull(vector<P>& pts) {
    vector<P> h;
    for (auto p : pts) {
        // Son iki nokta ile p sola dönüyor mu?
        while (h.size() >= 2) {
            P a = h[h.size()-2], b = h[h.size()-1];
            // Vektörel çarpım: (b-a) × (p-a)
            if ((conj(b-a) * (p-a)).Y <= 0)
                h.pop_back();  // sola dönüş yok → sil
            else break;
        }
        h.push_back(p);
    }
    return h;
}

Alt hull için noktaları ters sırada işle; iki hull birleştirilince tam convex hull elde edilir.

Özet Tablo

Tüm problemlerde ortak yapı aynıdır: olayları sırala, veri yapısıyla tara.

Kaynak: Rekabetçi Programcı (Competitive Programmer’s Handbook — Antti Laaksonen), Bölüm 30.

Örnek: Bir dörtgenin alanı, köşeleri $s = (a+b+c)/2$ olmak üzere Heron Formülü ile iki üçgene bölerek hesaplanabilir; ama hangi köşegen seçileceği özel durumlar doğurur. Bunun yerine doğrudan genel formül:

Bu formülün avantajı hiç özel durum içermemesi ve tüm çokgenlere genellenebilmesidir. ``

29.1 Karmaşık Sayılar

Bir karmaşık sayı $x + yi$ formundadır ($i = \sqrt{-1}$). Geometrik olarak $(x, y)$ noktasına ya da orijinden o noktaya uzanan vektöre karşılık gelir.

C++’ta complex sınıfı geometri problemlerini çözmek için güçlü bir araçtır:

typedef long long C;
typedef complex<C> P;
#define X real()
#define Y imag()

P p = {4, 2};
cout << p.X << " " << p.Y << "\n"; // 4 2

P v = {3, 1}, u = {2, 2};
P s = v + u;
cout << s.X << " " << s.Y << "\n"; // 5 3

Koordinat tipi seçimi:

• long long → tam sayı koordinatlar; hesaplamalar kesintir, tercih edilir.

• long double → reel koordinatlar; kayan nokta hatalarına dikkat! Eşitlik kontrolü için $

  a - b

  < \varepsilon$ kullanılır ($\varepsilon = 10^{-9}$ gibi).

Hazır Fonksiyonlar

Döndürme: Bir vektörü $a$ radyan saat yönünün tersine döndürmek için $\text{polar}(1, a)$ ile çarpmak yeterlidir:

P v = {4, 2};
cout << arg(v) << "\n";   // 0.463648
v *= polar(1.0, 0.5);
cout << arg(v) << "\n";   // 0.963648

29.2 Noktalar ve Çizgiler

Vektörel Çarpım (Cross Product)

$a = (x_1, y_1)$ ve $b = (x_2, y_2)$ vektörlerinin vektörel çarpımı:

Bu değer, $a$’dan sonra $b$’nin hangi yöne döndüğünü söyler:

C++ ile complex sınıfı kullanarak hesaplama:

P a = {4, 2};
P b = {1, 2};
C cross = (conj(a) * b).Y; // 4*2 - 1*2 = 6

conj(a) → $(x_1, -y_1)$; bununla $b = (x_2, y_2)$ çarpılınca sonucun $Y$ bileşeni $x_1 y_2 - x_2 y_1$ verir.

Nokta Lokasyonu

$s_1$ ve $s_2$ noktalarından geçen doğruya göre $p$ noktasının konumu:

• Pozitif → $p$ çizginin sol tarafındadır
• Negatif → $p$ çizginin sağ tarafındadır
• Sıfır → $p$ çizgi üzerindedir

Çizgi Kesişimi

$ab$ ve $cd$ parçalarının kesişip kesişmediğini kontrol etmek için üç durum vardır:

1. Durum — Aynı doğru üzerinde: Vektörel çarpım ile tüm noktaların aynı doğruda olduğu kontrol edilir; ardından çakışma sıra karşılaştırmasıyla belirlenir.

2. Durum — Ortak köşe noktası: Sadece 4 olasılık: $a=c$, $a=d$, $b=c$ veya $b=d$.

3. Durum — İç kesişim: $c$ ve $d$ noktaları, $a$’dan $b$’ye çizilen doğrunun farklı taraflarındaysa parçalar kesişir. Vektörel çarpımın işaretleri kontrol edilir.

Çizgiye Nokta Mesafesi

$s_1$ ve $s_2$’den geçen doğruya $p$ noktasının en kısa mesafesi:

Kanıt: $s_1$, $s_2$, $p$ köşeli üçgenin alanı iki şekilde yazılabilir:

• $\frac{1}{2}

  s_2 - s_1

  \cdot d$

• $\frac{1}{2}

  (s_1 - p) \times (s_2 - p)

  $

Bunlar eşitlenerek $d$ elde edilir.

Çokgen İçinde Nokta

Bir $p$ noktasının çokgenin içinde mi dışında mı olduğunu bulmak için ışın atma yöntemi kullanılır:

1. $p$’den rastgele bir yöne ışın gönder.
2. Işının çokgenin kenarlarıyla kaç kez kesiştiğini say.
3. Tekse → içeride; çiftse → dışarıda.

b (dışarıda) → ışın 0 veya 2 kez kesişir
a (içeride)  → ışın 1 veya 3 kez kesişir

29.3 Çokgen Alanı

Ayakkabı Bağı Formülü (Shoelace Formula)

Köşeleri sırasıyla $p_1 = (x_1, y_1), p_2 = (x_2, y_2), \ldots, p_n = (x_n, y_n)$ olan bir çokgenin alanı:

($p_1 = p_n$ yani ilk ve son köşe aynıdır.)

Örnek: Köşeleri $(2,4), (5,5), (7,3), (4,1), (4,3)$ olan çokgen için:

Formülün fikri: Her kenar için $y = 0$ çizgisine uzanan bir yamuk düşünülür. Yamuğun işaretli alanı:

Tüm yamuklardan bu alanlar toplandığında eşdeğer formül elde edilir. Mutlak değer alınmasının nedeni: toplam, köşelerin dolaşım yönüne göre (saat/saat tersi) pozitif ya da negatif olabilir.

Pick’in Teoremi

Tüm köşeleri tamsayı koordinatlarda olan bir çokgenin alanı:

• $a$: Çokgenin içindeki tamsayı nokta sayısı
• $b$: Çokgenin sınırındaki tamsayı nokta sayısı

Örnek: Önceki çokgen için $a = 6$, $b = 7$:

Pick Teoremi, ayakkabı bağı formülünün tamsayı koordinatlardaki özel halidir ve ikisi her zaman aynı sonucu verir.

29.4 Uzaklık Fonksiyonları

Öklid ve Manhattan Uzaklığı

İki nokta $(x_1, y_1)$ ve $(x_2, y_2)$ arasında:

Örnek: $(2, 1)$ ve $(5, 2)$ noktaları için:

Geometrik yorum: Öklid uzaklığındaki “1 birim bölge” bir daire, Manhattan uzaklığında ise 45° döndürülmüş bir kare (elmas) şeklindedir.

Koordinat Döndürme ile Manhattan → Çebyşev

Bazı problemler Manhattan uzaklığı ile çalışırken koordinatları 45° döndürmek işleri basitleştirir. Dönüşüm:

Bu dönüşümün temel özelliği:

Yani Manhattan uzaklığı, döndürülmüş koordinatlarda Çebyşev uzaklığına dönüşür. Bu sayede $x$ ve $y$ koordinatları birbirinden bağımsız ele alınabilir.

Örnek — Maksimum Manhattan Uzaklığı:

$n$ nokta arasındaki maksimum Manhattan uzaklığını bulmak:

1. Her $(x, y)$ noktasını $(x+y, y-x)$’e dönüştür.

2. $\max(

   x_1’ - x_2’

   ,

   y_1’ - y_2’

   )$ değerini bul.

3. Bu değer ya $x’$ koordinatlarının, ya da $y’$ koordinatlarının maksimum farkından gelir.
4. Her eksen için fark $(\max - \min)$ olarak hesaplanır → $O(n)$.

Örneğin $p_1 = (1, 0)$ ve $p_2 = (3, 3)$: Döndürülmüş koordinatlar $p_1’ = (1, -1)$, $p_2’ = (6, 0)$:

Özet Tablo

Kaynak: Rekabetçi Programcı (Competitive Programmer’s Handbook — Antti Laaksonen), Bölüm 29.

Pratikte karekök algoritmaları hem yeterince hızlı hem de uygulaması görece basittir. Temel fikir, bir diziyi $\sqrt{n}$ büyüklüğündeki bloklara ayırmaktır. ``

Temel Yapı: Blok Ayrıştırma

$n$ elemanlı bir dizi üzerinde iki işlem desteklenmek istensin:

• Güncelleme: Belirli bir pozisyondaki elemanı değiştir.
• Toplam sorgusu: $[a, b]$ aralığındaki elemanların toplamını bul.

Dizi $\sqrt{n}$ büyüklüğünde bloklara ayrılır; her blok kendi toplamını tutar.

5 | 8 | 20 | 17 ||  6 | 3 | 2 | 7 || 13 | 1 | 5 | 6 || 3 | 2 | 2 | ?
       50          ||      18        ||       25        ||       7

• Güncelleme: Elemanı değiştir, yalnızca o bloğun toplamını güncelle → $O(1)$
• Toplam sorgusu: Aralığı üç parçaya böl — sol kenardaki tek elemanlar + tam kaplanan bloklar + sağ kenardaki tek elemanlar → $O(\sqrt{n})$

Blok büyüklüğü $k$ seçilirse güncelleme $O(1)$, sorgu $O(k + n/k)$ zaman alır. $k = \sqrt{n}$ bu ikisini dengeler. Pratikte tam $\sqrt{n}$ yerine dengelemeye göre farklı $k$ değerleri kullanılabilir.

27.1 Algoritmaları Birleştirme

Karekök eşiği iki farklı algoritmayı birleştirir: küçük durumlar için biri, büyük durumlar için diğeri. Her iki algoritma da tek başına $O(n^2)$ iken birleşince $O(n\sqrt{n})$’e iner.

Durum İşleme (Case Processing)

$n$ hücreli iki boyutlu bir yapıda her hücrede bir harf var. Aynı harfe sahip, aralarındaki Manhattan mesafesi en kısa iki hücreyi bul.

İki algoritma:

1. 1. Algoritma: $c$ harfine sahip $k$ hücrenin tüm çiftlerini tara → $O(k^2)$
2. 2. Algoritma: $c$ harfine sahip tüm hücrelerden aynı anda BFS başlat → $O(n)$

Karekök birleştirmesi:

• $k \leq \sqrt{n}$ olan harfler: her hücre en fazla $\sqrt{n}$ kez karşılaştırılır → toplam $O(n\sqrt{n})$
• $k > \sqrt{n}$ olan harfler: en fazla $\sqrt{n}$ çeşit böyle harf olabilir → toplam $O(n\sqrt{n})$

Genel toplam: $O(n\sqrt{n})$

Grup İşleme (Batch Processing)

$n$ hücreli yapıda başta bir hücre siyah, geri kalanı beyaz. $n-1$ işlem yapılır: her işlemde beyaz bir hücreden en yakın siyah hücreye mesafe bulunur, ardından o hücre siyaha boyanır.

İki algoritma:

1. 1. Algoritma: Tüm siyah hücrelerden BFS yap → $O(n)$; ardından herhangi bir hücreden en yakın siyah hücreye mesafe $O(1)$’de bulunur.
2. 2. Algoritma: Siyah hücreleri listede tut; her işlemde listeden geç → $O(k)$ ($k$: liste uzunluğu)

Karekök birleştirmesi: İşlemleri $\sqrt{n}$ büyüklüğünde gruplara böl.

• Her grubun başında 1. Algoritma uygulanır → $O(n)$, toplam $O(n\sqrt{n})$
• Grup içinde 2. Algoritma kullanılır; liste $\sqrt{n}$’den büyümez (her grup başında temizlenir) → her işlem $O(\sqrt{n})$, toplam $O(n\sqrt{n})$

Genel toplam: $O(n\sqrt{n})$

27.2 Tamsayı Bölmesi

Gözlem: $n$ pozitif tamsayısı, farklı pozitif tamsayıların toplamı olarak yazılırsa bu toplam en fazla $O(\sqrt{n})$ terim içerir.

Kanıt: En fazla terim sayısı için $1 + 2 + \cdots + k = \frac{k(k+1)}{2} \leq n$ olmalı, buradan $k = O(\sqrt{n})$.

Bu gözlem bazı algoritmalarda $O(n\sqrt{n})$ sınırı elde etmek için kullanılır.

Sırt Çantası (Knapsack)

Toplamları $n$ olan tamsayı ağırlıklar verilsin; bu ağırlıklarla oluşturulabilecek tüm toplamları bul.

• Klasik DP yaklaşımı: $O(n^2)$
• Karekök iyileştirmesi: Aynı ağırlıktan en fazla $O(\sqrt{n})$ farklı değer olduğu bilindiğinden, aynı ağırlıklıları gruplar hâlinde işle. Her grup $O(n)$’de, toplam $O(n\sqrt{n})$’de çözülür.

Fikir: $n$ elemanlık bir “ulaşılabilir toplam” dizisi tutulur (1: ulaşılabilir, 0: ulaşılamaz). Grupları soldan sağa işlerken yeni ulaşılabilir değerler kaydedilir.

Yazı Oluşturma (String Construction)

$n$ uzunluğundaki $s$ yazısı ile toplam uzunluğu $m$ olan $D$ yazı kümesi verilsin. $D$’deki yazıları birleştirerek $s$’yi kaç farklı şekilde oluşturabiliriz?

DP tanımı: $\text{count}(k)$ = $s[0 \ldots k]$’yı $D$’den yazılarla oluşturma yolu sayısı.

• Trie ile: $O(n^2)$
• Hash + karekök: $D$’de en fazla $O(\sqrt{m})$ farklı yazı uzunluğu vardır. Her $\text{count}(k)$ hesaplanırken bu uzunluklar taranır; her adım $O(\sqrt{m})$, toplam $O(n\sqrt{m})$.

27.3 Mo’nun Algoritması

Mo’nun Algoritması, sabit (sorgu sırasında değişmeyen) diziler üzerindeki aralık sorgularını verimli işler. Her sorgu $[a, b]$ aralığındaki elemanlardan bir değer ister.

Dizi sabit olduğu için sorgular istenen sırada işlenebilir; Mo’nun Algoritması bu sırayı akıllıca seçerek toplam işlem sayısını minimize eder.

Temel Fikir

Algoritma bir aktif aralık $[l, r]$ tutar. Her sorgu için bu aralığın sınırları eleman ekleyerek veya çıkararak kaydırılır. Her kaydırma adımı $O(f(n))$ zaman alırsa toplam karmaşıklık:

Sıralama Stratejisi

Dizi $k = O(\sqrt{n})$ büyüklüğünde bloklara ayrılır. $[a_1, b_1]$ sorgusu $[a_2, b_2]$’den önce işlenir; eğer:

\(\lfloor a_1 / k \rfloor < \lfloor a_2 / k \rfloor \qquad\text{veya}\) \(\lfloor a_1 / k \rfloor = \lfloor a_2 / k \rfloor \text{ ve } b_1 < b_2\)

Yani: Aynı blokta olanlar sağ bitiş noktasına göre artan sırada; farklı bloklar soldan sağa işlenir.

Hareket Analizi

Bu sıralama ile:

• Sol bitiş noktası: Her blok geçişinde en fazla $O(\sqrt{n})$ hareket eder. $O(\sqrt{n})$ blok vardır → toplam $O(n\sqrt{n})$ hareket.
• Sağ bitiş noktası: Her blok içinde monoton artar, o blok bitince sıfırlanır. Her blok $O(n)$ hareket → toplam $O(n\sqrt{n})$ hareket.

Her iki bitiş noktası toplamda $O(n\sqrt{n})$ adım atar.

Örnek: Aralıkta Farklı Eleman Sayısı

Her $[a, b]$ sorgusunda aralıkta kaç farklı eleman olduğu bulunacak.

Veri yapısı: count[x] → $x$ elemanının aktif aralıkta kaç kez geçtiği.

• Eleman ekle ($x$): count[x]++; eğer count[x] == 1 oldu ise cevabı 1 artır.
• Eleman çıkar ($x$): count[x]--; eğer count[x] == 0 oldu ise cevabı 1 azalt.

Her adım $O(1)$ → toplam $O(n\sqrt{n})$.

Örnek geçiş:

4  2  5  4  2  4  3  3  4
         [3..7]
            [4..9]

Kaynak: Rekabetçi Programcı (Competitive Programmer’s Handbook — Antti Laaksonen), Bölüm 27.

26.1 Yazı Terminolojisi

$n$ uzunluğundaki $s$ yazısı sıfır tabanlı indislenir: $s[0], s[1], \ldots, s[n-1]$.

Sözlük sıralaması (lexicographical order): $x < y$ için ya $x \neq y$ ve $x$, $y$’nin ön ekidir; ya da $x[k] < y[k]$ olan ilk $k$ pozisyonu vardır.

26.2 Trie Yapısı

Trie, bir yazı kümesini tutan köklü ağaçtır. Ortak ön ekli yazılar aynı dalı paylaşır.

Örnek: ${\text{CANAL, CANDY, THE, THERE}}$ kümesi için trie:

(kök)
├── C → A → N → A → L *
│             └── D → Y *
└── T → H → E *
               └── R → E *

* o noktada bir yazının bittiğini gösterir (THE, THERE gibi iç içe yazılar için gereklidir).

İşlemler:

• $n$ uzunluğunda yazı arama: $O(n)$
• $n$ uzunluğunda yazı ekleme: $O(n)$
• Bir yazının en uzun ön eki kümede mi? → $O(n)$
• Her düğümde sayaç tutularak ön eke sahip yazı sayısı da bulunabilir

Dizi temsili:

int trie[N][A];
// N: maksimum düğüm sayısı, A: alfabe büyüklüğü
// trie[s][c]: s düğümünden c karakteriyle gidilen sonraki düğüm
// Kök düğüm: 0

26.3 Yazı Hashleme

Yazı hashleme, iki yazının aynı olup olmadığını verimli şekilde belirler: karakterleri tek tek karşılaştırmak yerine hash değerlerini karşılaştırırız.

Hash Değeri Hesaplama (Polinom Hashleme)

$n$ uzunluğundaki $s$ yazısının hash değeri:

$A$ ve $B$ önceden seçilen sabitlerdir. Örneğin ALLEY için karakter kodları $65, 76, 76, 69, 89$; $A=3$, $B=97$ ile:

Ön İşleme ile $O(1)$ Alt Dize Hashi

$h[k] = H(s[0 \ldots k])$ ve $p[k] = A^k \bmod B$ dizileri $O(n)$’de oluşturulur:

\(h[0] = s[0], \qquad h[k] = (h[k-1] \cdot A + s[k]) \bmod B\) \(p[0] = 1, \qquad p[k] = (p[k-1] \cdot A) \bmod B\)

$a > 0$ için $s[a \ldots b]$ alt dizesinin hash değeri $O(1)$’de:

Bu sayede kaba kuvvet örüntü eşleştirme $O(n^2)$’den $O(n)$’e iner.

Ek uygulama: Hashleme + ikili arama ile iki yazının sözlük sırası $O(\log n)$’de bulunur (ortak ön ek uzunluğu ikili aramayla bulunur).

Çarpışmalar ve Parametre Seçimi

Farklı iki yazının aynı hash değerini almasına çarpışma denir ve yanlış sonuç üretir.

Üç senaryo ($n = 10^5$ için çarpışma olasılıkları):

1. senaryo doğum günü paradoksudur: Tüm çiftler karşılaştırıldığında $B \approx 10^9$ ile çarpışma olasılığı yaklaşık %39’dur!

Önerilen sabitler:

A = 911382323
B = 972663749

Güvenli kullanım: İki farklı $(A, B)$ çiftiyle paralel hash — çarpışma ihtimali $\approx 10^{-18}$.

⚠️ $B = 2^{32}$ veya $B = 2^{64}$ gibi 2’nin kuvvetlerini kullanmayın; bu parametrelerle her zaman çarpışma üretebilen girdiler oluşturmak mümkündür.

26.4 Z-Algoritması

$n$ uzunluğundaki $s$ yazısının Z-dizisi $z$, her $k$ için $k$ pozisyonundan başlayan ve aynı zamanda $s$’nin ön eki olan en uzun alt dizenin uzunluğunu verir:

Örnek: ACBACDACBACBACDA için Z-dizisi:

Örneğin $z[6] = 5$ çünkü ACBAC ($= s[6 \ldots 10]$) yazının ön ekidir ama ACBACB değil.

Algoritmanın Çalışması

Z-algoritması bir $[x, y]$ aralığı tutar: $s[x \ldots y]$, $s$’nin bir ön ekidir ve $y$ mümkün olduğunca büyük tutulur.

Her $k$ pozisyonu için:

1. $z[k-x]$ değerine bakılır.
   • $k + z[k-x] < y$ ise → $z[k] = z[k-x]$ (karaktere bakmaya gerek yok).
   • $k + z[k-x] \geq y$ ise → $y$’den devam ederek karakter karakter karşılaştır.
2. Gerekirse $[x, y]$ güncellenir.

Her karakter en fazla bir kez yeni karşılaştırmaya girer → toplam süre $O(n)$.

Örüntü Bulma ile Kullanım

$p$ örüntüsünün $s$ yazısında geçtiği yerleri bulmak için:

Örnek: $s = \text{HATTIVATTI}$, $p = \text{ATT}$

1. ve 10. pozisyonlar $z = 3 =

   p

   $ → ATT, HATTIVATTI‘da 1. ve 6. indislerde geçer.

Implementasyon

vector<int> z(string s) {
    int n = s.size();
    vector<int> z(n);
    int x = 0, y = 0;
    for (int i = 1; i < n; i++) {
        z[i] = max(0, min(z[i-x], y-i+1));
        while (i+z[i] < n && s[z[i]] == s[i+z[i]]) {
            x = i; y = i+z[i]; z[i]++;
        }
    }
    return z;
}

Hashleme vs Z-Algoritması

Kaynak: Rekabetçi Programcı (Competitive Programmer’s Handbook — Antti Laaksonen), Bölüm 26.