Forum: D Programlama Dili RSS
Süper zeka oyunu
acehreli (Moderatör) #1
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Konu adı: Süper zeka oyunu
Bu oyuna herhalde "sayı bulmaca" da deniyordur. İngilizce'deki "master mind" oyunu... Herkes biliyordur ama özetliyorum.

Bilgisayar 4 haneli bir sayı tutuyor, oyuncu da o sayıyı bulmaya çalışıyor. Sayıda rakam tekrarı yok. Hem rakam doğruysa hem de doğru yerdeyse bir tane '+' karakteri gösteriliyor. Rakam doğruysa, ama yeri yanlışsa '-' karakteri gösteriliyor.

Örneğin bilgisayarın tuttuğu sayı 0123 ise ve oyuncu 4132 girmişse, bilgisayar yeri de doğru olan 1 için '+', yerleri yanlış olan 2 ve 3 için '--' gösteriyor.

Bilgisayar, '+' ve '-'lerin hangi haneler için olduğunu söylemiyor.

Programa bir hile yerleştirdim: Tahmin sırasında "?" girilirse hangi sayıyı tuttuğunu gösteriyor ve sonlanıyor.

Programı tamamen yapısal programlamaya uygun olarak yazdım. İçinde hiç nesne yönelimli yöntemler yok. Belki sonra öyle de yazarız...

Bazıları gereksiz olsa da bol bol in, out, ve unittest blokları kullandım. Phobos'tan şu işlevleri kullandım:

- randomShuffle: kendisine verilen aralığı rastgele karıştırır

- repeat: birinci parametresi olan dizgiyi ikinci parametresi kadar tekrarlar

- std.algorithm.find: birinci parametresi içinde ikinci parametresini arar; dönüş değeri, bulduğu noktadan sona kadar olan bir aralıktır. Örneğin find("abcxyz", "c")'nin sonucu "cxyz"dir.

import std.stdio;
import std.cstream;
import std.random;
import std.algorithm;
import std.string;
 
// std.string.find ile karışmasın diye; hangi 'find'ı
// istediğimizi seçiyoruz
alias std.algorithm.find find;
 
void main(string[] parametreler)
{
    oynat(sayıTut("0123456789", 4));
}
 
char[] sayıTut(in string geçerliRakamlar, in int haneAdedi)
in
{
    assert((haneAdedi >= 1) && (haneAdedi <= geçerliRakamlar.length));
}
out (sonuç)
{
    assert(sonuç.length == haneAdedi);
}
body
{
    char[] rakamlar = geçerliRakamlar.dup;
    randomShuffle(rakamlar);
    return rakamlar[0..haneAdedi];
}
 
struct TahminSonucu
{
    int yeriDeDoğru;    // hem rakamı hem de hanesi doğru olanların adedi
    int rakamıDoğru;    // rakamı doğru ama yeri yanlış olanların adedi
 
    string toString() const
    {
        return repeat("+", yeriDeDoğru) ~ repeat("-", rakamıDoğru);
    }
}
 
void oynat(in char[] tutulan)
in
{
    assert(tutulan.length > 0);
}
body
{
    // Çıktıda belirli bir düzene uyulsun diye, hamle sayısını gösteren düzeni
    // tek bir yerde tanımlıyoruz
    static const string hamleDüzeni = "% 3s: ";
 
    // Tutulanı gizli olarak '#' karakterleri ile gösteriyoruz
    writeln(format(hamleDüzeni, " "), repeat("#", tutulan.length));
 
    auto sonuç = TahminSonucu(0, 0);
 
    for (int hamle = 1; sonuç.yeriDeDoğru != tutulan.length; ++hamle) {
        string satırBaşı = format(hamleDüzeni, hamle);
        sonuç = karşılaştır(tutulan, tahminiOku(satırBaşı, tutulan));
        writeln(satırBaşı, repeat(" ", tutulan.length), sonuç);
    }
}
 
char[] tahminiOku(in char[] satırBaşı, in char[] tutulan)
in
{
    assert(tutulan.length > 0);
}
out (sonuç)
{
    assert(sonuç.length == tutulan.length);
}
body
{
    char[] okunan;
 
    do {
        write(satırBaşı);
        din.readf(&okunan);
 
        if (okunan == "?") {
            // Soru işareti girilince tuttuğumuzu gösteriyoruz
            okunan = tutulan.dup;
            writeln(satırBaşı, okunan, " <-- bunu tutmuştum");
        }
    } while (!geçerli_mi(okunan, tutulan.length));
 
    return okunan;
}
 
bool geçerli_mi(in char[] tahmin, in int haneAdedi)
in
{
    assert(haneAdedi > 0);
}
body
{
    return haneAdediDoğru_mu(tahmin, haneAdedi) && tekrarsız_mı(tahmin);
}
unittest
{
    assert(geçerli_mi("012", 3));
    assert(!geçerli_mi("012", 4)); // uzunluğu tutmuyorsa geçersizdir
    assert(!geçerli_mi("011", 3)); // tekrarlıysa geçersizdir
}
 
bool haneAdediDoğru_mu(in char[] tahmin, in int haneAdedi)
in
{
    assert(haneAdedi > 0);
}
body
{
    if (tahmin.length != haneAdedi) {
        writefln("Lütfen %s hane giriniz", haneAdedi);
        return false;
    }
 
    return true;
}
unittest
{
    assert(haneAdediDoğru_mu("79", 2));
    assert(!haneAdediDoğru_mu("79", 1));
}
 
bool tekrarsız_mı(in char[] tahmin)
{
    foreach (i; 0 .. tahmin.length - 1) {
        if (find(tahmin[i + 1 .. $], tahmin[i]) != "") {
            writefln("Aynı rakam kullanılamaz");
            return false;
        }
    }
 
    return true;
}
unittest
{
    assert(tekrarsız_mı("0123456789"));
    assert(!tekrarsız_mı("01234567859"));
}
 
TahminSonucu karşılaştır(in char[] tutulan, in char[] tahmin)
in
{
    assert(tutulan.length == tahmin.length);
}
out (sonuç)
{
    assert(sonuç.yeriDeDoğru >= 0);
    assert(sonuç.rakamıDoğru >= 0);
    assert((sonuç.yeriDeDoğru + sonuç.rakamıDoğru) <= tutulan.length);
}
body
{
    auto sonuç = TahminSonucu(0, 0);
 
    foreach (i, tutulanRakam; tutulan) {
        foreach (j, tahminRakamı; tahmin) {
            if (tutulanRakam == tahminRakamı) {
                if (i == j) {
                    ++sonuç.yeriDeDoğru;
                } else {
                    ++sonuç.rakamıDoğru;
                }
            }
        }
    }
 
    return sonuç;
}
unittest
{
    // Hiç tutmuyor
    assert(karşılaştır("0123", "4567") == TahminSonucu(0, 0));
 
    // Hepsi doğru
    assert(karşılaştır("0123", "0123") == TahminSonucu(4, 0));
 
    // Rakamlar doğru ama hep yanlış hanedeler
    assert(karşılaştır("0123", "1230") == TahminSonucu(0, 4));
 
    // İkisi doğru yerde, ikisi yanlış yerde
    assert(karşılaştır("0123", "0321") == TahminSonucu(2, 2));
}

Ali
canalpay (Moderatör) #2
Kullanıcı başlığı: Can Alpay Çiftçi
Üye Tem 2009 tarihinden beri · 1133 mesaj · Konum: İzmir
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Türkiyede bu oyun bilinmiyor. Yada ben Türkiyede bu oyunun bilindiğini bilmiyorum.

Oyun gerçekten güzel hemde biraz zorluymuş. Zorlanınca 2 haneli şekilde oynayıp 4.de bildim :-)

Kodda anlamadığım hiçbir yer yok ama bin yıl düşünsem aklıma gelirmiydi emin olamadığım şeyler var.
1. Bu kesin aklıma gelmezdi :
bool tekrarsız_mı(in char[] tahmin)
{
    foreach (i; 0 .. tahmin.length - 1) {
        if (find(tahmin[i + 1 .. $], tahmin[i]) != "") {
            writefln("Aynı rakam kullanılamaz");
            return false;
        }
    }
 
    return true;
}

Ben yapmış olsaydım:
bool tekrarsız_mı(in char[] tahmin)
{
    foreach (i; tahmin) {
        if (count(tahmin,i) != 1) {
            writefln("Aynı rakam kullanılamaz");
            return false;
        }
    }
 
    return true;
}
Herhalde benimki sizinkinden daha fazla işletiliyor. 


karşılaştır işlevide çok güzel yazılmış. Herhalde onun en pratik ve hızlı çözümü sizin yazdığınızdır. Çok sevdim bu çözümü.
Düşünsem benim aklıma böyle bir çözüm gelir miydi ? Sanmıyorum. O j==i çözümü asla aklıma gelmezdi.

Kodları okurken fark ettimde, sizce işlevi istediğimiz yerde tanımlayabilmemiz iyi bir şey mi ? Eğer çok işlev tanımladıysak kodu baştan sona okumak yerine ilk işlevin kodunu okuyoruz, ondan sonra ilk işlevde kullanılan diğer işlevin kodunu. O diğer işlevde de kullanılan diğer işlevin kodunu okuyoruz. Kodun bir aşağısına bakıyoruz bir yukarısına. Bu bence okunabilirliği azaltıyor. Ddilindeki kendi projelerimiz için sizce bunu önlemek için bir standart belirleyelim mi ?
acehreli (Moderatör) #3
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Yorumlar için teşekkürler. :)

canalpay:
Türkiyede bu oyun bilinmiyor. Yada ben Türkiyede bu oyunun bilindiğini bilmiyorum.

Küçükken bende İngiltere'den gelmiş Master Mind adında vardı. Rakamlarla değil, renkli plastik düğmelerle oynanıyordu. Sonra Türkiye'de Süper Zeka adıyla da gördüm ve oynadım. :)

Sonra okulda kağıt üzerine yazılarak da oynamıştık. Hey gidi günler... :P

Oyun gerçekten güzel hemde biraz zorluymuş. Zorlanınca 2 haneli şekilde oynayıp 4.de bildim :-)

Çok az hane olunca da ipucu şansı azalıyor. On rakama karşılık 4 hane iyi. Mantık hatası yapılmadığı zaman 5-7 hamlede bulunuyor.

Fikir: Oyun biraz akıllı olabilir ve şöyle önerilerde bulunabilir:

- "ikinci hamlede hiç + vermemiştim, demek ki hiçbir rakamın yeri doğru değildi; ama bak 1'i yine aynı yerde kullandın"
- "üçüncü hamlede hiç + veya - vermemiştim; demek ki onların dördü de yok; ama bak 2'yi yine kullandın"
- vs. :)

Aslında güzel olan, oyunu bilgisayara oynatmak olur. ;) Ben bu programı daha önce Sinclair BASIC, C, ve C++'da da yazmıştım ama hiç bilgisayara oynatmamıştım. Belki Can yapar! :)

Kodda anlamadığım hiçbir yer yok ama bin yıl düşünsem aklıma gelirmiydi emin olamadığım şeyler var.

Aynısı bana da olur. Başkalarının kodlarına bakmak her zaman için yararlıdır.

1. Bu kesin aklıma gelmezdi :
bool tekrarsız_mı(in char[] tahmin)
{
    foreach (i; 0 .. tahmin.length - 1) {
        if (find(tahmin[i + 1 .. $], tahmin[i]) != "") {
            writefln("Aynı rakam kullanılamaz");
            return false;
        }
    }
 
    return true;
}

Aslında onun da bir kütüphane işlevi olmalı ama hızlıca baktığımda görememiştim. Aslında şimdi bakınca, != "" yerine de .length demek biraz daha mantıklı geliyor.

Ben yapmış olsaydım:
bool tekrarsız_mı(in char[] tahmin)
{
    foreach (i; tahmin) {
        if (count(tahmin,i) != 1) {
            writefln("Aynı rakam kullanılamaz");
            return false;
        }
    }
 
    return true;
}
Herhalde benimki sizinkinden daha fazla işletiliyor. 

Bu kadar küçük dizgilerde hiç önemi yok ve ikisi de O(N^2) (N kare) düzeyinde algoritma.

Eğer hiç tekrar yoksa, benimki de seninki de toplam NxN işlem yapmak zorunda.

Eğer tekrar varsa, ve tekrarlanan ilk rakam rastgele bir noktadaysa, ortalama olarak N/2'nci hanede olduğunu varsayabiliriz. Benimki ortalamada NxN/2 işlem yapar, seninki yine NxN.

Algoritma karmaşıklığında çarpanlar atıldığı için, ikisinin de N'e bağlı en büyük terimi N üzeri 2 düzeyindedir. Yani "aynılar" :) ama benimki bazen ortalamada yarısı kadar işlem yapıyor olabilir.

karşılaştır işlevide çok güzel yazılmış. Herhalde onun en pratik ve hızlı çözümü sizin yazdığınızdır. Çok sevdim bu çözümü.
Düşünsem benim aklıma böyle bir çözüm gelir miydi ? Sanmıyorum. O j==i çözümü asla aklıma gelmezdi.

Güzel, güzel! :) Amaç o zaten. Fikir alış verişi olsun... Aslında karşılaştır'ı for döngüsüyle de bir kaç kere yazdım. Sanki bu daha okunaklı oldu.

Kodları okurken fark ettimde, sizce işlevi istediğimiz yerde tanımlayabilmemiz iyi bir şey mi ? Eğer çok işlev tanımladıysak kodu baştan sona okumak yerine ilk işlevin kodunu okuyoruz, ondan sonra ilk işlevde kullanılan diğer işlevin kodunu. O diğer işlevde de kullanılan diğer işlevin kodunu okuyoruz. Kodun bir aşağısına bakıyoruz bir yukarısına.

Bunun iyi bir çözümü yok. Ben C ve C++ programlarında (ve D.ershane'deki örneklerde) main'i en sona yazıyorum. Böylece C ve C++'da işlevlerin ayrıca bildirilmeleri gerekmiyor.

Ama bunun önüne yine de iyi bir şekilde geçilemiyor. Alt düzey işlevlerin yukarıda olmasına çabalarken kod sürekli değiştirilebiliyor. Eskiden aşağıda bulunan bir işlev başa taşınıyor.

Aynı düzeyde bulunan işlevlerin sorunu da ayrı: haneAdediDoğru_mu ve tekrarsız_mı'dan hangisi önce tanımlanmalı?

Bu bence okunabilirliği azaltıyor.

Kabul. Ama öteki türlü olunca da asıl ne olduğunu bilmeden, önce alt düzey işlevleri öğrenmeye başlıyoruz, okuyoruz, okuyoruz, ondan sonra anlıyoruz...

Ddilindeki kendi projelerimiz için sizce bunu önlemek için bir standart belirleyelim mi ?

Gördüğün gibi, ben kararsızım. :) Hangi durumda hangisi mantıklı oluyorsa; kabul...

Ali
acehreli (Moderatör) #4
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Bazı yerleri zorlama oldu ama bir de nesne yönelimli programlama sayılacak şekilde yazdım.

- bütün oyunu SüperZekaOyunu isimli bir sınıf içine aldım

- oyun kurallarıyla ilgili kararları Hakem isimli bir sınıfın görevi haline getirdim. O sınıf, hem girişin yasallığını denetliyor, hem de + - hesaplarını yapıyor

- girişten gelen dizginin geçerlilik koşullarını Denetim'den türeyen bir sıradüzene yaptırdım. Artık önceki programdan bir tane daha fazla denetim var: RakamlarYasal_mı (bu yeni), RakamTekrarsız_mı, HaneAdediDoğru_mu

Ben programın önceki basit halini daha çok beğeniyorum. :D Buradaki nesne yönelimli hali sanki biraz zorlama oldu. Bu kadar küçük bir programda gereksiz gibi geliyor.

Tabii ki yararları da var: Örneğin her denetim kararı kendi küçük sınıfına yaptırılıyor. İleride yeni denetimlerin eklenmesi veya denetimlerin çıkartılması çok kolay olur.

Neyse... :)

import std.stdio;
import std.cstream;
import std.random;
import std.algorithm;
import std.string;
 
// std.string.find ile karışmasın diye; hangi 'find'ı
// istediğimizi seçiyoruz
alias std.algorithm.find find;
 
// Sıradüzenin tepesindeki bu sınıf, yalnızca kullanıcıya bildirilecek olan
// mesajı barındırır
class Denetim
{
    // Denetim geçersiz olduğunda kullanıcıya bildirilen mesaj
    string mesaj_;
 
    this(string mesaj)
    {
        mesaj_ = mesaj;
    }
 
    @property string mesaj() const
    {
        return mesaj_;
    }
 
    // Bu işlevin tanımı, özel denetimlerine bağlı olarak alt sınıflar
    // tarafından yapılır
    abstract bool yasal_mı(string tutulan) const;
}
 
unittest
{
    // Mesajın geri okunabildiğini test edelim
    class Deneme : Denetim
    {
        this()
        {
            super("deneme mesajı");
        }
 
        override bool yasal_mı(string tutulan) const
        {
            return true;
        }
    }
 
    auto denetim = new Deneme;
    assert(denetim.mesaj == "deneme mesajı");
}
 
// Bu, bütün rakamların geçerli olduğunu denetler
class RakamlarYasal_mı : Denetim
{
    string geçerliRakamlar;
 
    this(string geçerliRakamlar)
    {
        super("Geçerli rakamlar: " ~ geçerliRakamlar);
        this.geçerliRakamlar = geçerliRakamlar;
    }
 
    override bool yasal_mı(string tutulan) const
    {
        foreach (tutulanRakam; tutulan) {
            if (find(geçerliRakamlar, tutulanRakam) == "") {
                return false;
            }
        }
 
        return true;
    }
}
 
unittest
{
    Denetim denetim = new RakamlarYasal_mı("abcdefg");
    assert( denetim.yasal_mı("acf"));   // doğru rakamlar
    assert(!denetim.yasal_mı("azg"));   // geçersiz rakam
}
 
class RakamTekrarsız_mı : Denetim
{
    this()
    {
        super("Rakam tekrarlanamaz");
    }
 
    override bool yasal_mı(string tahmin) const
    {
        foreach (i, tahminRakamı; tahmin[0 .. $ - 1]) {
            if (find(tahmin[i + 1 .. $], tahminRakamı).length) {
                return false;
            }
        }
 
        return true;
    }
}
 
unittest
{
    Denetim denetim = new RakamTekrarsız_mı;
    assert( denetim.yasal_mı("aoeuhtsn"));   // tekrar yok
    assert(!denetim.yasal_mı("aoEuhtsEn"))// tekrar var
}
 
class HaneAdediDoğru_mu : Denetim
{
    int haneAdedi;
 
    this(int haneAdedi)
    {
        super(format("Lütfen %s hane giriniz", haneAdedi));
        this.haneAdedi = haneAdedi;
    }
 
    override bool yasal_mı(string tahmin) const
    {
        return tahmin.length == haneAdedi;
    }
}
 
unittest
{
    Denetim denetim = new HaneAdediDoğru_mu(7);
    assert( denetim.yasal_mı("1234567"));    // evet, 7 haneli
    assert(!denetim.yasal_mı("123456"));     // 7 değil
    assert(!denetim.yasal_mı("12345678"));   // 7 değil
}
 
struct TahminSonucu
{
    int yeriDeDoğru;    // hem rakamı hem de hanesi doğru olanların adedi
    int rakamıDoğru;    // rakamı doğru ama yeri yanlış olanların adedi
 
    string toString() const
    {
        return repeat("+", yeriDeDoğru) ~ repeat("-", rakamıDoğru);
    }
}
 
class Hakem
{
    Denetim[] denetimlar;
 
    this(string geçerliRakamlar, int haneAdedi)
    {
        denetimlar ~= new RakamlarYasal_mı(geçerliRakamlar);
        denetimlar ~= new RakamTekrarsız_mı;
        denetimlar ~= new HaneAdediDoğru_mu(haneAdedi);
    }
 
    struct Karar
    {
        bool yasal;
        string[] uyarıMesajları;
    }
 
    Karar yasal_mı(string tahmin) const
    {
        bool yasal = true;       // baştan yasal olduğunu varsayıyoruz
        string[] uyarıMesajları;
 
        foreach (denetim; denetimlar) {
            if (!denetim.yasal_mı(tahmin)) {
                yasal = false;
                uyarıMesajları ~= denetim.mesaj;
            }
        }
 
        return Karar(yasal, uyarıMesajları);
    }
 
    TahminSonucu karşılaştır(in char[] tutulan, in char[] tahmin) const
    in
    {
        assert(tutulan.length == tahmin.length);
    }
    out (sonuç)
    {
        assert(sonuç.yeriDeDoğru >= 0);
        assert(sonuç.rakamıDoğru >= 0);
        assert((sonuç.yeriDeDoğru + sonuç.rakamıDoğru) <= tutulan.length);
    }
    body
    {
        auto sonuç = TahminSonucu(0, 0);
 
        foreach (i, tutulanRakam; tutulan) {
            foreach (j, tahminRakamı; tahmin) {
                if (tutulanRakam == tahminRakamı) {
                    if (i == j) {
                        ++sonuç.yeriDeDoğru;
                    } else {
                        ++sonuç.rakamıDoğru;
                    }
                }
            }
        }
 
        return sonuç;
    }
}
 
unittest
{
    auto hakem = new Hakem("abcdefg", 3);
    Hakem.Karar karar;
 
    // Başlangıçta yasal olmamalı
    assert(!karar.yasal);
 
    // Yasal hamle
    karar = hakem.yasal_mı("abc");
    assert(karar.yasal);
    assert(karar.uyarıMesajları.length == 0);
 
    // Geçersiz rakam
    karar = hakem.yasal_mı("ab3");
    assert(!karar.yasal);
    assert(karar.uyarıMesajları.length == 1);
 
    // Tekrarlı
    karar = hakem.yasal_mı("aba");
    assert(!karar.yasal);
    assert(karar.uyarıMesajları.length == 1);
 
    // Yanlış uzunluk
    karar = hakem.yasal_mı("abcd");
    assert(!karar.yasal);
    assert(karar.uyarıMesajları.length == 1);
 
    // Hepsi yanlış
    karar = hakem.yasal_mı("a7abcd");
    assert(!karar.yasal);
    assert(karar.uyarıMesajları.length == 3);
}
 
class SüperZekaOyunu
{
    string tutulan;   // tuttuğumuz sayı
    Hakem hakem;      // kuralları işleten program mantığı
 
    static const string hamleDüzeni = "%3s: ";
 
    this(in char[] geçerliRakamlar, in int haneAdedi)
    in
    {
        assert((haneAdedi >= 1) && (haneAdedi <= geçerliRakamlar.length));
    }
    out
    {
        assert(tutulan.length == haneAdedi);
    }
    body
    {
        hakem = new Hakem(geçerliRakamlar.idup, haneAdedi);
 
        char[] rakamlar = geçerliRakamlar.dup;
        randomShuffle(rakamlar);
        tutulan = rakamlar[0..haneAdedi].idup;
    }
 
    char[] tahminiOku(in char[] satırBaşı) const
    out (sonuç)
    {
        assert(sonuç.length == tutulan.length);
    }
    body
    {
        char[] okunan;
        Hakem.Karar karar;
 
        do {
            write(satırBaşı);
            din.readf(&okunan);
 
            if (okunan == "?") {
                // Soru işareti girilince tuttuğumuzu gösteriyoruz
                okunan = tutulan.dup;
                writeln(satırBaşı, okunan, " <-- bunu tutmuştum");
            }
 
            karar = hakem.yasal_mı(okunan.idup);
 
            // Aslında bu denetime gerek yok; çünkü karar.yasal olduğunda zaten
            // karar.uyarıMesajları'nın boş olduğunu biliyoruz; döngüyü her
            // durumda işletmenin bir zararı olamaz. Ama yine de daha mantıklı
            // olduğu için bir if deyimi kullanıyoruz. :)
            if (!karar.yasal) {
                foreach (mesaj; karar.uyarıMesajları) {
                    writeln(satırBaşı, mesaj);
                }
            }
        } while (!karar.yasal);
 
        return okunan;
    }
 
    void oynat() const
    {
        // Tutulanı gizli olarak '#' karakterleri ile gösteriyoruz
        writeln(format(hamleDüzeni, " "), repeat("#", tutulan.length));
 
        auto sonuç = TahminSonucu(0, 0);
 
        for (int hamle = 1; sonuç.yeriDeDoğru != tutulan.length; ++hamle) {
            string satırBaşı = format(hamleDüzeni, hamle);
            sonuç = hakem.karşılaştır(tutulan, tahminiOku(satırBaşı));
            writeln(satırBaşı, repeat(" ", tutulan.length), sonuç);
        }
    }
}
 
void main()
{
    auto oyun = new SüperZekaOyunu("0123456789", 4);
    oyun.oynat();
}

Ali
Bu mesaj acehreli tarafından değiştirildi; zaman: 2010-06-10, 01:32.
acehreli (Moderatör) #5
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Bu programı Google Code'a koydum:

  https://code.google.com/p/super-zeka/source/browse/#svn%2F…

Ali
Doğrulama Kodu: VeriCode Lütfen resimde gördüğünüz doğrulama kodunu girin:
İfadeler: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O
Özel Karakterler:
Bağlı değilsiniz. · Şifremi unuttum · ÜYELİK
This board is powered by the Unclassified NewsBoard software, 20100516-dev, © 2003-10 by Yves Goergen
Şu an: 2017-11-19, 08:03:46 (UTC -08:00)