ATIN SATRANÇ TAHTASI ÜZERİNDE Kİ 64 HAREKETİ

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İ

16 thoughts on “ATIN SATRANÇ TAHTASI ÜZERİNDE Kİ 64 HAREKETİ

  • July 16, 2010 at 12:21 am
    Permalink

    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?

    Reply
    • July 16, 2010 at 8:45 am
      Permalink

      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!!!

      Reply
  • July 16, 2010 at 12:05 pm
    Permalink

    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.

    Reply
    • July 16, 2010 at 12:08 pm
      Permalink

      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.

      Reply
  • July 27, 2010 at 5:05 pm
    Permalink

    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.

    Reply
    • July 27, 2010 at 9:14 pm
      Permalink

      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!!

      Reply
  • July 30, 2010 at 12:08 am
    Permalink

    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.

    Reply
  • July 30, 2010 at 9:02 am
    Permalink

    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!!!

    Reply
  • July 30, 2010 at 10:24 am
    Permalink

    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 😉

    Reply
  • July 30, 2010 at 10:45 am
    Permalink

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

    Reply
  • May 25, 2012 at 9:02 am
    Permalink

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

    Reply
    • May 29, 2012 at 11:12 am
      Permalink

      hatırladığım kadarıyla 92 farklı hamle yapabiliyor…

      Reply
  • May 25, 2012 at 9:45 am
    Permalink

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

    Reply
    • May 29, 2012 at 11:12 am
      Permalink

      Java Kodu yok maalesef C++ kodunuda artık sen Javaya Çevirecen…

      Reply
  • July 25, 2013 at 9:20 pm
    Permalink

    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.

    Reply
    • October 7, 2013 at 9:30 am
      Permalink

      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.

      Reply

Leave a Reply

Your email address will not be published. Required fields are marked *