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 ?

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

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

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Yorumlar için teşekkürler. :)

Alıntı (canalpay):

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

Alıntı:

Ç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! :)

Alıntı:

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

Alıntı:

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

Alıntı:
>
> Ben yapmış olsaydım:
>

return true;

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.

Alıntı:

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.

Alıntı:

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ı?

Alıntı:

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

Alıntı:

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

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

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 gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bu programı Google Code'a koydum:

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

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ali hocam Google code biraz ayarla çalıştı(Aslında içindeki try catch kısmını silmeden çalışmadı onları sildim ve çalıştı) ancak diğeri yani üstte kodlarını paylaştığınız ve SüperZekaOyunu sınıfı içine aldığınız kodlar çalışmadı.. sanırım cstream ile ilgili bir hata veriyor. cstream ne işe yaradığını bilmediğim için sorma gereği duydum.. her iki programı kıysalamak için bu kodu da çalıştırmak istiyorum açıkçası..

'c@C:~/programlama/sayi_bul$ dmd main.d
main.d(2): Error: module cstream is in file 'std/cstream.d' which cannot be read
import path[0] = /usr/include/dmd/phobos
import path[1] = /usr/include/dmd/druntime/import
c@C:~/programlama/sayi_bul$ '

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Kod o kadar eski olunca dildeki değişiklikler nedeniyle geride kalabiliyor. try-catch'teki hata şuymuş: artık catch'ten sonra parantez içinde hata türünü bildirmek şart olmuş. Düzelttim:

https://bitbucket.org/acehreli/super-zeka/commits/80f23f47d76606e3f337fa72b7b0ff59d3de13b6

Bu konunun #4 numaralı yorumuna kopyalamış olduğum programı da derlenir hale getirdim ama daha fazla düzeltmeyeceğim: :)

• cstream'i ben bile unutmuşum: D'nin standart giriş ve çıkış akımlarının din ve dout isminde olanları da vardı. Artık stdin ve stdout kullanıyoruz. 'import cstream' satırını çıkarttım.

// import std.cstream;

• repeat std.algorithm'den std.range'e geçirilmiş olmalı... std.range'i de ekledim:

import std.range;

• toString işlevini şöyle değiştirdim ama sonuçtan memnun değilim ama dediğim gibi, daha fazla uğraşmayacağım. :)

     return format!"%-(%s%)%-(%s%)"(repeat("+", yeriDeDoğru), repeat("-", rakamıDoğru));
       // return repeat("+", yeriDeDoğru) ~ repeat("-", rakamıDoğru);

• Standart girişten okuma satırını değiştirdim:

           // din.readf(&okunan);
           okunan = readln.strip().dup;

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]