Hayatımızın her alanında problemlerle karşılaşıyoruz ve bildiğimiz gibi bu konuları çözümleme üstüne odaklanıyoruz. Bilgisayar alanındaki programlama dilleri de aslında bizim ürettiğimiz belli bir mantık içinde görevini yerine getirmek üzere tasarlanmıştır. Yemek, içmek gibi her an farkında olmadan çözmeye çalıştığımız problemlerin karşılıklarını C algoritmaları içerisinde de buluyoruz. Ürettiğimiz çözüm algoritmalarının kaynak kodunu derlemek ve çalışır bir program haline getirmek de, bir mantık çerçevesi içinde, başlama ve bitiş sürecinin arasında kalmış bir evreden ibaret. İlk önce isterseniz basit birkaç algoritma ve çözüm yolları düşünelim ve bunların hangi evrelerden en iyi çözüme gittiğini görelim. Örneğin, çalışan bir saat yapmak istesek, gün, saat, dakika ve saniye cinsinden 4 adet döngüyle kontrol sağlamamız gerekecekti. Fakat bu algoritmayı sadece 1 adet döngü kullanarak da nasıl çözüme ulaşabileceğimizi göstermeye çalışacağım. Çalışan saat örneğimiz ;

int main()
{
     int i,j= 0,x= 0,z=0;
     for(i = 0;i < 61; i++) {
         delay(500);
         if(i > 59) { 
             j++;
             i=0;
             delay(1000);
         }
         if(j > 59){
              x++; 
              j=0;
             delay(1000);
         }
         if(x > 23){
             z++;
             z=0;
             delay(1000);
        }
         printf("%d gun %d saat %d dakika %d saniye\r",z,x,j,i); 
    }
    return 0;
}

Örneğimizde de gördüğünüz gibi; iç içe döngülerle uğraşmak yerine bir adet for döngüsüyle çözüme ulaştık. Bu uygulamamızı, programınızın ne kadar zamandır çalıştığını öğrenmek içinde kullanabilirsiniz. Küçük örneklerle size algoritmaları anlatmaya çalışacağım. Gördüğünüz gibi algoritma kurulamazsa programdan bahsedemeyiz. Kod yazmak bir sanattır ama şu da unutulmaması gerekir ki algoritma yani çözücülük sanatı kod yazma sanatının lokomotifidir. Karmaşık yollardan çözüme ulaşan bir algoritmanın kodu da karmaşık olacaktır. Unutmayalım ki, programlama sanatı hem algoritmayı hem de kodu kapsayan bir birlikteliktir. Bunun da en önemli amacı programın anlaşılabilir ve taşınabilir olmasıdır. Girişimizi yaptıktan sonra ana konumuza yavaş yavaş değinelim bir problem düşünelim ve bunun yapım aşamalarını ortaya çıkartalım. Problemimiz şu olsun: Bir satranç tahtasında aletlerimizi (şah , at, fil vb.), nereye koyarsak koyalım yapabileceği bütün hamleleri bize gösterebilen bir o kadarda yararlı bir uygulama geliştirelim. Bu uygulamamızın adı (programımızın bir adı olmalı değil mi?), hamle v0.9 olsun.İlk öncelikle include’larımızı ve global değişkenlerimizi koyalım;#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define alet tahtagor(tahta)int satir, sutun;
int tahta[8][8]={0};Burada tahta dizimiz, satranç tahtamızı temsil etmektedir(8x8’liktir lakin dizilerin 0’ıncı indis’den başladığını unutmayalım). Satir ve sutun ise tahtamızın bizim oluşturduğumuz, sanal olarak x ve y koordinatlarına böldüğümüz matrisimizin istediğimiz alanına ulaşmakta kullandığımız değişkenlerimizdir.Burada bütün taşların mantığı belli bir kalıba oturduğu için her taşımızı çözümlemek yerine önce at aletimizi çözümlemeyi uygun bulduk yazımızın altında uygulamanın çalıştırılabilir programını bulabilirsiniz.At fonksiyonumu;

void at(int n, int m)
{
    int ilk,son,z;
    int kadir[8][2]={{-2,-1},{-2,1},{2,-1},{2,1},{1,-2},{1,2},{-1,-2},{-1,2}};
   
    for(z=0;z<8;z++){
        ilk = kadir[z][0];
        son = kadir[z][1];
        kolaylik(n,m,ilk,son);
    }
}   

Gördüğünüz gibi bir at fonksiyonu yazdık burada dikkat edilmesi gereken yer kadir dizimiz olacaktır. Kadir dizimizde bir atın gidebileceği yerleri tanımlamış bulunuyoruz. Bir at aleti L şeklinde gideceği için 2 ve 1 rakamları bizim sihirli sayılarımızdır. Bunların oluşturduğu kombinasyonlar, kadir dizinini çok değerli bir hale getirmektedir. Sizde bir satranç tahtasında bu rakamları kullanarak gidebileceği bütün yerleri görebilirsiniz(algoritmanın burada işi nasıl bitirdiğini görebilirsiniz acaba beynimizde 0 ve 1’lerdenmi oluşuyor ;) ). Unutulmaması gereken bir diğer husus ise döngümüzün 8 defa döndüğüdür. At’ımızın gidebileceği maksimum yer sayısı 8’dir. Aynı anda ilk ve son değişkenlerimize x ve y koordinatlarını bildiriyoruz. At fonksiyonumuzun aldığı iki tamsayı parametre ise geldiği gibi fonksiyonun içinden kolaylik fonksiyonumuza geçiyor. İsterseniz kolaylik fonksiyonumuzu inceleyelim(nede olsa C bir fonksiyonlar dili bunu sonuna kadar kullanabiliriz).

void kolaylik(int re, int ke, int z, int l)
{
    int x,y;
   
    system("cls");
    re += z;
    ke += l;
    for(x= 0,y = 0;x < 8, y < 8; x++,y++) {
        if(re > x || ke > y || re < 0 || ke < 0) { }
        else{
            gecerli(re, ke);
        }
    }
}

Kolaylik fonksiyonumuz, 4 parametre almaktadır. Unutmayalım At fonksiyonundan aldığı n,m ve ilk,son değişkenleri ile işlem yapmaktadır. Dizimizin taşmaması ve saçmalamasını önlemek için for döngümüzü işe getirdik eğer taşıyorsa veya saçmalıyorsa da hiçbir şey yapmadan o pozisyonu if deyimimizde pas geçiyor. Eğer bir sorun yoksa gecerli() fonksiyonumuz işletiliyor. Unutulmaması gereken at fonksiyonumuzun aldığı iki parametre değişkeni, at fonksiyonumuz içindeki ve kadir değişkeninden aldığımız değerle toplanıyor.İsterseniz şimdide gecerli() fonksiyonumuzu inceleyelim (fonksiyonların bizi nereye götüreceği belli olmuyor ).İşte geçerli fonksiyonumuz;

void gecerli(int x, int y)
{
    tahta[x][y]=2;
}

Sadece tahtamızdaki hamleleri işliyor. Basit ama o kadarda işin özünü anlatan bir fonksiyon diyebiliriz.Ve uygulamamız da satranç tahtamızı görmek için yazdığım bir fonksiyon;

void tahtagor(int dizi[][8])
{
    int k,l;
    printf("\n\n");
    for(k=0;k<8;k++){
         for(l=0;l<8;l++){
             printf("\t%d",dizi[k][l]);
        }
        printf("\n\n\n\n");
    }
}

Bu kısmı anlatmama gerek yok sanıyorum basitçe dizinin her elemanını bir matris şeklinde yazdırıyor.Evet, işin zor kısmını atlattık bundan sonraki bölümler ince ve dikkat edilmesi gereken noktalar.

void warning()
{
    printf("Ornek 4 5 !!!");
    scanf("%d%d",&satir,&sutun);
    system("CLS");
    satir--;
    sutun--;
    tahta[satir][sutun]=1;
}

Burada satir ve sutun değişkenlerimizi okuyoruz ve 1 azaltıyoruz malum dizilerin güzelliklerinden dolayı.Algoritmalar daha çok bizim atı nasıl işletebileceğimiz kısmında ortaya çıkıyor. Benim yazdığım aletin bütün hamleleri, adlı uygulamanın bu konuda en iyi algoritma olduğunu savunmuyorum, çünkü daha çok çözüm yolları olabildiği gibi daha iyisi ve daha kötüsüde olabilir. main ve hikaye isimli son fonksiyonumuzu da verelim.

int main()
{
    int a;

    hikaye();
    scanf("%d",&a);
    if(a == 1) {
        printf("At’in Konumunu Giriniz");
        warning();
        at(satir, sutun);
    }
    else if(a == 2){
        printf("Fil’in Konumunu Giriniz");
        warning();
        fil(satir, sutun);
    }
    else if(a == 3){
        printf("Kale’nin Konumunu Giriniz");
        warning();
        kale(satir, sutun);
    }
    else if(a == 4){
        printf("Piyon’un Konumunu Giriniz");
        warning();
        piyon(satir, sutun);
    }
    else if(a == 5){
        printf("Sah’in Konumunu Giriniz");
        warning();
        sah(satir, sutun);
    }
    else if(a == 6){
        printf("Vezir’in Konumunu Giriniz");
        warning();
        vezir(satir, sutun);
    }
    alet;
    getch();
    return 0;
}

 

void hikaye()
{
     system("CLS");
     printf("\n\n\tLutfen Bir Alet Seciniz\n");
     printf("\t1-) At\n\t2-) Fil\n\t3-) Kale \n\t4-) Piyon\n\t5-) Sah\n\t6-) Vezir\n");
     printf("\twritten by Volkan Atasever\t inhoftec@gmail.com\n");
}

Evet, uygulamamız bitti sizde kalan diğer taşları programlarsanız bu uygulamanın bir anlamı olacağı kanısındayım.