🧮 0.8: Temel Algoritmalar

Pseudocode, Flowchart ve Python Kodları ile Temel Algoritmalar

📖 Giriş

Bu bölümde temel algoritma problemlerini üç aşamalı yaklaşımla çözeceğiz:

🎯 Problem Çözme Yaklaşımı:
  1. Pseudocode: Algoritmanın sözde kodla yazılması
  2. Flowchart: Akış şeması ile görselleştirme
  3. Python Kodu: Çalışan kod yazılması

📐 1. Basit Hesaplama Problemleri

1.1 Dairenin Alanı

Problem: Yarıçapı verilen dairenin alanını hesaplayın (π ≈ 3.14).

1. BAŞLA 2. π = 3.14 3. r oku 4. alan = π × r × r 5. alan yazdır 6. BİTİR
flowchart TD A([BAŞLA]) --> B[π = 3.14] B --> C[/r oku/] C --> D[alan = π × r²] D --> E[/alan yazdır/] E --> F([BİTİR])
PI = 3.14
r = float(input("Yarıçap: "))
alan = PI * r ** 2
print(f"Alan: {alan:.2f}")

1.2 Karenin Alanı

Problem: Kenar uzunluğu verilen karenin alanını hesaplayın.

1. BAŞLA 2. kenar oku 3. alan = kenar × kenar 4. alan yazdır 5. BİTİR
kenar = float(input("Kenar: "))
alan = kenar ** 2
print(f"Alan: {alan}")
💡 Not: ** operatörü üs almak içindir. x**2 = x², x**3 = x³

1.3 Dikdörtgenin Çevresi

Problem: Kısa ve uzun kenar verilen dikdörtgenin çevresini hesaplayın.

1. BAŞLA 2. kısa, uzun oku 3. çevre = 2 × (kısa + uzun) 4. çevre yazdır 5. BİTİR
kisa = float(input("Kısa kenar: "))
uzun = float(input("Uzun kenar: "))
cevre = 2 * (kisa + uzun)
print(f"Çevre: {cevre}")

1.4 Üç Sayının Ortalaması

Problem: Üç sayının aritmetik ortalamasını bulun.

1. BAŞLA 2. a, b, c oku 3. ortalama = (a + b + c) / 3 4. ortalama yazdır 5. BİTİR
flowchart TD A([BAŞLA]) --> B[/a, b, c oku/] B --> C[ort = a + b + c / 3] C --> D[/ort yazdır/] D --> E([BİTİR])
a = float(input("a: "))
b = float(input("b: "))
c = float(input("c: "))
ortalama = (a + b + c) / 3
print(f"Ortalama: {ortalama:.2f}")

1.5 Celsius → Fahrenheit Dönüşümü

Problem: Celsius değerini Fahrenheit'a çevirin. Formül: F = C × 9/5 + 32

1. BAŞLA 2. C oku 3. F = C × 9 / 5 + 32 4. F yazdır 5. BİTİR
C = float(input("Celsius: "))
F = C * 9 / 5 + 32
print(f"{C}°C = {F}°F")

🔀 2. Karar Yapılı Algoritmalar

2.1 İki Sayıdan Büyüğü

Problem: Girilen iki sayıdan büyük olanı bulun.

1. BAŞLA 2. x, y oku 3. EĞER x > y ise 4. x yazdır 5. DEĞİLSE EĞER y > x ise 6. y yazdır 7. DEĞİLSE 8. "Eşit" yazdır 9. BİTİR
flowchart TD A([BAŞLA]) --> B[/x, y oku/] B --> C{x > y ?} C -->|Evet| D[/x yazdır/] C -->|Hayır| E{y > x ?} E -->|Evet| F[/y yazdır/] E -->|Hayır| G[/Eşit yazdır/] D --> H([BİTİR]) F --> H G --> H
x = float(input("x: "))
y = float(input("y: "))

if x > y:
    print(f"Büyük olan: {x}")
elif y > x:
    print(f"Büyük olan: {y}")
else:
    print("İki sayı eşit")

2.2 Tek mi Çift mi?

Problem: Girilen sayının tek mi çift mi olduğunu bulun.

1. BAŞLA 2. n oku 3. EĞER n % 2 == 0 ise 4. "Çift" yazdır 5. DEĞİLSE 6. "Tek" yazdır 7. BİTİR
n = int(input("n: "))

if n % 2 == 0:
    print("Çift")
else:
    print("Tek")
💡 % Operatörü: Mod operatörü bölmeden kalanı verir.
Çift sayılar 2'ye bölündüğünde kalan 0'dır.

2.3 Üç Sayıdan Min ve Max

Problem: Üç sayının en küçüğünü ve en büyüğünü bulun.

1. BAŞLA 2. a, b, c oku 3. min = a 4. EĞER b < min ise min = b 5. EĞER c < min ise min = c 6. max = a 7. EĞER b > max ise max = b 8. EĞER c > max ise max = c 9. min, max yazdır 10. BİTİR
a = float(input("a: "))
b = float(input("b: "))
c = float(input("c: "))

# Minimum bul
min_val = a
if b < min_val:
    min_val = b
if c < min_val:
    min_val = c

# Maximum bul
max_val = a
if b > max_val:
    max_val = b
if c > max_val:
    max_val = c

print(f"Min: {min_val}, Max: {max_val}")

🔄 3. Döngü Algoritmaları

3.1 Üs Alma (Exponentiation)

Problem: Taban ve üs verilen sayının sonucunu hesaplayın (örn: 2³ = 8).

1. BAŞLA 2. taban, üs oku 3. sonuç = 1 4. i = 1 5. i ≤ üs İKEN TEKRARLA: 6. sonuç = sonuç × taban 7. i = i + 1 8. sonuç yazdır 9. BİTİR
flowchart TD A([BAŞLA]) --> B[/taban, üs oku/] B --> C[sonuç = 1, i = 1] C --> D{i ≤ üs ?} D -->|Evet| E[sonuç = sonuç × taban] E --> F[i = i + 1] F --> D D -->|Hayır| G[/sonuç yazdır/] G --> H([BİTİR])
taban = int(input("Taban: "))
us = int(input("Üs: "))

sonuc = 1
for i in range(us):
    sonuc *= taban

print(f"{taban}^{us} = {sonuc}")
💡 Not: Python'da taban ** us ile de üs alınabilir, ancak algoritma dersinde döngü ile yazmanız beklenir.

3.2 Asal Sayı Kontrolü

Problem: Girilen sayının asal olup olmadığını kontrol edin.

🔢 Asal Sayı Nedir?

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

  • Asal sayılar: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, ...
  • Asal olmayan (Bileşik): 4, 6, 8, 9, 10, 12, 14, 15, ...
  • Özel: 1 ne asal ne de bileşiktir. 2 tek çift asal sayıdır.

Neden önemli? Kriptografi, şifreleme algoritmaları (RSA), hash fonksiyonları asal sayılara dayanır.

💡 Optimizasyon: Neden √n'e kadar kontrol yeterli?

Eğer n = a × b ise ve a ≤ b ise, o zaman a ≤ √n olmalıdır.

Çünkü a > √n ve b > √n olsaydı, a × b > n olurdu (çelişki!).

Örnek: 36 için √36 = 6. 36 = 2×18 = 3×12 = 4×9 = 6×6. En küçük çarpan her zaman ≤6.

1. BAŞLA 2. n oku 3. EĞER n < 2 ise "Asal Değil" yaz, BİTİR 4. i = 2 5. i × i ≤ n İKEN TEKRARLA: 6. EĞER n % i == 0 ise 7. "Asal Değil" yaz, BİTİR 8. i = i + 1 9. "Asal" yaz 10. BİTİR
n = int(input("n: "))

if n < 2:
    print("Asal değil")
else:
    asal = True
    i = 2
    while i * i <= n:
        if n % i == 0:
            asal = False
            break
        i += 1
    
    if asal:
        print(f"{n} asaldır")
    else:
        print(f"{n} asal değildir")

3.3 Onluktan İkiliye Dönüşüm

Problem: Onluk tabandaki sayıyı ikilik tabana çevirin.

🔢 Sayı Sistemleri ve Taban Dönüşümü

Günlük hayatta onluk sistem (decimal, base-10) kullanırız: 0-9 rakamları.

Bilgisayarlar ikilik sistem (binary, base-2) kullanır: sadece 0 ve 1.

Matematiksel Temel:

Her sayı, tabanın kuvvetlerinin toplamı olarak yazılabilir:

$157_{10} = 1×10^2 + 5×10^1 + 7×10^0 = 100 + 50 + 7$

$1011_2 = 1×2^3 + 0×2^2 + 1×2^1 + 1×2^0 = 8 + 0 + 2 + 1 = 11_{10}$

Onluktan İkiliye Dönüşüm Yöntemi:

Sayıyı sürekli 2'ye böl, kalanları tersten oku:

13 ÷ 2 = 6kalan: 1
6 ÷ 2 = 3kalan: 0
3 ÷ 2 = 1kalan: 1
1 ÷ 2 = 0kalan: 1

Sonuç: $13_{10} = 1101_2$ (alttan yukarı oku)

1. BAŞLA 2. n oku 3. EĞER n == 0 ise "0" yaz, BİTİR 4. ikili = "" 5. n > 0 İKEN TEKRARLA: 6. bit = n % 2 7. ikili = bit + ikili 8. n = n // 2 9. ikili yaz 10. BİTİR
flowchart TD A([BAŞLA]) --> B[/n oku/] B --> C{n == 0 ?} C -->|Evet| D[/0 yazdır/] C -->|Hayır| E[ikili = empty] E --> F{n > 0 ?} F -->|Evet| G[bit = n % 2] G --> H[ikili = bit + ikili] H --> I[n = n // 2] I --> F F -->|Hayır| J[/ikili yazdır/] D --> K([BİTİR]) J --> K
n = int(input("Onluk sayı: "))

if n == 0:
    print("İkilik: 0")
else:
    ikili = ""
    sayi = n
    while sayi > 0:
        bit = sayi % 2
        ikili = str(bit) + ikili
        sayi = sayi // 2
    print(f"{n} → {ikili}")

3.4 EBOB (Öklid Algoritması)

Problem: İki sayının en büyük ortak bölenini (EBOB) bulun.

📜 Öklid Algoritması: Yaklaşık 2300 yıl önce yaşayan Öklid, iki sayının EBOB'unu bulmak için şu yöntemi önerdi:
"İki sayıdan büyüğünden küçüğünü çıkart, işleme eşit oluncaya kadar devam et."

Modern hali: EBOB(a,b) = EBOB(b, a % b) → b sıfır olunca a cevaptır.
1. BAŞLA 2. a, b oku 3. b ≠ 0 İKEN TEKRARLA: 4. r = a % b 5. a = b 6. b = r 7. a yazdır (EBOB) 8. BİTİR
flowchart TD A([BAŞLA]) --> B[/a, b oku/] B --> C{b ≠ 0 ?} C -->|Evet| D[r = a % b] D --> E[a = b] E --> F[b = r] F --> C C -->|Hayır| G[/a yazdır/] G --> H([BİTİR])
a = int(input("a: "))
b = int(input("b: "))
orj_a, orj_b = a, b

while b != 0:
    a, b = b, a % b

print(f"EBOB({orj_a}, {orj_b}) = {a}")

3.5 EKOK

Problem: İki sayının en küçük ortak katını (EKOK) bulun.

💡 Formül: a × b = EBOB(a,b) × EKOK(a,b)
Bu nedenle: EKOK = (a × b) / EBOB
1. BAŞLA 2. a, b oku 3. EBOB'u Öklid algoritması ile bul 4. EKOK = (a × b) / EBOB 5. EKOK yazdır 6. BİTİR
# EBOB fonksiyonu
def ebob(a, b):
    while b != 0:
        a, b = b, a % b
    return a

a = int(input("a: "))
b = int(input("b: "))

eb = ebob(a, b)
ekok = (a * b) // eb

print(f"EBOB: {eb}")
print(f"EKOK: {ekok}")

3.6 N ile M Arası Toplam

Problem: N'den M'ye kadar tüm sayıların toplamını bulun.

Yöntem A: Döngü ile (O(n) zaman)

1. BAŞLA 2. n, m oku 3. toplam = 0 4. i = n'den m'e TEKRARLA: 5. toplam = toplam + i 6. toplam yazdır 7. BİTİR
n = int(input("n: "))
m = int(input("m: "))

toplam = 0
for i in range(n, m + 1):
    toplam += i

print(f"Döngü ile toplam: {toplam}")

Yöntem B: Gauss Formülü ile (O(1) zaman)

1. BAŞLA 2. n, m oku 3. terim_sayısı = (m - n) + 1 4. toplam = terim_sayısı × (n + m) / 2 5. toplam yazdır 6. BİTİR
n = int(input("n: "))
m = int(input("m: "))

terim = (m - n) + 1
toplam = terim * (n + m) // 2

print(f"Formül ile toplam: {toplam}")
⚡ Verimlilik Karşılaştırması:
Döngü yöntemi O(n) adım sürer (n büyüdükçe yavaşlar).
Formül yöntemi O(1) - sadece 3 işlem (anında sonuç).

Bu yüzden verimli algoritma seçimi çok önemlidir!

📋 4. Liste Algoritmaları

4.1 Doğrusal Arama (Linear Search)

Problem: Bir listede belirli bir elemanı arayın.

1. BAŞLA 2. liste, aranan oku 3. i = 0 4. i < len(liste) İKEN TEKRARLA: 5. EĞER liste[i] == aranan ise 6. i yazdır, BİTİR 7. i = i + 1 8. "Bulunamadı" yazdır 9. BİTİR
a = [1, 2, 5, 67, 98, 13]
aranan = 67

i = 0
while i < len(a):
    if a[i] == aranan:
        print(f"{aranan} bulundu! İndeks: {i}")
        break
    i += 1
else:
    print(f"{aranan} bulunamadı")
⚠️ Not: if aranan in a kullanmak yerine yukarıdaki döngü ile yazmanız beklenir!

4.2 Listede Min-Max Bulma

Problem: Bir listedeki en küçük ve en büyük elemanı bulun.

a = [-128, 62, 9000, -987, -85600]

# En küçük ve en büyük
min_val = a[0]
max_val = a[0]

i = 1
while i < len(a):
    if a[i] < min_val:
        min_val = a[i]
    if a[i] > max_val:
        max_val = a[i]
    i += 1

print(f"Min: {min_val}")
print(f"Max: {max_val}")

4.3 Liste Toplamı ve Ortalaması

a = [7, 10, 4, 44]

i = 0
toplam = 0

while i < len(a):
    toplam += a[i]
    i += 1

ortalama = toplam / len(a)

print(f"Toplam: {toplam}")
print(f"Ortalama: {ortalama}")

📋 Özet

Bu Bölümde Öğrendiklerimiz:
  1. Basit Hesaplamalar: Alan, çevre, ortalama, dönüşümler
  2. Karar Yapıları: Min/max, tek/çift, karşılaştırma
  3. Döngüler: Üs alma, asal kontrol, taban dönüşümü
  4. Klasik Algoritmalar: EBOB, EKOK (Öklid), Gauss toplamı
  5. Liste İşlemleri: Arama, min/max, toplam
🎯 Algoritma Dersinde Hatırla:
  • Her problemi önce pseudocode ile çöz
  • Akış şeması ile görselleştir
  • Hazır fonksiyonlar yerine kendi döngünü yaz
⚡ Verimlilik Hakkında Ön Bilgi

Bu bölümde bazı algoritmaların "daha verimli" olduğundan bahsettik. Örneğin Gauss formülü, döngüden çok daha hızlı.

Algoritmaların verimliliğini ölçmek için Big O notasyonu kullanılır:

  • O(1) - Sabit süre: Veri ne kadar büyük olursa olsun, aynı sürede biter (örn: Gauss formülü)
  • O(n) - Doğrusal: Veri büyüdükçe süre orantılı artar (örn: liste tarama)
  • O(n²) - Karesel: İç içe döngüler, veri büyüdükçe çok yavaşlar

Bu konuyu Bölüm 1: Algoritma Analizi'nde detaylı öğreneceksiniz.