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.

25.1 Oyun Durumları

Örnek oyun: $n$ çubukluk bir öbek var; $A$ ve $B$ oyuncuları sırayla oynar, $A$ başlar. Her hamlede oyuncu 1, 2 veya 3 çubuk çıkarır; son çubuğu çıkaran kazanır.

$n = 10$ için örnek oynanış:

• A, 2 çıkarır → 8 kaldı
• B, 3 çıkarır → 5 kaldı
• A, 1 çıkarır → 4 kaldı
• B, 2 çıkarır → 2 kaldı
• A, 2 çıkarır → A kazanır

Kazanan ve Kaybeden Durumlar

• Kazanan durum (W): Mevcut oyuncu optimal oynarsa kazanır.
• Kaybeden durum (L): Rakip optimal oynarsa mevcut oyuncu kaybeder.

Temel kural:

• Şu anki durumdan bir kaybeden duruma geçiş yapılabiliyorsa → kazanan durum
• Şu anki durumdan yalnızca kazanan durumlara geçilebiliyorsa → kaybeden durum

Başka hamle olmayan son durum her zaman kaybedendir (0 çubuk: hamle yok).

1–2–3 çubuk çıkarma oyununda 0–15 durumlarının sınıflandırması:

Kalıp: $k$ durumu, $4 \mid k$ ise kaybeden; aksi hâlde kazanandır. Optimal strateji her hamlede kalan çubuk sayısını 4’ün katı tutmaktır.

Durum Çizgesi

Daha karmaşık oyunlarda (örneğin $k$. durumda $k$’yi bölen kadar çubuk alınabilir) durum çizgesi kurulur: düğümler durumları, kenarlar geçişleri gösterir. 1–9 durumları için:

Bu oyunda tüm tek sayılı durumlar kaybedendir.

25.2 Nim Oyunu

Nim, oyun teorisinin temel taşıdır; çünkü çoğu oyun aynı stratejiyle analiz edilebilir.

Kurallar:

• $n$ öbek vardır, $k$. öbekte $x_k$ çubuk bulunur.
• Sıradaki oyuncu bir öbek seçer ve istediği kadar çubuk çıkarır.
• Son çubuğu çıkaran kazanır.
• Durum $[0, 0, \ldots, 0]$ kaybedendir.

Analiz: Nim Toplamı

Herhangi bir nim durumu nim toplamı ile sınıflandırılır:

$\oplus$ XOR operatörüdür. Nim toplamı 0 olan durum kaybedendir; diğerleri kazanandır.

Örnek: $[10, 12, 5]$ durumunda $s = 10 \oplus 12 \oplus 5 = 3 \neq 0$ → kazanan durum.

Neden işe yarar?

• Kaybeden durumlar: $[0,0,\ldots,0]$’ın nim toplamı 0’dır. Herhangi bir $x_k$’yı değiştirmek nim toplamını 0’dan farklı yapar → kazanan duruma geçilir.
• Kazanan durumlar: $x_k \oplus s < x_k$ olan bir $k$ her zaman mevcuttur (nim toplamının en soldaki bitine karşılık gelen öbek). Bu öbeği $x_k \oplus s$ büyüklüğüne düşürmek nim toplamını 0 yapar → kaybeden duruma geçilir.

Örnek hamle: $[10, 12, 5]$, nim toplamı $s = 3$:

$s$’nin en soldaki biti 10’un 2. bitine denk gelir. Yeni öbek boyutu: $10 \oplus 3 = 9$. Hamle: 10’lu öbekten 1 çubuk çıkar → $[9, 12, 5]$, nim toplamı $9 \oplus 12 \oplus 5 = 0$ → kaybeden durum.

Misère Nim

Misère versiyonunda son çubuğu alan kaybeder. Strateji:

• Tüm öbeklerde en fazla 1 çubuk kalana dek standart nim gibi oyna.
• Bu eşiğe gelindiğinde taktiği değiştir:
  • Standart nim’de tek çubuklu öbek sayısını çift tut.
  • Misère’de tek çubuklu öbek sayısını tek tut.

Bu eşik durumu her zaman kazanan bir durumdur (birden fazla çubuklu tek öbek mevcuttur, nim toplamı 0 değildir).

25.3 Sprague–Grundy Teoremi

Sprague–Grundy Teoremi, nim stratejisini aşağıdaki şartları sağlayan tüm oyunlara genelleştirir (Sprague 1935, Grundy 1939 — bağımsız olarak):

• İki oyuncu sırayla hamle yapar.
• Olası hamleler kimin sırasında olduğuna bağlı değildir.
• Hamle yapamayan oyuncu kaybeder.
• Oyun sonlu durumda biter.
• Oyuncuların tam bilgisi vardır; rastgelelik yoktur.

Temel fikir: Her oyun durumuna bir Grundy sayısı atanır. Bu sayı bir nim öbeğindeki çubuk sayısına karşılık gelir; böylece oyun standart nim gibi oynanabilir.

Grundy Sayısı (mex)

Bir durumun Grundy sayısı:

$g_1, g_2, \ldots, g_n$ gidilebilecek durumların Grundy sayıları; mex ise kümede bulunmayan en küçük negatif olmayan tam sayıdır.

Örnek: $\text{mex}({0, 1, 3}) = 2$. Hamle olmayan durumda $\text{mex}(\emptyset) = 0$.

Özellikler:

• Grundy sayısı 0 → kaybeden durum
• Grundy sayısı pozitif → kazanan durum
• Grundy sayısı $x > 0$ olan durumdan $0, 1, \ldots, x-1$ Grundy sayılı tüm durumlara gidilebilir

Labirent oyunu örneği: Oyuncular figürü sol veya yukarı hareket ettiriyor; son hamleyi yapan kazanıyor. Sol alt köşenin Grundy sayısı 2 → kazanan durum. Kaybeden duruma ya iki adım yukarı ya dört adım sola gidilerek varılır.

Standart nim’den farklı olarak Grundy sayısı daha büyük bir duruma geçmek mümkündür; fakat rakip her zaman bu hamleyi nötrleyebilir.

Alt Oyunlar

Oyun birden fazla bağımsız alt oyundan oluşuyorsa ve her hamlede yalnızca bir alt oyunda hareket ediliyorsa, tüm oyunun Grundy sayısı alt oyunların Grundy sayılarının nim toplamıdır:

Örnek: 3 labirentten oluşan oyun; başlangıç Grundy sayıları 2, 3, 3 ise:

Optimal hamle: ilk labirentte iki adım yukarı git → $0 \oplus 3 \oplus 3 = 0$ (kaybeden durum).

Grundy’nin Oyunu

Bazen bir hamle oyunu bağımsız alt oyunlara böler. Bu durumda:

Grundy’nin Oyunu: Tek bir öbek var; her hamlede oyuncu seçtiği öbeği farklı büyüklükte iki boş olmayan öbeğe böler. Son hamleyi yapan kazanır.

$f(n)$, $n$ çubuklu öbeğin Grundy sayısı olsun. Örneğin $n = 8$:

1 ve 2 çubuklu öbekler bölünemez; dolayısıyla $f(1) = f(2) = 0$. İlk Grundy sayıları:

$f(8) = 2 \neq 0$ → kazanan durum. Kazanan hamle: $1 + 7$ olarak böl, çünkü $f(1) \oplus f(7) = 0 \oplus 0 = 0$.

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

Zar atma örneğiyle:

• $P(\text{“sonuç 4”}) = 1/6$
• $P(\text{“sonuç 6 değil”}) = 5/6$
• $P(\text{“sonuç çift”}) = 1/2$ ``

24.1 Hesaplama

Bir olayın olasılığını hesaplamak için iki temel yöntem kullanılır.

1. Yöntem — Kombinatorik: Olasılık şu formülle bulunur:

Örneğin karıştırılmış 52 kartlık desteden aynı değerde 3 kart seçme olasılığı:

çünkü 13 kart değeri vardır, her değerden 4 kart arasından 3 seçilir ve toplamda 52 karttan 3 seçilir.

2. Yöntem — Simülasyon (Adım adım çarpım): Her adımı sırayla düşünürüz:

• 1. kart: herhangi bir kart → olasılık $1$
• 1. kart: kalan 51 kart arasında aynı değerde 3 kart → olasılık $3/51$
• 1. kart: kalan 50 kart arasında aynı değerde 2 kart → olasılık $2/50$

24.2 Olaylar

Olasılık teorisinde bir olay $A$, tüm olası durumlar kümesi $X$’in bir alt kümesidir: $A \subset X$.

Zar örneğinde $X = {1,2,3,4,5,6}$ ve “çift sayı gelme” olayı $A = {2,4,6}$’dır. Her $x$ durumuna bir $p(x)$ olasılığı atanır; olayın olasılığı:

Tüm olası durumların olasılıkları toplamı her zaman $P(X) = 1$ olmalıdır.

Temel İşlemler

Olaylar birer küme olduğundan standart küme işlemleri uygulanır:

• Tümleyen $\bar{A}$: “$A$ gerçekleşmeyecek”. $P(\bar{A}) = 1 - P(A)$
• Birleşim $A \cup B$: “$A$ veya $B$ gerçekleşecek”. $P(A \cup B) = P(A) + P(B) - P(A \cap B)$
• Kesişim $A \cap B$: “$A$ ve $B$ birlikte gerçekleşecek”. $P(A \cap B) = P(A)\,P(B \mid A)$

Tümleyen ile zıt problem çözme: 10 defa zar attığımızda en az bir kez 6 gelme olasılığı doğrudan hesaplamak yerine tümleyenle bulunur:

Birleşim örneği: Zar atarken $A = $ “çift sayı” ve $B = $ “4’ten küçük” olayları için:

Eğer $A \cap B = \emptyset$ (ayrık olaylar) ise $P(A \cup B) = P(A) + P(B)$.

Koşullu Olasılık

$B$ olayının gerçekleşeceği bilindiğinde $A$’nın olasılığı:

Bağımsız Olaylar

$A$ ve $B$ olayları, birinin gerçekleşmesi diğerini etkilemiyorsa bağımsızdır: $P(A \mid B) = P(A)$ ve $P(B \mid A) = P(B)$. Bu durumda:

Örneğin desteden kart çekerken $A = $ “sinek” ve $B = $ “değeri 4” bağımsızdır:

24.3 Rastgele Değişkenler

Rastgele değişken, rastgele bir süreçten üretilen sayısal değerdir. $P(X = x)$ ifadesi $X$’in $x$ değerini alma olasılığını verir.

Örneğin iki zar atıldığında $X = $ “toplamları” için $P(X = 10) = 3/36$; zira [4,6], [5,5] ve [6,4] kombinasyonları 10 toplamını verir.

Beklenen Değer

Beklenen değer $E[X]$, $X$’in ağırlıklı ortalamasıdır:

Tek zar için: $E[X] = \frac{1}{6}(1+2+3+4+5+6) = \frac{7}{2}$

Beklenen değerin doğrusallığı: Değişkenler bağımlı olsa bile:

İki zar için: $E[X_1 + X_2] = 7/2 + 7/2 = 7$.

Uygulama: $n$ topun rastgele $n$ kutuya yerleştirildiğinde boş kutu sayısının beklenen değeri nedir? Tek bir kutunun boş kalma olasılığı $\left(\frac{n-1}{n}\right)^n$ olduğundan, doğrusallık ile:

Dağılımlar

Bir rastgele değişkenin dağılımı, alabileceği her değerin olasılığını gösterir. Önemli dağılımlar:

Sürekli (Uniform) dağılım: $a, a+1, \ldots, b$ arasındaki $n$ değerden her birinin olasılığı $1/n$’dir.

Zar için: $E[X] = (1+6)/2 = 7/2$.

Binom dağılım: $n$ denemeden her birinin başarı olasılığı $p$ iken tam $x$ başarının olasılığı:

Örneğin 10 zar atışında tam 3 kez 6 gelme olasılığı: $\binom{10}{3}(1/6)^3(5/6)^7$.

Geometrik dağılım: İlk başarıya ulaşmak için gereken deneme sayısı ($p$ başarı olasılığı):

Örneğin 6 gelene kadar zar atarken 4 denemede başarı olasılığı: $(5/6)^3 \cdot 1/6$.

24.4 Markov Zincirleri

Markov zinciri, durumlar ve aralarındaki geçiş olasılıklarından oluşan rastgele bir süreçtir. Bir çizge olarak gösterilir: düğümler durumları, kenarlar geçişleri temsil eder.

Örnek: $n$ katlı binada her adımda bir kat yukarı ya da aşağı yürünüyor (1. kattan sadece yukarı, $n$. kattan sadece aşağı). $n = 5$ için çizge:

Olasılık dağılımı $[p_1, p_2, \ldots, p_n]$ vektörü ile tutulur; $p_k$ şu anki durumun $k$ olma ihtimalidir, $\sum p_k = 1$.

1. kattan başlayınca ilk dağılım $[1, 0, 0, 0, 0]$, sonraki $[0, 1, 0, 0, 0]$, ondan sonra $[1/2, 0, 1/2, 0, 0]$ şeklinde ilerler.

Hesaplama yöntemleri:

• Dinamik programlama: Dağılım vektörünü adım adım güncelleyerek $O(n^2 m)$ sürede $m$ adım hesaplanır.
• Matris kuvveti: Geçişler bir $n \times n$ geçiş matrisi $T$ ile ifade edilir. $m$ adım sonraki dağılım $T^m \cdot [p_1, \ldots, p_n]^T$ ile bulunur ve $O(n^3 \log m)$ sürer.

$n = 5$ için geçiş matrisi:

24.5 Rastgele Algoritmalar

Rastgele algoritma, probleme özgü rastgelelik olmasa bile kendi iç rastgeleliğini kullanan algoritmadır. İki ana türü vardır:

• Monte Carlo algoritması: Kesin doğru cevap garantisi yoktur, küçük bir hata olasılığı kabul edilir; buna karşın çalışma süresi deterministiktir.
• Las Vegas algoritması: Her zaman doğru cevabı verir; çalışma süresi rastgeledir ama beklenen süre verimlidir.

Sıra İstatistikleri (Quickselect)

$n$ elemanlı bir dizinin $k$. en küçük elemanını bulmak için diziyi tamamen sıralamak şart değildir. Hızlı Seçme (Quickselect) bir Las Vegas algoritmasıdır:

1. Diziden rastgele bir $x$ öğesi (pivot) seç.
2. $x$’ten küçükleri sola, büyükleri sağa yerleştir ($O(n)$ sürer).
3. Sol kısımda $a$ eleman varsa:
   • $a = k-1$ ise $x$ cevaptır.
   • $a \geq k$ ise sol kısımda ara.
   • $a < k-1$ ise sağ kısımda $(k-a-1)$. sırayı ara.

Beklenen süre:

En kötü durum $O(n^2)$ olmakla birlikte pratikte bu durum son derece nadirdir.

Matris Çarpımını Doğrulama (Freivalds Algoritması)

$n \times n$ boyutlu $A$, $B$, $C$ matrisleri için $AB = C$ mi sorusunu $O(n^2)$’de doğrulamak mümkündür (doğrudan $AB$ çarpmak $O(n^3)$ sürer):

1. Rastgele bir $n$ boyutlu $X$ vektörü seç.
2. $A(BX)$ ve $CX$ matrislerini hesapla (her biri $O(n^2)$).
3. $A(BX) = CX$ ise $AB = C$ de; değilse $AB \neq C$ de.

Algoritma (Freivalds, 1977) $AB \neq C$ olduğu hâlde yanlış “eşit” diyebilir; fakat bu olasılık çok küçüktür ve testi farklı rastgele $X$’lerle tekrarlamak hata ihtimalini üstel hızda azaltır.

Çizge Boyaması

$n$ düğüm ve $m$ kenardan oluşan bir çizgeyi iki renkle öyle boyamak istiyoruz ki en az $m/2$ kenarda uç noktaların renkleri farklı olsun.

Las Vegas yaklaşımı: Her düğümü $1/2$ olasılıkla bağımsız olarak renklendir. Tek bir kenarın uç noktalarının farklı renkli olma olasılığı $1/2$’dir. Doğrusallık gereği beklenen “farklı uçlu kenar” sayısı $m/2$’dir. Yani rastgele bir boyama beklenen değerde geçerlidir; dolayısıyla geçerli bir boyama genellikle hızla bulunur.

$A$ matrisinin transpozu $A^T$, satırlar ile sütunların yer değiştirmesinden elde edilir: $A^T[i, j] = A[j, i]$. Satır ve sütun sayısı eşit olan matris kare matristir. ``

23.1 Operasyonlar

Toplama ve Skaler Çarpma

Aynı boyuttaki $A$ ve $B$ matrislerinin toplamı $A + B$, karşılıklı elemanların toplamından oluşur:

Bir matrisi $x$ skaleriyle çarpmak, her elemanı $x$ ile çarpar:

Matris Çarpımı

$A$ matrisi $a \times n$, $B$ matrisi $n \times b$ boyutunda ise $AB$ çarpımı tanımlıdır ve $a \times b$ boyutunda bir matris üretir:

Her eleman, $A$’nın ilgili satırı ile $B$’nin ilgili sütununun nokta çarpımına eşittir. Örneğin:

Matris çarpımı birleşme özelliğine sahiptir ($A(BC) = (AB)C$) ama değişme özelliğine sahip değildir ($AB \neq BA$ olabilir).

Birim matris $I$, köşegenleri 1, diğer tüm elemanları 0 olan kare matristir. Herhangi bir $A$ için $AI = IA = A$ geçerlidir.

$n \times n$ iki matrisin çarpımı düz algoritmada $O(n^3)$ zamanda hesaplanır. Strassen (1969) gibi daha verimli algoritmalar teorik açıdan ilginç olmakla birlikte rekabetçi programlamada genellikle gerekli değildir.

Matris Kuvveti

$A$ kare matrisi ise $A^k$, $A$’nın kendisiyle $k$ defa çarpılmasıdır; $A^0 = I$. Modüler üs almanın analogu olan hızlı kuvvet yöntemiyle $A^k$, $O(n^3 \log k)$ zamanda hesaplanır:

Örneğin:

Determinant

$A$ kare matrisi için determinant $\det(A)$, özyinelemeli olarak hesaplanır. $1 \times 1$ matris için $\det(A) = A[1,1]$. Daha büyük matrisler için:

Burada $C[i, j] = (-1)^{i+j} \det(M[i,j])$ kofaktördür ve $M[i,j]$, $A$’dan $i$. satır ile $j$. sütun çıkarılarak elde edilir. Örneğin:

Ters Matris

$\det(A) \neq 0$ ise $A \cdot A^{-1} = I$ koşulunu sağlayan ters matris $A^{-1}$ mevcuttur:

Örneğin:

23.2 Lineer Tekrar (Linear Recurrences)

Lineer tekrar, $f(n)$ fonksiyonunun ilk $k$ değeriyle tanımlandığı ve büyük değerlerin şu formülle hesaplandığı bir yapıdır:

Dinamik programlamayla tüm değerleri soldan sağa hesaplamak $O(kn)$ zaman alır. Ancak $k$ küçükse matris işlemleriyle $f(n)$, $O(k^3 \log n)$ zamanda hesaplanabilir.

Fibonacci Sayıları

Fibonacci tekrarı $k = 2$, $c_1 = c_2 = 1$ olan özel bir lineer tekrardır:

$2 \times 2$ boyutundaki $X$ matrisiyle şu ilişki kurulur:

Bu dönüşümü gerçekleştiren matris:

Dolayısıyla:

$X^n$ matrisi $O(\log n)$ zamanda hesaplandığından $f(n)$ de $O(\log n)$ zamanda bulunur. Örneğin:

Genel Durum

Genel $k$’lı lineer tekrar için $k \times k$ boyutundaki dönüşüm matrisi:

İlk $k-1$ satır her değeri bir sonrakiyle kaydırır; son satır tekrarın katsayılarını taşır. Bu matrisle:

Bu formül $O(k^3 \log n)$ zamanda çalışır.

23.3 Çizgeler ve Matrisler

Yolları Saymak

Ağırlıksız bir çizgenin komşuluk matrisi $V$ için, $V^n$ matrisinin $V^n[i,j]$ elemanı $i$’den $j$’ye tam $n$ kenarlık yolların sayısını verir.

Örneğin 6 düğümlü bir çizgenin komşuluk matrisi $V$’yi hesaplayıp $V^4$’ü bulursak:

Bu, 2. düğümden 5. düğüme 4 kenarlı iki farklı yol bulunduğunu söyler: $2 \to 1 \to 4 \to 2 \to 5$ ve $2 \to 6 \to 3 \to 2 \to 5$.

En Kısa Yollar

Aynı fikir ağırlıklı çizgelerde en kısa yol bulmak için de kullanılabilir. Standart matris çarpımındaki toplam ve çarpım işlemleri aşağıdaki gibi değiştirilir:

Başlangıç değerleri olarak komşuluk matrisinde kenar ağırlıkları, kenar olmayan yerlerde $\infty$ kullanılır. Bu yapıyla $V^n[i,j]$, $i$’den $j$’ye tam $n$ kenarlık yolların en kısa uzunluğuna eşittir.

Örneğin ağırlıklı bir çizgede:

Bu değer, $2 \to 1 \to 4 \to 2 \to 5$ yoluna karşılık gelir.

Kirchhoff’un Teoremi

Kirchhoff’un Teoremi, bir çizgenin toplam kapsayan ağaç sayısını Laplacian matrisin determinantı yardımıyla hesaplar.

Laplacian matris $L$ şöyle tanımlanır:

Toplam kapsayan ağaç sayısı, $L$’den herhangi bir satır ve sütun çıkarıldıktan sonra kalan matrisin determinantına eşittir; hangi satır-sütun çıkarılırsa çıkarılsın sonuç değişmez.

Örnek: 4 düğümlü tam çizgede (her düğüm çifti arasında kenar var) kapsayan ağaçların sayısını bulalım. Laplacian matris:

İlk satır ve sütun çıkarıldıktan sonra:

Gerçekten bu çizgenin 3 farklı kapsayan ağacı vardır.

Cayley’in Formülüyle bağlantı: $n$ düğümlü tam çizgenin Laplacian matrisinin herhangi bir $(n-1) \times (n-1)$ alt determinantı $n^{n-2}$ olduğundan, Cayley’in Formülü Kirchhoff’un Teoreminin özel bir durumudur.

Örneğin toplamı $n$ olan tam sayı dizisi sayısı gibi problemler özyinelemeli formüllerle ele alınır. $f(n)$, $n$’yi toplam olarak yazma yollarının sayısı olsun:

İlk değerler: $f(0)=1,\ f(1)=1,\ f(2)=2,\ f(3)=4,\ f(4)=8$. Bu durumda kapalı form $f(n) = 2^{n-1}$’dir; çünkü $n-1$ boşluktan istediğimizi seçip $+$ ya da hiç koyabiliriz. ``

22.1 Binom Katsayıları

$\binom{n}{k}$, $n$ elemanlı bir kümeden $k$ elemanlı alt küme seçme sayısıdır. Örneğin $\binom{5}{3} = 10$ çünkü ${1,2,3,4,5}$ kümesinin 3 elemanlı alt kümeleri şunlardır:

1. Formül: Özyineleme

Kümedeki bir $x$ elemanı sabitlenir. $x$ alt kümede ya var ya yoktur:

Temel durumlar:

2. Formül: Faktöriyel

$n$ elemanın $n!$ permütasyonu arasından ilk $k$’sını alt kümeye eklersek, sıralama önemli olmadığından $k!$ ve $(n-k)!$’e böleriz:

Özellikler

Tüm binom katsayılarının toplamı:

Binom teoremi:

Pascal’ın Üçgeni: Her değer, üstündeki iki değerin toplamıdır:

            1
          1   1
        1   2   1
      1   3   3   1
    1   4   6   4   1
   ...  ...  ... ...  ...

Kutular ve Toplar

$k$ topu $n$ kutuya yerleştirme probleminin üç farklı varyantı vardır:

1. Durum — Her kutu en fazla 1 top alır: Çözüm sayısı doğrudan $\dbinom{n}{k}$’dır.

2. Durum — Bir kutu birden fazla top alabilir: Topları “o” ve kutu geçişlerini “→” ile sembolize edersek her çözüm $k$ adet “o” ve $n-1$ adet “→” içeren bir diziye karşılık gelir:

3. Durum — Her kutu en fazla 1 top alır ve ardışık iki kutu aynı anda dolu olamaz: $k$ topu önce $k$ ayrı kutuya yerleştirip aralarına birer boş kutu koyarız; kalan $n - 2k + 1$ kutuyu dağıtmak için 2. senaryonun formülünü uygularız:

Çok Terimli Katsayılar

$n$ nesneyi $k_1, k_2, \ldots, k_m$ büyüklüklü gruplara ayırma sayısı:

Bu, binom katsayısının $m = 2$ özel durumudur.

22.2 Katalan Sayıları

$C_n$, $n$ sol ve $n$ sağ parantezden oluşan geçerli parantez ifadelerinin sayısıdır. Örneğin $C_3 = 5$:

Geçerli Parantez İfadesi

Bir ifade geçerlidir ancak ve ancak:

• Her ön ekinde sağ parantez sayısı sol parantez sayısını geçmiyorsa,
• Toplam sol ve sağ parantez sayıları eşitse.

1. Formül: Özyineleme

İfadeyi iki parçaya böleriz; ilk parça mümkün olduğunca küçük tutulur:

Herhangi bir $i$ için ilk bölüm $i+1$ parantez çifti, ikinci bölüm $n-i-1$ parantez çifti içerir.

2. Formül: Binom Katsayısı

Türetme: $n$ sol ve $n$ sağ parantezden oluşan toplam $\binom{2n}{n}$ dizi vardır. Bunlardan geçersiz olanlar, ilk geçersizleştiği noktadan sonraki kısmın sembollerini ters çevirince $n+1$ sol ve $n-1$ sağ parantezli bir diziye dönüşür; bu tür dizi sayısı $\binom{2n}{n+1}$’dir. Dolayısıyla:

Ağaçlarla Bağlantı

Katalan sayıları ağaç sayma problemlerinde de ortaya çıkar:

• $n$ düğümden oluşan ikili ağaç sayısı $C_n$’dir.
• $n$ düğümden oluşan köklü ağaç sayısı $C_{n-1}$’dir.

Örneğin $C_3 = 5$ için 5 farklı ikili ağaç ve $C_2 = 2$ için 2 farklı köklü ağaç vardır.

22.3 İçerme-Dışarma

İçerme-dışarma ilkesi, kesişim büyüklüklerini kullanarak birleşim büyüklüğünü (ya da tersini) hesaplamamızı sağlar.

İki küme için:

Üç küme için:

Genel kural: Tek sayıda kümenin kesişimi eklenir, çift sayıda kümenin kesişimi çıkarılır.

Simetrik olarak kesişim büyüklükleri de birleşimden hesaplanabilir. Örneğin:

Düzensizlikler (Derangements)

${1, 2, \ldots, n}$ elemanlarının düzensizliği, hiçbir elemanın kendi konumunda bulunmadığı permütasyondur. Örneğin $n = 3$ için $(2,3,1)$ ve $(3,1,2)$ olmak üzere yalnızca 2 düzensizlik vardır.

İçerme-dışarma ile: $X_k$, $k$. pozisyonda $k$ elemanını içeren permütasyon kümesi olsun. Düzensizlik sayısı:

$n = 3$ için:

Düzensizlik sayısı $= 3! - 4 = 2$.

Özyineleme ile: $f(n)$, $n$ elemanlı kümenin düzensizlik sayısı olsun. 1. elemanın hangi $x$ ile yer değiştirdiğine göre iki seçenek vardır:

1. $x$ de 1. elemanın konumuna geçer → $n-2$ elemanlık düzensizlik: $f(n-2)$ yol.
2. $x$, 1. elemana değil başka bir konuma geçer → $n-1$ elemanlık düzensizlik: $f(n-1)$ yol.

22.4 Burnside’ın Lemma’sı

Burnside’ın Lemma’sı, simetriler dikkate alındığında birbirinden gerçekten farklı kombinasyon sayısını hesaplamamızı sağlar. $n$ farklı dönüşüm (pozisyon değiştirme yolu) varsa ve $k$. dönüşüm uygulandığında $c(k)$ kombinasyon değişmeden kalıyorsa, toplam farklı kombinasyon sayısı:

Örnek: Renkli Kolye

$n$ inciden oluşan, her incinin $m$ farklı rengi olabileceği bir kolyede, döndürme simetrileri dikkate alındığında kaç farklı kolye vardır?

Kolyeyi $0, 1, \ldots, n-1$ adım döndürebiliriz ($n$ farklı dönüşüm). $k$ adım döndürüldüğünde sabit kalan kolye sayısı:

Bunun nedeni $\gcd(k,n)$ büyüklüğündeki inci bloklarının birbirinin yerine geçmesidir. Burnside’ın Lemma’sına göre farklı kolye sayısı:

Örnek: $n = 4$, $m = 3$ için:

22.5 Cayley’in Formülü

Cayley’in Formülü, $n$ etiketli düğüm üzerinde oluşturulabilecek farklı ağaç sayısının $n^{n-2}$ olduğunu söyler. Düğümler $1, 2, \ldots, n$ ile etiketlenir; hem yapısı hem etiketi farklı olan ağaçlar sayılır.

Örneğin $n = 4$ için toplam etiketli ağaç sayısı $4^{4-2} = 16$’dır.

Prüfer Kodu

Cayley’in Formülü, Prüfer kodu ile kanıtlanır. Prüfer kodu, etiketli bir ağacı $n-2$ sayıdan oluşan bir diziye dönüştürür.

Kodlama algoritması: $n-2$ kez tekrarlanır:

1. Ağaçtaki en küçük etiketli yaprak kaldırılır.
2. Bu yaprağın tek komşusunun etiketi koda eklenir.

Örnek: 5 düğümlü bir ağaçta adımlar şöyle ilerler:

• 1. düğüm (yaprak) kaldırılır → komşu 4 koda eklenir: [4]
• 1. düğüm (yaprak) kaldırılır → komşu 4 koda eklenir: [4, 4]
• 1. düğüm (yaprak) kaldırılır → komşu 2 koda eklenir: [4, 4, 2]

Prüfer kodu: $[4, 4, 2]$.

Neden $n^{n-2}$? Her etiketli ağacın benzersiz bir Prüfer kodu vardır ve her Prüfer kodundan orijinal ağaç benzersiz biçimde yeniden oluşturulabilir. ${1, 2, \ldots, n}$ üzerindeki $n-2$ uzunluklu dizi sayısı $n^{n-2}$ olduğundan etiketli ağaç sayısı da $n^{n-2}$’dir.

Bu bölümde sayılar teorisinin rekabetçi programlamada sık karşılaşılan temel kavramları ve algoritmaları ele alınmaktadır. ``

21.1 Asal Sayılar ve Bölenler

$a$ sayısı $b$ sayısını bölüyorsa $a$, $b$’nin böleni ya da çarpanı olarak adlandırılır; $a \mid b$ ile gösterilir. Örneğin 24’ün bölenleri $1, 2, 3, 4, 6, 8, 12, 24$’tür.

$n > 1$ olan bir sayı yalnızca $1$ ve kendisine bölünebiliyorsa asal sayıdır. Her $n > 1$ için tekil bir asal çarpanlara ayrılma mevcuttur:

Örneğin $84 = 2^2 \cdot 3^1 \cdot 7^1$.

Çarpan Sayısı, Toplamı ve Çarpımı

$n$’nin çarpan sayısı:

Örneğin $\tau(84) = 3 \cdot 2 \cdot 2 = 12$.

$n$’nin çarpanlarının toplamı:

Örneğin $\sigma(84) = \dfrac{2^3 - 1}{2-1} \cdot \dfrac{3^2 - 1}{3-1} \cdot \dfrac{7^2 - 1}{7-1} = 7 \cdot 4 \cdot 8 = 224$.

$n$’nin çarpanlarının çarpımı:

Çarpanlar $\tau(n)/2$ çift oluşturur. Örneğin $84$’ün çarpanları $1 \cdot 84,\ 2 \cdot 42,\ 3 \cdot 28, \ldots$ çiftlerini oluşturur ve $\mu(84) = 84^6$.

Bir sayı $n = \sigma(n) - n$ ise mükemmel sayıdır; yani 1’den $n-1$’e kadar olan çarpanlarının toplamına eşittir. Örneğin $28 = 1 + 2 + 4 + 7 + 14$.

Asal Sayıların Sayısı ve Yoğunluğu

Sonsuz sayıda asal sayı vardır. Bunu çelişkiyle kanıtlayabiliriz: sonlu sayıda asal olsaydı $p_1 p_2 \cdots p_n + 1$ bu listenin hiçbir elemanına bölünemeyecek yeni bir asal oluştururdu.

$\pi(n)$, 1 ile $n$ arasındaki asal sayı adedini gösterir. Asal sayıların yoğunluğu için şu yaklaşım geçerlidir:

Örneğin $\pi(10^6) = 78498$ iken $10^6 / \ln 10^6 \approx 72382$.

Ünlü Konjektürler

Kanıtlanamamış fakat doğru olduğu güçlü biçimde düşünülen açık problemler:

• Goldbach’ın Konjektürü: Her $n > 2$ çift sayısı iki asal sayının toplamı olarak yazılabilir.
• İkiz Asal Konjektürü: $p$ ve $p+2$’nin her ikisinin de asal olduğu sonsuz sayıda ${p, p+2}$ çifti vardır.
• Legendre’nin Konjektürü: Her pozitif $n$ için $n^2$ ile $(n+1)^2$ arasında en az bir asal sayı bulunur.

Asal Sayı Testi ve Çarpanlara Ayırma

$n$ asal değilse $a \cdot b = n$ çarpımında $a \leq \sqrt{n}$ ya da $b \leq \sqrt{n}$ olmak zorundadır. Bu gözlem $O(\sqrt{n})$ zamanlı basit algoritmaların temelini oluşturur.

bool prime(int n) {
    if (n < 2) return false;
    for (int x = 2; x * x <= n; x++) {
        if (n % x == 0) return false;
    }
    return true;
}

vector<int> factors(int n) {
    vector<int> f;
    for (int x = 2; x * x <= n; x++) {
        while (n % x == 0) {
            f.push_back(x);
            n /= x;
        }
    }
    if (n > 1) f.push_back(n);
    return f;
}

Örneğin $24 = 2^3 \cdot 3$ için factors(24) sonucu [2, 2, 2, 3] olur.

Eratosten Kalburu

Eratosten Kalburu (Sieve of Eratosthenes), $2 \ldots n$ arasındaki her sayının asal olup olmadığını ve değilse bir asal çarpanını $O(n \log \log n)$ zamanda bulan ön işleme algoritmasıdır.

sieve[k] = 0 ise $k$ asaldır; sieve[k] != 0 ise sieve[k], $k$’nın asal çarpanlarından biridir.

for (int x = 2; x <= n; x++) {
    if (sieve[x]) continue;
    for (int u = 2 * x; u <= n; u += x) {
        sieve[u] = x;
    }
}

Örneğin $n = 20$ için dizi:

İç döngü yalnızca $x$ asal olduğunda çalıştığından gerçek karmaşıklık $O(n \log \log n)$’dir; bu değer $O(n)$’e çok yakındır.

Öklid’in Algoritması

$\gcd(a, b)$, hem $a$ hem $b$’yi bölen en büyük sayıdır. $\text{lcm}(a, b)$ ise her ikisi tarafından bölünebilen en küçük sayıdır. İkisi arasındaki ilişki:

Öklid’in Algoritması M.Ö. 300’lere uzanan, bilinen en eski algoritmalardan biridir:

int gcd(int a, int b) {
    if (b == 0) return a;
    return gcd(b, a % b);
}

Algoritma $O(\log \min(a, b))$ zamanda çalışır. En kötü durum ardışık Fibonacci sayılarının girdi olarak verilmesidir; örneğin $\gcd(13, 8) = \gcd(8, 5) = \gcd(5, 3) = \cdots = 1$.

Euler’in Totient Fonksiyonu

$\gcd(a, b) = 1$ ise $a$ ve $b$ aralarında asaldır. Euler’in Totient Fonksiyonu $\varphi(n)$, $1$’den $n$’e kadar $n$ ile aralarında asal olan sayıların adedini verir. Asal çarpanlardan hesaplama formülü:

Örneğin $\varphi(12) = 2^1 \cdot (2-1) \cdot 3^0 \cdot (3-1) = 4$. $n$ asal ise $\varphi(n) = n - 1$.

21.2 Modüler Aritmetik

Modüler aritmetikte sayılar $0, 1, 2, \ldots, m-1$ aralığına sıkıştırılır; her $x$ sayısı $x \bmod m$ ile temsil edilir. Temel işlem özellikleri:

Modüler Üs Alma

$x^n \bmod m$ değerini $O(\log n)$ zamanda hesaplamak için hızlı kuvvet alma kullanılır:

int modpow(int x, int n, int m) {
    if (n == 0) return 1 % m;
    long long u = modpow(x, n / 2, m);
    u = (u * u) % m;
    if (n % 2 == 1) u = (u * x) % m;
    return u;
}

Fermat’ın Teoremi ve Euler’in Teoremi

$m$ asal ve $\gcd(x, m) = 1$ iken Fermat’ın Küçük Teoremi:

Bu aynı zamanda $x^k \bmod m = x^{k \bmod (m-1)} \bmod m$ bağıntısını verir. Daha genel haliyle Euler’in Teoremi, $\gcd(x, m) = 1$ iken:

Fermat’ın Teoremi bu sonucun $m$ asal olduğundaki özel durumudur çünkü $\varphi(m) = m - 1$.

Modüler Çarpımsal Ters

$x$ sayısının $m$ modülündeki çarpımsal tersi $x^{-1}$, şu koşulu sağlayan sayıdır:

Bu ters, $x$ ile $m$ aralarında asal olduğunda her zaman mevcuttur. Örneğin $x = 6$, $m = 17$ için $x^{-1} = 3$ çünkü $6 \cdot 3 \bmod 17 = 1$. Modüler ters, modüler aritmetikte bölme işlemini mümkün kılar: $x$’e bölmek $x^{-1}$ ile çarpmaya eşdeğerdir.

Euler’in Teoreminden çarpımsal ters şöyle türetilir:

$m$ asal ise $x^{-1} = x^{m-2}$ olur. modpow ile verimli hesaplanır:

C++ notu: unsigned int türü $2^{32}$ ile doğal sarılma yapar; bu özellik bilinçli olarak modüler aritmetik hesaplamalarda kullanılabilir:

unsigned int x = 123456789;
cout << x * x << "\n";  // 123456789^2 mod 2^32 = 2537071545

21.3 Eşitlikleri Çözmek

Diyofantus Eşitlikleri

Diyofantus eşitliği, tam sayı çözüm aranan $ax + by = c$ biçimindeki denklemdir. Çözülebilmesi için gerekli ve yeterli koşul $\gcd(a, b) \mid c$’dir.

Çözüm genişletilmiş Öklid algoritması ile bulunur: önce $ax + by = \gcd(a, b)$ formu çözülür, ardından $c / \gcd(a, b)$ ile ölçeklenir.

Örnek: $39x + 15y = 12$. $\gcd(39, 15) = 3$ ve $3 \mid 12$ olduğundan çözülebilir. Öklid adımları:

Geri izleyerek $39 \cdot 2 + 15 \cdot (-5) = 3$ elde edilir; $4$ ile çarpılırsa:

Bir çözüm bulunduğunda sonsuz çözüm elde edilir. $(x, y)$ bir çözümse, her tam sayı $k$ için şu çift de çözümdür:

Çin Kalan Teoremi

Çin Kalan Teoremi (CRT), ikili aralarında asal modüllere sahip eşitlik sistemini çözer:

$X_k = m_1 m_2 \cdots m_n / m_k$ ve $X_k^{-1}$, $X_k$’nın $m_k$ modülündeki çarpımsal tersi olmak üzere çözüm:

Örnek:

Bir çözüm bulunduğunda $x + m_1 m_2 \cdots m_n$ biçimindeki tüm sayılar da çözümdür.

21.4 Diğer Sonuçlar

Lagrange’ın Teoremi

Her pozitif tam sayı en fazla dört tam karenin toplamı olarak ifade edilebilir:

Örneğin $123 = 8^2 + 5^2 + 5^2 + 3^2$.

Zeckendorf’un Teoremi

Her pozitif tam sayı, birbirini takip etmeyen farklı Fibonacci sayılarının toplamı olarak tek türlü yazılabilir. Örneğin $74 = 55 + 13 + 5 + 1$.

Pisagor Üçlüleri

$a^2 + b^2 = c^2$ bağıntısını sağlayan $(a, b, c)$ tam sayı üçlüsüne Pisagor üçlüsü denir. $(a, b, c)$ Pisagor üçlüsüyse her $k > 1$ için $(ka, kb, kc)$ de Pisagor üçlüsüdür. $a$, $b$ ve $c$ aralarında asal ise üçlü basittir (primitive). Tüm basit Pisagor üçlüleri Öklid’in formülü ile oluşturulur:

Burada $0 < m < n$, $n$ ve $m$ aralarında asal ve en az biri çifttir. Örneğin $m = 1$, $n = 2$ için $(3, 4, 5)$ elde edilir.

Wilson’un Teoremi

$n$ sayısı asal olmak ve ancak olmak üzere:

Örneğin $10! \bmod 11 = 10$ olduğundan 11 asaldır; $11! \bmod 12 = 0 \neq 11$ olduğundan 12 asal değildir. Pratikte $(n-1)!$ büyük $n$ için hesaplanamaz; bu nedenle asal testi açısından teorik önemi büyük olsa da pratik kullanımı sınırlıdır.