Satranç tahtası üzerinde atın L hareketi yaparak 64 kareyi tekrar etmeksizin gezmeyi amaçlayan bir algoritmadır. Aşağıda C++ kodu verilmiştir anlaşılmayan yerleri sorabilirsiniz.

#include<iostream>
using namespace std;

int p[8][8],atama=1;
int seviye=8;
int x,y;
int recursive(int f,int g)
{
    int a=f,b=g;
     int count=0;    
    
     if((a>=0&&b>=0)&&(a<8&&b<8))
     {
     if((a-2>=0&&b+1<=7)&&(p[a-2][b+1]==0))
     count++;
     if((a-2>=0&&b-1<=7)&&(p[a-2][b-1]==0))
     count++;
     if((a-1>=0&&b+2<=7)&&(p[a-1][b+2]==0))
     count++;
     if((a-1>=0&&b-2<=7)&&(p[a-1][b-2]==0))
     count++;
     if((a+2>=0&&b+1<=7&&a+2<=7)&&(p[a+2][b+1]==0))
     count++;
     if((a+1>=0&&b+2<=7&&a+1<=7)&&(p[a+1][b+2]==0))
     count++;
     if((a+1>=0&&b-2<=7&&a+1<=7)&&(p[a+1][b-2]==0))
     count++;
     if((a+2>=0&&b-1<=7&&a+2<=7)&&(p[a+2][b-1]==0))
     count++;
     }
    // a=f,b=g;
     if(count<seviye)
     {
       seviye=count;       
       x=f;
       y=g;     
     }   
}

void appointment(int i,int j)
{     
       int a=i,b=j;
       if(atama<=64)
       {
         if(p[a+2][b-1]==0)
         if(!(a+2<0||a+2>=8))
         if(!(b-1<0||b-1>=8))
         recursive(a+2,b-1);          
         if(p[a+2][b+1]==0)
         if(!(a+2<0||a+2>=8))
         if(!(b+1<0||b+1>=8))         
         recursive(a+2,b+1);
         if(p[a-1][b+2]==0)
         if(!(a-1<0||a-1>=8))
         if(!(b+2<0||b+2>=8)) 
         recursive(a-1,b+2);
         if(p[a+1][b+2]==0)
         if(!(a+1<0||a+1>=8))
         if(!(b+2<0||b+2>=8))
         recursive(a+1,b+2);
         if(p[a-2][b+1]==0)
         if(!(a-2<0||a-2>=8))
         if(!(b+1<0||b+1>=8))
         recursive(a-2,b+1);
         if(p[a-2][b-1]==0)
         if(!(a-2<0||a-2>=8))
         if(!(b-1<0||b-1>=8))
         recursive(a-2,b-1);
         if(p[a+1][b-2]==0)
         if(!(a+1<0||a+1>=8))
         if(!(b-2<0||b-2>=8))
         recursive(a+1,b-2);
         if(p[a-1][b-2]==0)
         if(!(a-1<0||a-1>=8))
         if(!(b-2<0||b-2>=8))
         recursive(a-1,b-2);        

                     
         p[i][j]=atama++;
         seviye=8;
         appointment(x,y);
         }

}

void print()
{
    for(int i=0;i<8;i++)
     {
          cout<<endl; 
          cout<<”      “; 
          for(int j=0;j<8;j++)
          cout<<p[i][j]<<”  “;            
          cout<<endl;       
     }
     cout<<endl<<endl;
}

main()
{
    appointment(7,7);
      print();
system (“pause”);     
}

MEHMET SALİH DEVECİ

YAZILIM MÜHENDİSİ

Reklamlar
yorum
  1. Hasan MANZAK dedi ki:

    Sanırım tek bir çözüm üretmeye odaklanılmış, kodu sağlıklı okuyamadım. Bütün çözümleri bulmaya yönelik nasıl bir çalışma yapılası gerek?

    • YAZILIM UZMANI dedi ki:

      hayır bizim bu çözümümüzde tüm olası değerleri buluyo kısaca başladığı yerden random olarak başlıyo yani dolayısıyla birbiriyle çakışmamak şartıyla her seferinde farklı bir dizim veriyo.Bütün çözümler 92 tane diye biliyorum onuda şöyle buluruz her bulduğumuz değerleri veritabanına kaydederiz gelen değeri karşılaştırırz eğer farklıysa onu da tutarız böylece sonunda tüm sonuçlar bulunmuş olur!!!

  2. Hasan MANZAK dedi ki:

    Tüm sonuçları bulmak için rastgelelik pek sağlıklı olmaz sanırım. En kötü seneryoyu Random ile sürekli aynı yerden başlaması ve sürekli aynı hareketleri yapması olarak değerlendirirsek, sürekli aynı sonucu üreme ihtimali var.

    • YAZILIM UZMANI dedi ki:

      o zaman şu daha sağlıklı bir çözüm olur ilk başladığı yerden itibaren sürekli yer değiştirrerek ilk başladığı konumu değiştiririz böylece her seferinde farklı çözümler sunar yani ilkin atı 0 0 lık yere yerleştirdiysek sonra 0 1 sonra 0 2 den başlayarak yerleştirebiliriz.

  3. Emre ATAR dedi ki:

    Labirent çözüm metoduyla yapılmış(ağaç metoduyla). Sonuç üretilmemesi durumunda bir önceki durumdan çözüm üretilmeye çalışılıyor. Random olarak sonuç verebilmesi zaten tek çözüm üretmediğini tüm çözümleri sıralayabildiğini açıkça gösteriyor. Başlangıç noktası elle seçiliyor mu ona dikkat etmedim. Ufak bir ekleme ile başlangıç noktası elle de seçilebilir. Dediğin gibi sonuçları tutup yalnızca farklı olanları alırsak tüm sonuçları elde edebiliriz. Eline sağlık güzel çalışma.

    • YAZILIM UZMANI dedi ki:

      Aslında burda Farkına varmanızı istediğim farklı bir nokta var ki oda şudur recursive denilen fonksiyonda ben o anda bulunduğum konumun gidebileceği tüm noktalar içerisinden düşük olana gitmesiyle gerçekledim örneğin at 4-4 konumundayken at bilindiği gibi L harfi çizeceğinden 8 durum oluşur bu 8 durum içerisindende herbir kordinatında gidebileceği noktalar var işte onlar içerisinden en az olanı seçip devam ediyoruz!! ilk nokta atama konusunda da randoma göre evet herseferinde farklı bir kordinatla gitmek daha avantajlı olur!!

  4. Hasan MANZAK dedi ki:

    Detaylı olarak üzerinde bir çalışma yapmadım ama bağlı listeyi ağaç yapısına benzeterek tüm sonuçları içeren tek bir yapı elde edilebilir. ( Rastgelelik olmadan 🙂 )

    Bir de dikkat ettim de gerek Salih olsun gerek orda burda bakındığım kadar olsun çözüme gidilirken hedef hep satranç tahtası sınırları ile kalıyor, 8×8… Vezir yerleştirme probleminde de böyle mesela. Satranç tahtasına 8 vezir yerleştirme probleminin çözümleri her tarafta var, NxN e N adet vezir yerleştirme problemini çözemiyor, onu çözebilecek şekilde modifiye edilemiyor. Tahtada at gezdirmek, at yerleştirmek, kale yerleştirmek… 8×8 e bağlı kalmayın, çözümler dinamik olsun 😉 Sınırlarını istersen 8 ver istersen 88… Algoritmanın kurallarından biridir, dikkatinizi çekerim : Genellik.

  5. YAZILIM UZMANI dedi ki:

    Haklısın Hasan hocam ama sanırım Onu Yapmak Çok Zor Olmasa Gerek Çünkü MAntık Aynı Hep Sabit yapılar olmasının nedeni Algoritma kitaplarında öyle gördüğümüz içindir yoksa 8*8 veziri yapan N*N liğide yapar sanırım!!!

  6. Hasan MANZAK dedi ki:

    Bu aralar dinlenme modundayım, çok uzun süre oturamıyorum bilgisayar başında. Biraz toparlayayım kendimi, birkaç örnek ulaştırırım sana 😉 Bir de başka bir yazının altında link vermiştim, Tuğrul Helvacı’nın blogunun adresi. Orayı baştan sona incelemeyi ihmal etme. Faydalı olur senin için 😉

  7. YAZILIM UZMANI dedi ki:

    Beklerim Hocam with the great pleasure:)) Evet verir vermez okudum ama akşam üzeri tam inceleyecem şuan stajdayımda:))

  8. er dedi ki:

    sizin bu çözüm ile at en fazla kaç hamle yapabilir??

  9. ercann dedi ki:

    peki bunun java da yazılmış code var mı? eğer varsa bana mail atabilir mısın

  10. Hakan YÜKSEL dedi ki:

    Bende bu algoritmayı c# ile yazıyorum. Kodları üç şekilde yazdım (doğrusal, recursive , oop).Şunu merak ediyorum; İlk atı koyduğumuz zaman geriye kalan yerleşim ihtimal sayısını bulurken 63′ün faktoriyelini mi almalıyız? ilk hamleyi köşeye koyduğumuz zaman tüm tahta 3-4 saniye içinde doldurulabiliyor ama ortada bir yere koyduğumuz zaman bu süre çok uzuyor.

    • Hasan MANZAK dedi ki:

      Eğer işgalleri ekranda bir yerde gösteriyorsanız pencere mesajlarının işlenmesi çok büyük vakit kaybettirir. O yüzden tahtayı işgal ettirirken ekranda güncellemeler yaptırmayın, sonucu yakalamaya çalışın. Bir de 2 algoritmik yaklaşımı (Lineer ve Recursive) birleştirip implemente ederseniz tüm sonuçları ayrı ayrı üretebilecek genel bir algoritma çıkartmış olursunuz. Ayrıca Wave algoritmalarına da şöyle bir göz atmanızı tavsiye ediyorum.

Bir Cevap Yazın

Aşağıya bilgilerinizi girin veya oturum açmak için bir simgeye tıklayın:

WordPress.com Logosu

WordPress.com hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Twitter resmi

Twitter hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Facebook fotoğrafı

Facebook hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Google+ fotoğrafı

Google+ hesabınızı kullanarak yorum yapıyorsunuz. Çıkış  Yap / Değiştir )

Connecting to %s