Ana içeriğe geç

Algoritma Örnekleri

Bu bölümde Lordex ile yazılmış çeşitli algoritma örneklerini bulabilirsiniz.

Matematiksel Algoritmalar​

Faktöriyel Hesaplama​

Bir sayının faktöriyelini hesaplar (n!).

fonksiyon faktoriyel(n) {
    eger (n <= 1) {
        geri_don 1
    }
    geri_don n * faktoriyel(n - 1)
}

// Test
yaz("5! = " + faktoriyel(5))    // 120
yaz("10! = " + faktoriyel(10))  // 3628800

İteratif Versiyon:

fonksiyon faktoriyel_iteratif(n) {
    sonuc = 1
    i = 2
    iken (i <= n) {
        sonuc = sonuc * i
        i = i + 1
    }
    geri_don sonuc
}

yaz(faktoriyel_iteratif(6))  // 720

Fibonacci Dizisi​

fonksiyon fibonacci(n) {
    eger (n <= 1) {
        geri_don n
    }
    geri_don fibonacci(n - 1) + fibonacci(n - 2)
}

// İlk 10 Fibonacci sayısı
yaz("Fibonacci Dizisi:")
i = 0
iken (i < 10) {
    yaz("F(" + i + ") = " + fibonacci(i))
    i = i + 1
}

Optimize Edilmiş Versiyon:

fonksiyon fibonacci_hizli(n) {
    eger (n <= 1) {
        geri_don n
    }
    
    a = 0
    b = 1
    sayac = 2
    
    iken (sayac <= n) {
        temp = a + b
        a = b
        b = temp
        sayac = sayac + 1
    }
    
    geri_don b
}

yaz(fibonacci_hizli(20))  // 6765

Asal Sayı Kontrolü​

fonksiyon asal_mi(n) {
    eger (n < 2) {
        geri_don hayir
    }
    
    eger (n == 2) {
        geri_don evet
    }
    
    eger (n % 2 == 0) {
        geri_don hayir
    }
    
    i = 3
    iken (i * i <= n) {
        eger (n % i == 0) {
            geri_don hayir
        }
        i = i + 2
    }
    
    geri_don evet
}

// 1-100 arası asal sayılar
yaz("1-100 arası asal sayılar:")
sayi = 2
iken (sayi <= 100) {
    eger (asal_mi(sayi)) {
        yaz(sayi)
    }
    sayi = sayi + 1
}

En Büyük Ortak Bölen (EBOB)​

fonksiyon ebob(a, b) {
    iken (b != 0) {
        temp = b
        b = a % b
        a = temp
    }
    geri_don a
}

yaz("EBOB(48, 18) = " + ebob(48, 18))  // 6
yaz("EBOB(100, 50) = " + ebob(100, 50)) // 50

En Küçük Ortak Kat (EKOK)​

fonksiyon ebob(a, b) {
    iken (b != 0) {
        temp = b
        b = a % b
        a = temp
    }
    geri_don a
}

fonksiyon ekok(a, b) {
    geri_don (a * b) / ebob(a, b)
}

yaz("EKOK(12, 18) = " + ekok(12, 18))  // 36

Sıralama Algoritmaları​

Bubble Sort (Kabarcık Sıralaması)​

fonksiyon bubble_sort(dizi) {
    n = uzunluk(dizi)
    
    i = 0
    iken (i < n) {
        j = 0
        iken (j < n - i - 1) {
            eger (dizi[j] > dizi[j + 1]) {
                // Swap
                temp = dizi[j]
                dizi[j] = dizi[j + 1]
                dizi[j + 1] = temp
            }
            j = j + 1
        }
        i = i + 1
    }
}

sayilar = [64, 34, 25, 12, 22, 11, 90]
yaz("Önce: " + sayilar)
bubble_sort(sayilar)
yaz("Sonra: " + sayilar)

Selection Sort (Seçmeli Sıralama)​

fonksiyon selection_sort(dizi) {
    n = uzunluk(dizi)
    
    i = 0
    iken (i < n - 1) {
        min_idx = i
        j = i + 1
        
        iken (j < n) {
            eger (dizi[j] < dizi[min_idx]) {
                min_idx = j
            }
            j = j + 1
        }
        
        // Swap
        eger (min_idx != i) {
            temp = dizi[i]
            dizi[i] = dizi[min_idx]
            dizi[min_idx] = temp
        }
        
        i = i + 1
    }
}

sayilar = [29, 10, 14, 37, 13]
selection_sort(sayilar)
yaz(sayilar)  // [10, 13, 14, 29, 37]

Arama Algoritmaları​

Linear Search (Doğrusal Arama)​

fonksiyon linear_search(dizi, aranan) {
    i = 0
    iken (i < uzunluk(dizi)) {
        eger (dizi[i] == aranan) {
            geri_don i
        }
        i = i + 1
    }
    geri_don -1  // Bulunamadı
}

sayilar = [10, 23, 45, 70, 11, 15]
indeks = linear_search(sayilar, 70)

eger (indeks != -1) {
    yaz("70 sayısı indeks " + indeks + " konumunda bulundu")
} degilse {
    yaz("Sayı bulunamadı")
}

Binary Search (İkili Arama)​

fonksiyon binary_search(dizi, aranan) {
    sol = 0
    sag = uzunluk(dizi) - 1
    
    iken (sol <= sag) {
        orta = int((sol + sag) / 2)
        
        eger (dizi[orta] == aranan) {
            geri_don orta
        } degilse_eger (dizi[orta] < aranan) {
            sol = orta + 1
        } degilse {
            sag = orta - 1
        }
    }
    
    geri_don -1
}

// Sıralı dizi gerekli!
sirali = [2, 5, 8, 12, 16, 23, 38, 45, 56, 67, 78]
sonuc = binary_search(sirali, 23)
yaz("23 sayısı indeks " + sonuc + " konumunda")

String Algoritmaları​

Palindrom Kontrolü​

fonksiyon palindrom_mu(metin) {
    n = uzunluk(metin)
    i = 0
    
    iken (i < n / 2) {
        eger (metin[i] != metin[n - 1 - i]) {
            geri_don hayir
        }
        i = i + 1
    }
    
    geri_don evet
}

yaz(palindrom_mu("kayak"))   // evet
yaz(palindrom_mu("merhaba")) // hayir

Karakter Sayma​

fonksiyon karakter_say(metin, aranan) {
    sayac = 0
    i = 0
    
    iken (i < uzunluk(metin)) {
        eger (metin[i] == aranan) {
            sayac = sayac + 1
        }
        i = i + 1
    }
    
    geri_don sayac
}

metin = "merhaba dünya"
yaz("'a' harfi " + karakter_say(metin, "a") + " kez geçiyor")

Dizi İşlemleri​

Dizi Ters Çevirme​

fonksiyon ters_cevir(dizi) {
    sol = 0
    sag = uzunluk(dizi) - 1
    
    iken (sol < sag) {
        temp = dizi[sol]
        dizi[sol] = dizi[sag]
        dizi[sag] = temp
        
        sol = sol + 1
        sag = sag - 1
    }
}

sayilar = [1, 2, 3, 4, 5]
yaz("Önce: " + sayilar)
ters_cevir(sayilar)
yaz("Sonra: " + sayilar)  // [5, 4, 3, 2, 1]

En Büyük ve En Küçük Bulma​

fonksiyon min_max_bul(dizi) {
    eger (uzunluk(dizi) == 0) {
        yaz("Dizi boş!")
        geri_don
    }
    
    en_kucuk = dizi[0]
    en_buyuk = dizi[0]
    
    icin (sayi in dizi) {
        eger (sayi < en_kucuk) {
            en_kucuk = sayi
        }
        eger (sayi > en_buyuk) {
            en_buyuk = sayi
        }
    }
    
    yaz("En küçük: " + en_kucuk)
    yaz("En büyük: " + en_buyuk)
}

sayilar = [45, 23, 67, 12, 89, 34]
min_max_bul(sayilar)

Dizi Ortalaması​

fonksiyon ortalama_hesapla(dizi) {
    eger (uzunluk(dizi) == 0) {
        geri_don 0
    }
    
    toplam = 0
    icin (sayi in dizi) {
        toplam = toplam + sayi
    }
    
    geri_don toplam / uzunluk(dizi)
}

notlar = [85, 92, 78, 90, 88]
ort = ortalama_hesapla(notlar)
yaz("Ortalama: " + ort)

Oyun Algoritmaları​

Tahmin Oyunu​

fonksiyon tahmin_oyunu() {
    hedef = int(rastgele() * 100) + 1
    tahmin_sayisi = 0
    max_tahmin = 7
    
    yaz("=== SAYI TAHMİN OYUNU ===")
    yaz("1 ile 100 arasında bir sayı tuttum!")
    yaz("Maksimum " + max_tahmin + " tahmin hakkınız var.")
    
    iken (tahmin_sayisi < max_tahmin) {
        yaz("\nTahmininiz (" + (tahmin_sayisi + 1) + "/" + max_tahmin + "):")
        tahmin = int(oku())
        tahmin_sayisi = tahmin_sayisi + 1
        
        eger (tahmin == hedef) {
            yaz("🎉 TEBRİKLER! " + tahmin_sayisi + " tahminde buldunuz!")
            geri_don
        } degilse_eger (tahmin < hedef) {
            yaz("⬆️ Daha büyük bir sayı deneyin")
        } degilse {
            yaz("⬇️ Daha küçük bir sayı deneyin")
        }
    }
    
    yaz("\n😢 Tahmin hakkınız bitti!")
    yaz("Doğru sayı: " + hedef)
}

tahmin_oyunu()

Taş Kağıt Makas​

fonksiyon tas_kagit_makas() {
    secenekler = ["taş", "kağıt", "makas"]
    bilgisayar = secenekler[int(rastgele() * 3)]
    
    yaz("=== TAŞ KAĞIT MAKAS ===")
    yaz("Seçiminiz (taş/kağıt/makas):")
    oyuncu = oku()
    
    yaz("\nSiz: " + oyuncu)
    yaz("Bilgisayar: " + bilgisayar)
    
    eger (oyuncu == bilgisayar) {
        yaz("🤝 Berabere!")
    } degilse_eger (
        (oyuncu == "taş" ve bilgisayar == "makas") veya
        (oyuncu == "kağıt" ve bilgisayar == "taş") veya
        (oyuncu == "makas" ve bilgisayar == "kağıt")
    ) {
        yaz("🎉 Kazandınız!")
    } degilse {
        yaz("😢 Kaybettiniz!")
    }
}

tas_kagit_makas()

Pratik Uygulamalar​

Basit Hesap Makinesi​

fonksiyon hesap_makinesi() {
    devam = evet
    
    iken (devam) {
        yaz("\n=== HESAP MAKİNESİ ===")
        yaz("1. Toplama")
        yaz("2. Çıkarma")
        yaz("3. Çarpma")
        yaz("4. Bölme")
        yaz("5. Çıkış")
        
        secim = int(oku("Seçiminiz: "))
        
        eger (secim >= 1 ve secim <= 4) {
            a = float(oku("Birinci sayı: "))
            b = float(oku("İkinci sayı: "))
            
            eger (secim == 1) {
                yaz("Sonuç: " + (a + b))
            } degilse_eger (secim == 2) {
                yaz("Sonuç: " + (a - b))
            } degilse_eger (secim == 3) {
                yaz("Sonuç: " + (a * b))
            } degilse {
                eger (b != 0) {
                    yaz("Sonuç: " + (a / b))
                } degilse {
                    yaz("HATA: Sıfıra bölme!")
                }
            }
        } degilse_eger (secim == 5) {
            devam = hayir
            yaz("Hoşça kalın!")
        } degilse {
            yaz("Geçersiz seçim!")
        }
    }
}

hesap_makinesi()

Not Ortalaması Hesaplama​

fonksiyon not_sistemi() {
    yaz("=== ÖĞRENCİ NOT SİSTEMİ ===")
    yaz("Kaç öğrenci var?")
    ogrenci_sayisi = int(oku())
    
    i = 0
    iken (i < ogrenci_sayisi) {
        yaz("\n--- Öğrenci " + (i + 1) + " ---")
        
        ad = oku("Ad: ")
        
        notlar = []
        j = 0
        iken (j < 3) {
            yaz("Not " + (j + 1) + ":")
            not = float(oku())
            ekle(notlar, not)
            j = j + 1
        }
        
        toplam = 0
        icin (not in notlar) {
            toplam = toplam + not
        }
        ortalama = toplam / uzunluk(notlar)
        
        yaz("\n" + ad + " - Ortalama: " + ortalama)
        
        eger (ortalama >= 90) {
            yaz("Harf Notu: AA")
        } degilse_eger (ortalama >= 80) {
            yaz("Harf Notu: BA")
        } degilse_eger (ortalama >= 70) {
            yaz("Harf Notu: BB")
        } degilse_eger (ortalama >= 60) {
            yaz("Harf Notu: CB")
        } degilse_eger (ortalama >= 50) {
            yaz("Harf Notu: CC")
        } degilse {
            yaz("Harf Notu: FF - Kaldı")
        }
        
        i = i + 1
    }
}

not_sistemi()

İpuçları​

Performans
  • Büyük veri setlerinde ikili arama doğrusal aramadan çok daha hızlıdır
  • Recursive fonksiyonlar zarif ama iteratif versiyonlar genellikle daha hızlıdır
  • Gereksiz döngülerden kaçının
Dikkat
  • Sıralama algoritmalarını kullanmadan önce dizinin sıralı olup olmadığını kontrol edin
  • Binary search sadece sıralı dizilerde çalışır
  • Recursive fonksiyonlarda exit koşulu unutmayın

Sonraki Adımlar​

Pratik

Bu algoritmaları çalıştırın ve değiştirerek kendi versiyonlarınızı oluşturun!