Algoritmik düşünmede girdi, işlem ve çıktı nasıl belirlenir?

Algoritmik düşünmede girdi, işlem ve çıktı sıralaması nettir: Önce problemin hangi verileri aldığını, sonra bu veriler üzerinde hangi dönüşümlerin yapılacağını, son olarak hangi sonucu üretmesi gerektiğini belirlemek gerekir. Bu üçlü ayrım, algoritmanın neyi kabul ettiğini, ne yaptığını ve geriye ne verdiğini görünür hâle getirir.

Algoritmik düşünme yalnızca kod yazmak değildir. Koddan önce problem cümlesini parçalamak, gerekli bilgileri seçmek, adımları doğru sıraya koymak ve farklı girdilerde ne olacağını değerlendirmek gerekir.

Girdi, işlem ve çıktı arasındaki temel ayrım

Bir algoritmayı tasarlarken problemi üç kutuya ayırabilirsin. Her problem öncesinde şu soruları sırayla sormak, düşünceyi dağınık olmaktan çıkarıp izlenebilir bir akışa dönüştürür:

• Girdi ne geliyor? Algoritmanın dışarıdan aldığı verileri belirler. Bu veri bir sayı, birkaç sayı, bir metin, bir seçim veya birden fazla bilginin birleşimi olabilir.
• İşlem ne değişiyor? Alınan veriler üzerinde yapılacak hesaplama, karşılaştırma, sıralama, dönüştürme ya da karar verme adımlarını gösterir.
• Çıktı ne dönüyor? İşlemler tamamlandıktan sonra kullanıcıya, başka bir programa veya bir sonraki adıma sunulacak sonucu tanımlar.

Örneğin “İki sayının toplamını bul” probleminde girdi iki sayıdır. İşlem bu sayıların toplanmasıdır. Çıktı ise elde edilen toplam değeridir. Burada toplamın kendisi girdi değildir; girdiler üzerinde yapılan işlemin sonucudur.

Bu ayrımı yapmak, algoritmadaki gereksiz adımları fark etmeyi de kolaylaştırır. Bir bilgi işlem sırasında kullanılmıyorsa onu girdi listesine eklemek zorunda değilsin. Benzer şekilde, çıktı olarak istenmeyen ara hesaplamaları sonuç diye sunmamalısın. Ara değerler işlem sırasında kullanılabilir, fakat algoritmanın son çıktısı problem cümlesindeki isteğe karşılık gelmelidir.

Üç kutulu yaklaşım, kod yazmadan önce kullanılabilecek kısa bir karar çerçevesidir. Önce veriyi kutuya koyarsın, sonra veride yapılacak değişikliği tanımlarsın, en son dışarı aktarılacak sonucu belirlersin. Bu çerçeve sayesinde algoritmanın eksik girdiye, farklı değerlere veya beklenmeyen durumlara nasıl tepki vereceğini daha erken sorgulayabilirsin.

Problem cümlesi girdiye nasıl dönüştürülür?

Bir problem cümlesini algoritmaya dönüştürmenin ilk adımı, cümlede verilenlerle istenen sonucu birbirinden ayırmaktır. Bunun için üç soru kullanabilirsin: Verilen nedir? Kullanılacak bilgi nedir? Sonuçta ne isteniyor?

Örneğin “Bir öğrencinin üç sınav notunun ortalamasını hesapla” cümlesinde verilenler üç sınav notudur. Kullanılacak bilgi yine bu üç nottur, çünkü ortalama hesabı bunlara dayanır. İstenen sonuç ise notların toplamı değil, ortalamadır. Böylece girdi listesi üç nottan, işlem toplama ve bölme adımlarından, çıktı ise ortalama değerinden oluşur.

Problem metninde geçen her bilgi algoritmaya girdi olarak eklenmemelidir. “Bir kitabın adı, yazarı ve sayfa sayısı veriliyor. Sayfa sayısını ekrana yazdır” cümlesinde kitabın adı ve yazarı metinde bulunsa da istenen sonuç için gerekli değildir. Bu bilgiler, algoritmanın bu görevi açısından gereksiz girdilerdir. Gerekli veriyi seçmek, algoritmanın daha açık ve daha kolay sınanabilir olmasını sağlar.

Girdinin sınırlarını da başlangıçta düşünmek gerekir. Sayı hiç verilmezse ne yapılacak, değer negatif olabilir mi, metin boş bırakılabilir mi veya bir seçenek beklenen değerlerin dışında olabilir mi? Eksik ve geçersiz girdiler, işlem adımlarının değişmesine neden olabilir. Sınırdaki girdiler de aynı şekilde önemlidir. Örneğin sıfıra bölme ihtimali varsa işlem sırasına kontrol eklemek gerekir. Bu nedenle her problemde üç kutuyu doldurduktan sonra şu ek soruyu sorabilirsin: Bu kutuya beklenmeyen bir veri gelirse algoritma nasıl davranmalı?

İşlem adımlarının sırası, karar ve tekrar yapıları

Bir algoritmada önce hangi verilerin geldiği, sonra bu veriler üzerinde hangi işlemlerin yapılacağı, son olarak da hangi sonucun üretileceği belirlenir. İşlem adımları, girdiden çıktıya doğru doğal bir sıra izlemelidir. Önce hazırlık yapılır, ardından karşılaştırma veya hesaplama gerçekleştirilir ve sonuç ekrana yazdırılır.

Her adımı yazmadan önce şu üç kutulu yaklaşımı kullanabilirsin:

• Girdi kutusu: Algoritmanın kullanacağı bilgi nedir? Sayılar, metinler veya kullanıcıdan alınan başka veriler burada belirlenir.
• İşlem kutusu: Girdide ne değişecek? Toplama, karşılaştırma, sıralama ya da bir koşulu kontrol etme gibi işlemler bu bölümde yer alır.
• Çıktı kutusu: İşlemlerin sonunda ne dönecek? Ekrana yazdırılacak değer veya kullanıcıya verilecek mesaj açıkça belirtilir.

Örneğin bir sayının pozitif olup olmadığını kontrol eden algoritmada önce sayı alınır, ardından sayı sıfırla karşılaştırılır. Sayı sıfırdan büyükse “pozitif”, değilse farklı bir sonuç üretilir. Buradaki farklı yolları belirleyen adım karar yapısıdır. Sözde kodda bu yapı genellikle “eğer” ve “değilse” ifadeleriyle gösterilir.

Bir işlem birden fazla veri üzerinde uygulanacaksa tekrar yapısı gerekir. Örneğin listedeki her sayıyı incelemek için aynı karşılaştırma adımı listedeki değerler bitene kadar tekrarlanır. Tekrarın ne zaman başlayacağı ve hangi koşulda biteceği belirtilmezse algoritma eksik kalır.

İşlem adımlarını sadeleştirmek için her adıma şu soruyu sor: Bu adım çıktının oluşmasına nasıl katkı sağlıyor? Çıktıyı değiştirmeyen, aynı kontrolü yeniden yapan veya başka bir adım tarafından zaten gerçekleştirilen işlemler çıkarılabilir. Bu kontrolü algoritmik düşünme bilgi testleri ile farklı problem türleri üzerinde de uygulayabilirsin.

Örnek: En büyük sayıyı bulma algoritması

Problem: Bir sayı listesinde bulunan en büyük değeri bul ve sonucu göster.

Problemi üç parçaya ayıralım:

• Girdi: Bir veya daha fazla sayıdan oluşan liste.
• İşlem: İlk sayıyı geçici olarak en büyük kabul et, diğer sayılarla karşılaştır ve daha büyük bir değer bulursan kaydı güncelle.
• Çıktı: Listedeki en büyük sayı.

Adım akışı şöyledir:

1. Listenin boş olup olmadığını kontrol et.
2. Liste boş değilse ilk sayıyı geçici en büyük değer olarak belirle.
3. Kalan sayıları sırayla incele.
4. İncelenen sayı mevcut en büyük değerden büyükse en büyük değeri güncelle.
5. Listenin sonunda en büyük değeri yazdır.

Sözde kod:

Başla
Eğer liste boşsa "Liste boş" yazdır
Değilse:
    en_buyuk = listenin ilk elemanı
    Listedeki kalan sayıları sırayla incele
    Eğer sayı en_buyuk değerinden büyükse en_buyuk değerini güncelle
    en_buyuk değerini yazdır
Bitir

Aynı mantığın Python uygulaması:

sayilar = [12, 7, 19, 4, 19]

if not sayilar:
    print("Liste boş.")
else:
    en_buyuk = sayilar[0]

    for sayi in sayilar[1:]:
        if sayi > en_buyuk:
            en_buyuk = sayi

    print(f"En büyük sayı: {en_buyuk}")

Program ilk sayıyı başlangıç değeri olarak alır ve listedeki diğer sayıları tek tek karşılaştırır. Eşit bir sayı geldiğinde yalnızca daha büyük değerler kabul edildiği için mevcut değer değiştirilmez.

Beklenen çıktı:

En büyük sayı: 19

Sınır durumlarını da kontrol etmelisin: Boş listede program uygun bir mesaj vermeli, tek elemanlı listede o eleman sonuç olarak dönmeli, eşit en büyük değerlerin bulunduğu listede ise en büyük değer doğru biçimde korunmalıdır.

Algoritmayı sınamak için son kontrol listesi

Bir algoritmayı tamamladıktan sonra doğrudan kod yazmak yerine onu üç kutulu bir karar çerçevesiyle kontrol et: Girdi ne geliyor, işlem ne değişiyor, çıktı ne dönüyor? Bu üç soruya açık cevap veremiyorsan algoritmanın bir adımı eksik veya belirsiz olabilir.

• Girdi kutusu: Problemde verilen tüm bilgiler algoritmaya aktarılıyor mu? Sayı, metin, liste veya başka bir veri eksik bırakılmış mı?
• İşlem kutusu: Veriler doğru sırayla işleniyor mu? Karşılaştırma, hesaplama ve karar adımları amaca uygun mu?
• Çıktı kutusu: Sonuç açıkça tanımlanmış mı? Algoritma hangi değeri, hangi biçimde ve hangi koşulda döndürüyor?

Bu kontrolün ardından sınır durumlarını dene. Girdi hiç gelmezse ne olacak? Geçersiz bir değer verilirse algoritma bunu fark ediyor mu? En küçük veya en büyük kabul edilebilir değer kullanıldığında sonuç doğru mu? Aynı değer birden fazla kez tekrarlandığında işlem beklenen şekilde devam ediyor mu? Örneğin en büyük sayıyı bulma algoritmasında tüm sayıların eşit olduğu bir liste, tek elemanlı bir liste ve negatif sayılardan oluşan bir liste ayrı ayrı denenebilir.

Algoritmayı sınamanın pratik bir yolu, adımları elle izlemektir. Örnek olarak [7, 2, 9] verisini kullan ve her adımda mevcut en büyük değeri not et. İlk değeri geçici en büyük kabul ediyorsan başlangıç durumu 7 olur. Sonraki değer olan 2 karşılaştırılır ve 7 korunur. 9 geldiğinde geçici değer güncellenir. Beklenen çıktı 9 ise gerçek sonuçla bunu karşılaştır. Fark oluşuyorsa hangi adımda ayrıştığını belirle.

Elle izleme sırasında gereksiz adımları da ayıkla. Sonucu değiştirmeyen bir karşılaştırma, aynı veriyi tekrar tekrar işleyen bir adım veya çıktı üzerinde etkisi olmayan bir işlem varsa algoritmayı sadeleştirmeyi değerlendir. Bu yöntem, yalnızca kod hatalarını değil, problem çözme sırasındaki gereksiz karmaşıklığı da görünür hâle getirir.

Algoritmik düşünme becerilerini farklı problem türleriyle sınamak için algoritmik düşünme bilgi testi gibi dilden bağımsız bir alıştırmadan yararlanabilirsin. Her sorudan sonra aynı üç kutuya dön: Girdi doğru mu, işlem sırası tutarlı mı, çıktı ölçülebilir mi?

Sık Sorulan Sorular

Girdi ile çıktı arasındaki temel fark nedir?

Girdi, algoritmanın işlemeye başladığı veridir. Çıktı ise bu veriler üzerinde yapılan işlemler sonucunda elde edilen bilgidir. Örneğin sayılar girdi, bu sayılar arasındaki en büyük değer çıktı olabilir.

Her algoritmada karar ve tekrar adımı bulunur mu?

Hayır. Bazı algoritmalar yalnızca sıralı işlemlerden oluşur. Karar adımı bir koşula göre farklı yol seçmek, tekrar adımı ise bir işlemi birden fazla kez uygulamak gerektiğinde kullanılır.

Eksik veya geçersiz bir girdi algoritmada nasıl ele alınır?

Algoritma önce girdiyi kontrol edebilir. Girdi eksikse kullanıcıdan yeni bilgi isteyebilir, geçersizse uygun bir uyarı verebilir veya işlemi güvenli biçimde sonlandırabilir. Hangi seçeneğin kullanılacağı problemin kurallarına bağlıdır.

Bir algoritmanın doğru işlem sırasına sahip olduğu nasıl kontrol edilir?

Adımları küçük bir örnek veriyle baştan sona elle izle. Her adımın ara sonucunu not et ve sonunda elde ettiğin gerçek çıktıyı beklenen çıktıyla karşılaştır. Fark varsa hatanın oluştuğu ilk adımı bulup işlem sırasını yeniden değerlendir.

Girdi, işlem ve çıktı ayrımını her problemde yeniden kontrol etmek, algoritmayı koddan önce anlaşılır ve sınanabilir hâle getirir.