MasterMind nedir? Nasıl oynanır?

Grafik 1. MasterMind oyunu

MasterMind iki kişiyle oynanan bir kod-kırma oyundur. Oyunculardan birisi kod-oluşturucu diğeri ise kod-kırıcıdır. Kod-oluşturucu 6 farklı renkteki mandalı kullanarak 4 adet seçer ve bir kod oluşturur (aynı renk birden fazla kullanılabilr). Kod-kırıcı ise kod-oluşturucunun verdiği ipuçlarını kullanarak bu kodu bulmaya çalışır. Kod-oluşturucu kod-kırıcının doğru yerde ve doğru renkteki her tahmini için tahtada tahminin yapıldığı yerin sağına siyah bir mandal (yukarıdaki resimde turuncu), doğru renkte ancak farklı yerde yer alan her bir tahmin için ise beyaz bir mandal yerleştirir. Mesela, kod-oluşturucunun seçtiği renk kombinasyonu şöyle olsun,

Beyaz | Mavi | Sarı | Kırmızı

Kod-kırıcı ise şöyle bir tahminde bulunsun.

Beyaz | Kırmızı | Pembe | Yeşil

Bu durumda kod-oluşturucu, 1 siyah 1 beyaz mandal ile kod-kırıcıya, yapılan tahminde bir mandalın yerinin de renginin de doğru (Beyaz), bir mandalın ise renginin doğru ancak yerinin yanlış (Kırmızı) olduğu bilgisini verecektir.

MasterMind oyununda  farklı varyasyonlar kullanılabilir elbette. Mesela

-          Aynı renk birden fazla kullanılamaz (bütün mandallar farklı renkte)

-          Aynı renk en fazla iki defa kullanılabilir

-          Aynı renk en fazla 3 defa kullanılabilir

gibi…Bizim burada ele alacağımız MasterMind oyunu sayıların temel alındığı (aynı zamanda, temelde sayılar kullanılarak farklı nesnelerin de yer alabileceği) bir oyun olacak. Ve bütün kod oluşturmak için kullanılan rakamlar en fazla bir defa kullanılabilecektir (sayıların rakamları birbirlerinden farklı).

Kısaca MasterMind oyunu hakkında bilgi verdikten sonra asıl konumuza gelebiliriz.

Biliyorsunuz arkadaşlar bir süredir C# ile kombinasyon, permütasyon hesapları yapmakla meşguldüm. Nedeni ise MasterMind oyununu klasik biçiminden (bilgisayar sayı üretir kullanıcı tahmin etmeye çalışır) daha farklı bir şekilde C# ile yeniden yazmaktı. Farklı olmasını planladığım kısmı, kullanıcıların da bilgisayara karşı bu oyunu oynayabilmelerini sağlamaktı. Yani kullanıcı kafasından bir sayı seçecekti ve bilgisayar da kullanıcının verdiği bilgiler doğrultusunda bu sayıyı bulmaya çalışacaktı. Seneler önce üniversitede iken Pascal programlama dili ile başarmıştım bunu. Çok aradım ama bulamadım yıllar evvel yazdığım bu programcığı, sizinle paylaşmayı çok isterdim.

Pascal ile yazdığım programcık yalnızca 4 basamaklı sayılar için çalışıyordu yani 5, 6, 7 ve daha fazla sayıda basamağı olan sayılar için geçerli değildi. Ve aynı zamanda seçilen sayılar, 0-9 arasındaki rakamlardan oluşuyordu yani sayıların oluşturulduğu rakam havuzu her zaman sabitti. Yazılım dünyasında sabit olan şeyleri pek sevmiyorum, dinamik yapılardan daha fazla keyif alıyorum. Bu nedenle de C# ile yazmayı planladığım MasterMind oyununu da dinamik yapılar üzerine inşa etmeyi planladım hep. Yani sayıların oluşturulacağı rakam havuzu sabit olmayacaktı ve aynı zamanda sayıların basamak sayısı da dinamik olacaktı. Yani isterseniz şöyle diyebilecektiniz, ben 5 basamaklı ve aynı zamanda 0, 7 ve 6 rakamlarının olmadığı sayılarla bu oyunu oynamak istiyorum.  Bu aynı zamanda bana şu esnekliği de sağlıyor olacaktı: oyunu yalnızca sayılarla oynamak zorunda olmayacaktım, istersem rakamları başka nesnelerle ilişkilendirebilir (renk, şekil vs.) böylece oyuna oynanabilirlik adına esneklik kazandırabilecektim. Emin olun bunu başarmak biraz zor! Bu nedenle de yukarıda bahsettiğim gibi son zamanlarda olasılık, permütasyon ve kombinasyon  hesapları ile dolu kafam. Ama sonunda bitirdim…İşte sonuç,

Grafik 2. MasterMind oyunu uygulama ara yüzü

Uygulama İngilizce, uzun süredir bütün uygulamalarımı İngilizce olarak yazdığım için -kodlar dahil-  böyle bir alışkanlık oluştu bende. Türkçe olsa belki benim için bile daha anlaşılır olacak ancak İngilizce yazmaya alışmışım ve sanırım işin doğasının da bu olması gerektiğini düşünüyorum. Ama Türkçe versiyonunun olmasını isterseniz – yorumlarınızda bu konuyu bildirmeniz yeterli- onu da hemen hazırlar paylaşırım.

Sol üstte yer alan “Game Properties – Oyun Özellikleri” bölümü, oyunun temel özelliklerini belirleyebileceğiniz bölümü. En üstte yer alan rakamlar, sayıların oluşturulmasını istediğiniz rakamları gösteriyor. Bu örnekte 0-9 arasındaki bütün rakamlar kullanılabilir durumda gösterilmiş. Kullanılmasını istemediğiniz rakamların işaretlerini kaldırmanız yeterli olacaktır. Aynı şekilde kullanılmasını istediğiniz rakamları da işaretlemeniz gerekecektir. Burada dikkat edilmesi gereken nokta, en az seçilen sayı basamağı kadar rakamın seçilmiş olması. Demek istediğim 4 basamaklı ve rakamları birbirlerinden farklı bir sayıyı 3 adet rakamı kullanarak oluşturamazsınız, bu durumda en az 4 adet rakama ihtiyacınız olacaktır. Merak etmeyin böyle bir ihtimal olduğunda program sizi uyaracaktır.

Yine “Game Properties – Oyun Özellikleri” bölümde yer alan “Length – Uzunluk” seçeneği ile oyunda kullanılacak sayının kaç basamaklı olduğunu belirleyebilirsiniz. “Number – Sayı” bölümü ise, eğer bilgisayar kod-üretici rolünde ise, bilgisayarın ürettiği sayıyı gösteriyor (şifreli şekilde, her bir basamağı * işaretli). Yine bu bölümde yer alan “Com vs Human” seçeneği, kullanıcının kod-oluşturucu, bilgisayarın kod-kırıcı olduğu oyun şeklini (siz kafanızda bir sayı tutarsınız ve bilgisayar sayıyı bulmaya çalışır), “Human vs Com” seçeneği ise bilgisayarın kod-oluşturucu, kullanıcının ise kod-kırıcı olduğu oyun şeklini (bilgisayar bir sayı üretir siz sayıyı tahmin etmeye çalışırsınız) seçmenizi sağlar. Yani oyun tipleri arasında geçiş yapmanıza olanak verir.

Sol altta yer alan “Game Activity- Oyun Faaliyeti” bölümü, oyunun gidişatını gösterir. Oyunun tipi ne olursa olsun bütün tahminler ve yapılan tahminler üzerindeki ip uçlarının tamamı burada kullanıcıya gösterilir. Sol kutucuk tahmin edilen sayıları gösterir. Kod-kırıcının bilgisayar olduğu oyun tipinde bilgisayar her yeni tahmin yaptığında, yeni tahmin otomatik olarak burada yer alacaktır. Kod-kırıcının kullanıcı olduğu oyun tipinde ise, yeni bir tahminde bulunmak için bu kutucuğun üzerinde sağ tıklamanız ve açılan menüden “New Guess” seçeneğini seçerek (ya da basitçe bu kutucuk üzerinde çift tıklayarak) tahmininizi açılan kutuya yazmanız gerekecektir. Sağ taraftaki diğerine göre daha küçük olan kutucuk ise yapılan tahminler ile ilgili doğru ve yanlış bilgilerini verir. Bu bilgiler ışığında da yeni sayı tahminleri yapılır. Oyunda kullanıcının kod-kırıcı olduğu durumlarda (bilgisayara karşı oynanırken), yine bu kısımda (“Game Activity- Oyun Faaliyeti”) yer alan “True – Doğru” ve “False – Yanlış” kutucukları ile bilgisayarın ürettiği tahminlerde yer alan doğru ve yanlış sayılarını bilgisayara bildirmenizi sağlar.

Uygulamada sağ tarafta yer alan 3 kutucuk ise verilen bilgiler doğrultusunda bilgisayar tarafından hesaplanan ihtimaller doğrultusunda üretilen (dolayısıyla bilgisayara karşı oynan oyunlarda) sayıları göstermektedir. En soldaki kutucuk olası sayıları göstermektedir, yani kullanıcı tarafından tutulan sayı mutlaka bu ihtimaller içerisinde yer almaktadır. Ortada yer alan kutucuk, bir önceki tahminde yer alan olası sayıları, en sağdaki kutucuk ise en son verilen bilgiler doğrultusunda üretilen olası sayıları göstermektedir. Basitçe, soldaki kutucuk, sağda yer alan iki kutucuğun kesişimidir aslında -ki bu yöntem bilgisayar tarafından sayının bulunması için kullanılan çok akıllıca bir yapay zeka yöntemidir- böylece bilgisayar verilen bilgileri birbirleri ile ilişkilendirir. Daha açık bir ifade ile, bilgisayar yeni bir tahminde bulunurken yalnızca son tahminde kendisine verilen ip uçlarını değil, o ana kadar verilen bütün ip uçlarını değerlendirir. Üretilen sayıları bir öncekilerle kesiştirmek bunu yapmanın en iyi yoludur.

Gel gelelim MasterMind oyununu bilgisayar karşı oynayabilmenin, daha doğrusu bilgisayarın düşünmesini sağlamanın zorluğuna…İşin zorluğu ihtimalleri hesaplayabilmekte…Matematiksel olarak hesaplamak çok kolay ancak bunu bilgisayara da yaptırabilmek zorlu bir iş. Bu uygulama ile ben bu işi yapabildiğimi düşünüyorum ve bunu da sizinle paylaşmak istedim.

O halde biraz kombinasyon, permütasyon ve olasılık çalışalım…

4 basamaklı bir sayı için, rakamları birbirinden farklı sayılar :

9 * 9 * 8 * 7 = 4.536 adet

ihtimalin olduğunu görürüz. Basamak sayısı arttıkça ihtimaller de artıyor elbette,

5 basamaklı sayılar = 9 * 9 * 8 * 7 * 6 = 27.216 adet

6 basamaklı sayılar = 9 * 9 * 8 * 7 * 6 * 5 = 136.080 adet

7 basamaklı sayılar = 9 * 9 * 8 * 7 * 6 * 5 = 544.320 adet

İhtimalin söz konusu. Bu ihtimaller permütasyon ile basitçe hesaplanabiliyor ancak bizim buradaki durumumuz biraz farklı. Burada doğru ve yanlış bilgilerini de hesaba katmamız gerekiyor. Yani bilgisayar bir sayı tahmin ederken, kullanıcının ona verdiği “tahmin ettiğin sayı içerisinde 2 doğru 1 adet yanlış var” bilgisini de göz önünde bulundurması lazım. Peki bunu nasıl yaptıracağız bilgisayara? Konuyu anlayabilmek için detaylarına inmemiz lazım, inceleyelim….

Örneğin bilgisayarın tahmini

1234

olsun. Kullanıcı da tahminde 2 doğru 1 yanlış olduğunu belirtmiş olsun. İhtimalleri hesaplayalım :

Grafik 3. Seçim ihtimalleri ve olası sayılar

Görüldüğü üzere toplam 12 adet seçim ihtimali var, yani şu rakam doğru yerde-şu rakam yanlış yerde  olursa deme ihtimalimiz 12. Her bir seçim ihtimali sonucunda oluşturulabilecek sayılar da seçimlerin karşısında yer alıyor. Bu sayılar elbette yapılan seçimin sonucunda oluşturuluyorlar. Gelelim bu sonuçların matematiksel ifadesine…

Yapılan tahminde 2 adet doğru rakamımız varsa eğer, bu rakamların ihtimallerini bulmak için kombinasyon almamız yeterli olacaktır. Yani 4’ün (sayımız 4 basamaklı) 2’li kombinasyonu,

4! / (4-2)! * 2! = 6

Yani şu rakam ve şu rakam doğru yerde olsa diyebileceğimiz toplam 6 adet ihtimal var. Buraya kadar sorun yok. Şimdi yanlış yerde olan rakam ihtimalini de hesaba katmamız lazım.

4 basamaklı sayımızda iki rakamı çıkartırsak -çünkü bu iki rakamı doğru olarak işaretledik yukarıda- geriye 2 basamak kalıyor. 2 basamak içerisinden de 1 rakamımız doğru ancak yanlış yerde, bu durumdaki ihtimalleri de bulabilmek için 2’nin 1’li kombinasyonunu hesaplamamız yeterli.

2! / (2-1)! * 1! = 2

Yani yukarıdaki 2 basamağın doğru olması durumunda ortaya çıkan her bir 6 ihtimal için, 2 adet de 1 rakamın yanlış yerde olma ihtimali söz konusu. Dolayısıyla toplam seçim ihtimalimiz,

6 * 2 = 12

adet ihtimalimiz söz konusu. Bu seçim ihtimallerini de zaten yukarıda görüyorsunuz. Aynı sonuca tersten de ulaşmamız mümkün. Yani önce yanlış olan ihtimalleri sonra da doru olabilecek ihtimalleri hesaplayarak (yukarıdaki resimde olduğu gibi). Görelim :

4 basamaklı bir sayıda 1 basamağın yanlış olması durumunda oluşabilecek ihtimaller :

4! / (4-1)! * 1! = 4

4 basamaklı bir sayıdan yanlış olabileceğini düşündüğümüz 1 rakamı çıkardığımızda geriye 3 basamak kalıyor. 3 basamak içerisinden de doğru olabileceğini düşündüğümüz 2 adet rakamı seçmeliyiz. Seçelim :

3! / (3-2)! * 2! = 3

ve toplam seçim ihtimali yine aynı :

4 * 3 = 12

Peki seçim ihtimallerini bulduk. Ve biliyoruz ki bu ihtimallere uyan sayılardan birisi kullanıcının sayısı. Peki ama bu seçim ihtimallerine uyan sayıları nasıl bulacağız? Bunun için bize verilen bilgiler doğrultusunda sayı üreten bir yapı lazım. Büyük resmi yavaş yavaş görmeye başladık, yani uygulamamız şu yapıya uygun bir şekilde çalışmalı –ki emin olun bu şekilde çalışıyor-.

Grafik 4. Uygulamanın çalışma prensibi (sayı : 1234; 2 Doğru, 1 Yanlış)

Sayı üreticisine geçmeden önce şu konu üzerinde durmamız lazım. Yerleri doğru olan rakamlarla ilgili çok sıkıntımız yok, ufak bir kombinasyon hesabı ile işimizi hallettik. Ancak yerleri yanlış olan rakamlar için basit bir kombinasyon almak yetmiyor. Neden? Çünkü kombinasyon ile bu rakam ya da rakamların bulunabileceği yerleri buluyoruz kombinasyonla ancak bize bu rakamların bulunabilecekleri yerler değil, BULUNAMAYACAKLARI yerler gerekli. Çünkü bu rakamların yerleri bize yanlış olarak bildirilmiş zaten yani kombinasyon ile bulduğumuz yerlerde bulunamazlar! Yani bilgisayarın kendisine yanlış olarak bildirilen rakamların olası yanlış yerlerini hesaplayabiliyor olması lazım. Bunun için bulduğum yöntem şöyle, öncelikle rakamların bulunabilecekleri tüm yerleri hesaplıyorum, daha sonra da bu kümeden, rakamların bulunamayacakları ihtimalleri çıkartıyorum. Matematiksel olarak ifade edelim.

Yukarıda Excel tablosunda (Grafik 3) belirtilen ilk seçimi ele alalım, yani 1 rakamı yanlış yerde, 3 ve 4 rakamları doğru yerde olursa,

Öncelikle doğru olan rakamları hesaba katmamız gerekli!  İki rakam (3 ve 4) doğru yerde ise, geriye 2 basamak kalıyor.  Yanlış olan basamağın hangisi (ya da hangileri) olduğu ihtimalleri, 2’nin 1’li kombinasyonudur, yani :

2! / (2-1)! * 1! = 2

Yani yanlış olarak kabul edeceğimiz sayımız ya ilk basamakta ya da ikinci basamakta (3. ve 4. basamaktaki rakamları doğru yerde olarak işaretlemiştik) yer alabilir. Yani ya 1 rakamı yanlış yerdedir, ya da 2 rakamı. 1 rakamının yanlış olması durumunda oluşturulabileceğimiz sayıları,

X134

şeklinde ifade edebiliriz. Burada X olarak işaretlediğimiz basamağa ise 5,6,7,8,9 rakamları gelebilir Sayının basamakları birbirlerinden farklı olmak zorunda olduğu için X basamağına 1,2 ve 3 rakamlarını yerleştiremeyiz ve aynı zamanda bu basamak ilk basamak olduğu için buraya 0 rakamını da yerleştiremeyiz. Sonuçta elde edilen rakamlar,

5134, 6134, 7134, 8134, 9134

olacaktır. Benzer şekilde yanlış rakamın 2 olması durumunda da oluşturabileceğimiz rakamlar,

2X34 = 2034, 2534, 2634, 2734, 2834, 2934

sayıları olacaktır. Burada yukarıdakinden farklı olarak X basamağı ilk basamak olmadığı için buraya 0 rakamını da yerleştirebiliriz. Dolayısıyla üretilebilen sayılar bir öncekinden bir adet fazla yani 6 adettir.

Sonuç olarak bilgisayara doğru olarak bildirilen her bir rakam bir kombinasyon işlemi, yanlış olarak bildirilen her bir rakam ise bir kombinasyon ve her bir kombinasyon için bir permütasyon işlemi gerektirecektir. Bu bilgiler doğrultusunda uygulamamız, 4 basamaklı bir sayı için, 2 doğru ve 1 yanlışın olduğu tüm sayılar,

Grafik 5. Üretilen olası sayılar (Sayı : 9264; 2 doğru, 1 yanlış)

Üretilen sayıların adedini veren bir formül olduğunu düşünmüyorum çünkü üretilen sayılar yapılan seçime göre değişiyorlar ayrıca ilk basmakta 0 rakamının bulunmaması gibi ayrı bir detay da söz konusu. Bunun bir formülü varsa da ben bulamadım henüz. Bu noktada sizin de paylaşımlarınız olursa bana bildirirseniz çok sevinirim gerçekten.

Şimdi de uygulamayı test edelim. Önce 4 basamaklı bir sayı tutalım ve bilgisayar sayımızı bulmaya çalışsın. Sayımız 3589 olsun.

Grafik 6. 3589 sayısı için bilgisayarın tahminleri ve sonucu

Toplam 4 tahminde sayımızı buldu. Ve dikkat ederseniz son verilen bilgi doğrultusunda bilgisayar ihtimaller arasında verilen bilgilere uyan yalnızca bir sayı olması gerektiğine karar vermiş. Ve doğru da vermiş kararını

Son olarak 5 basamaklı bir sayı deneyelim. Sayımız 48207 olsun.

Grafik 6. 48207 sayısı için bilgisayarın tahminleri ve sonucu

Toplam 5 tahmin sonucunda sonuca ulaştı bilgisayar. Gördüğünüz üzere gayet akıllı bilgisayarımız J Ancak şunu da söylemem lazım basamak sayısı arttıkça ve rakamların tümü (0-9 arasında) kullanıldığında yavaş çalışmaya başlıyor. En azından ilk ihtimalleri hesaplarken çünkü çok fazla ihtimal var. 7 basamaklı bir sayı için 2 milyonun üzerinde rakamları birbirinden farklı sayımız söz konusu ve her bir permütasyon ve kombinasyon işleminde bu kadar fazla sayıda ihtimali göz önünde bulundurmak biraz zaman alıyor. Şu an için zaten 7, 8 ve 9 basamaklı sayıları kullanıma kapattım. Hızlı bir yöntem bulursam bu basamakları da kullanıma açacağım.

Bu yazımı da burada noktalamak istiyorum izninizle, saat 02:00’ye yaklaşıyor ve uykum geldi, yazmaktan yoruldum

Buraya kadar eminim merak ettiğiniz bir nokta vardır uygulama ile ilgili! O da ihtimallere uyan sayıları nasıl ürettiğim? Bu da başka bir yazımın konusu olsun. Ama bir ipucu vereyim, sayaçlar…

“MasterMind with C#”

DOWNLOAD (üyelik gerektiriyor, forumuma üye olun lütfen)
http://u2m.me/hh

Bu yazımda C# ile nasıl kombinasyon hesabı yapılabileceğinden bahsetmiştim. C# ile permütasyon hesabı yapan benzer bir sınıfı da oluşturup sizinle paylaşmak istedim. Biliyorsunuz şu aralar C# ile MasterMinde oyunu üzerinde çalışıyorum. Klasik oyundan farklı olarak bilgisayara karşı da oynanabilecek bir versiyon üzerinde çalışıyorum ve hem kombinasyon hem de permütasyon hesaplarına şiddetle ihtiyaç duyuyorum. Bütün bu yazılar da bu ihtiyacın bir sonucu olarak ortaya çıktı zaten. Yakında uygulamayı da buradan paylaşacağım sizinle…

C# ile permütasyon hesabı yapabileceğiniz sınıfımız da aşağıda.

    public class Permutation
    {
        List<string> innerArray_ = new List<string>();
 
        public Permutation()
        {
            this.DigitCount = 0;
            this.Permutations = 0;
            this.UseRepeatation = false;
        }
 
        public bool UseRepeatation { get; set; }
 
        public int DigitCount { get; set; }
 
        public int Permutations { get; set; }
 
        public List<string> GetPermutations()
        {
            if (this.DigitCount > 0 && this.Permutations > 0)
                GetPermutations("");
 
            return this.innerArray_;
        }
 
        public List<string> GetPermutations(int digitcount, int permutations)
        {
            this.DigitCount = digitcount;
            this.Permutations = permutations;
 
            return this.GetPermutations();
        }
 
        private void GetPermutations(string current)
        {
            if (current.Length < this.Permutations)
            {
                for (int i = 0; i < this.DigitCount; i++)
                {
                    if (current.IndexOf(i.ToString()) < 0 || this.UseRepeatation)
                        GetPermutations(current + i.ToString());
                }
            }
            else if (current.Length == this.Permutations)
                this.innerArray_.Add(current);
        }
    }

4 basamaklı bir sayının 2′li kombinasyonlarını (sayı tekrarı olmadan) bulmak için,

Permutation per = new Permutation();
 
List<string> result = per.GetPermutations(4, 2);

4 basamaklı bir sayının 2′li kombinasyonlarını (sayı tekrarı ile) bulmak için,

Permutation per = new Permutation();
per.UseRepeatation = true;
 
List<string> result = per.GetPermutations(4, 2);

Burada da aynen kombinasyon da olduğu gibi dikkat etmeniz gereken nokta, List olarak geri dönen değerler kombinasyonların index değerleri (sayının index değerleri demek daha doğru olur).

İşte C# ile kombinasyon hasabı yapabileceğimiz sınıfımız.

public class Combination
{
    List<string> innerArray_ = new List<string>();
 
    public Combination()
    {
        this.DigitCount = 0;
        this.Combinations = 0;
    }
 
    public int DigitCount { get; set; }
 
    public int Combinations { get; set; }
 
    public List<string> GetCombinations()
    {
        if (DigitCount > 0)
        {
            //for (int i = 0; i < this.DigitCount; i++)
            //    GetCombinations(i.ToString(), i);
 
            GetCombinations("", -1);
        }
 
        return this.innerArray_;
    }
 
    public List<string> GetCombinations(int digitcount, int combinations)
    {
        this.DigitCount = digitcount;
        this.Combinations = combinations;
 
        return this.GetCombinations();
    }
 
    /// <summary>
    /// Kombinasyon hesaplamasını yapar
    /// </summary>
    /// <param name="current">Şu anki işlenen veri</param>
    /// <param name="index">İşlenen veri indexi</param>
    private void GetCombinations(string current, int index)
    {
        string tmpcurrent = "";
 
        for (int i = index + 1; i < this.DigitCount; i++)
        {
            tmpcurrent = current + i.ToString();
 
            GetCombinations(tmpcurrent, i);
        }
 
        if (current.Length == this.Combinations)
            this.innerArray_.Add(current);
    }
}

Şimdi bu sınıfımızı, 5 basamaklı bir sayının 2′li kombinasyonunu hesaplamak üzere şu şekilde kullanabilirsiniz.

 
Combination com = new Combination();
 
List<string> result = com.GetCombinations(5, 2);

Burada dikkat etmeniz gereken nokta, List olarak geri dönen değerler kombinasyonların index değerleri. Örneğin 5′in 2′li kombinasyonlarını bulmak istiyorsunuz (sayımız da 12345 olsun mesela), geri dönen değerlerden birisi de “01″. Bu kombinasyonun değeri aslında “12″, diğer bir kombinasyon değerimiz “13″ ise, asıl değerimiz “24″ olmalı. Bu eşleştirmeyi kendiniz yapmanız gerekecek. Belki MasterMind oyununu bitirdiğimde, bütün kodları paylaşırım sizinle. Böylece Combination sınıfının eksiksiz bir kopyasını siz de kullanabilirsiniz -ben de henüz yazmadım:)-

Şu aralar MasterMind adlı bir oyunla uğraşıyorum. Oyunu bilgisayara karşı da oynayabilmenizi sağlayacak bir yapı üzerinde çalışıyorum. Bu yapının temelinde de olasılık, kombinasyon ve permütasyon hesaplamaları var. Aşağıdaki kod belirlenen basamak sayısına göre sayıların kombinasyonlarını hesaplar.

/// <summary>
/// Kombinasyon hesaplamasını yapar
/// </summary>
/// <param name="current">Şu anki işlenen veri</param>
/// <param name="digitcount">Toplam basamak sayısı</param>
/// <param name="combination">Kombinasyon sayısı (4'ün 2'li kombinasyonu için 2)</param>
/// <param name="index">İşlenen veri indexi</param>
private void GetCombinations(string current, int digitcount, int combination, int index)
{
    for (int i = index + 1; i < digitcount; i++)
    {
        string newcurrent = current + i.ToString();
        GetCombinations(newcurrent, digitcount, combination, i);
    }
 
    if (current.Length == combination)
        Console.WriteLine(current);
}

Sonuçları Console’a yazdırıyor method. Bu metoda çok fazla yoğunlaşamadım ama isterseniz siz bir sınıf oluşturup bu metodu bu sınıf içerisinde gerçekleyebilirsiniz. Combination adlı bir sınıf oluşturup, 4 basamaklı sayıların 2′li kombinasyonlarını hesaplamak için Combination.Calculate(4,2) gibi bir metotla işleminizi yapabilirsiniz (Böyle bir sınıf için lütfen bu http://u2m.me/gX bağlantıyı takip ediniz ). Ama şu anki haliyle, 5 basamaklı sayıların 2′li kombinasyonları için,

1. yol

  for (int i = 0; i < total; i++)
       GetCombinations(i.ToString(), 5,2, i);

2. yol

GetCombinations("", 5, 2, -1);

şeklinde metodu çağırabilirsiniz.

Grafik 1. Java Uygulama Arayüzü

Grafik 2. Sonuçlar (Normal)

Grafik 3. Sonuçlar(Logaritmik)

Grafik 4. P sayısı ve basamak sayısı ilişkisi

Sonuçlar beklendiği gibi…Daha doğrusu beklediğim gibi…Java’da kullanılan Array, ArrayList<int> yapıları C#’taki benzerlerinden daha hızlı…

Ama…

Fortan’dan C# dili gibi Java’da çok yavaş

Fortran bir tarafa, C# mı? (dolayısıyla .NET) Java mı? derseniz eğer…Benim gibi her ikisini de öğrenin derim. Aralarında çok fazla farklılık yok zaten. Ama ille de yok abicim ben birisini seçmek istiyorum derseniz…Tamamen ilgi alanlarınıza göre seçiminizi yapın bence.

Oyun programlama vs. ile uğraşacaksanız kesinlikle Java öğrenin derim…

Orta ölçekli masaüstü yazılımlar yazacağım diyorsanız her ikisi de olabilir, benim tavsiyem .NET

Büyük ölçekli yazılımlar (ERP vs.) yazacağım diyorsanız her iki ortamı da kullanabilirsiniz ama benim tavsiyem Java.

Web uygulamaları geliştireceksiniz tavsiyem .NET (ASP.NET)

Sizlerin de konuyla ilgili düşüncelerinizi öğrenmek isterim, yorumlarınızı bekliyorum.

for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

Yukarıda gördüğünüz C# ile yazılmış basit bir döngü yapısı. 0 ile 9 arasıdaki (0 ve 9

dahil) rakamları ekrana yazdırıyor. Yani tek basamaklı doğal sayıları. Peki 2

basamaklı doğal sayıları nasıl ekrana yazdıracağız? Şöyle,

for (int i = 1; i < 10; i++)
{
    for (int j = 0; j < 10; j++)
    {
        Console.WriteLine(i.ToString() + j.ToString());
    }
}

Peki 3 basamaklı doğal sayıları? (i değişkeninin 1′den başladığına dikkat edin

lütfen)

for (int i = 1; i < 10; i++)
{
    for (int j = 0; j < 10; j++)
    {
        for (int k = 0; k < 10; k++)
        {
            Console.WriteLine(i.ToString() + j.ToString() + k.ToString());
        }
    }
}

Dikkat ederseniz her defasında bir döngü (her basamak için) en içteki döngünün

içerisine ekleniyor. Kısacası herbir basamak için bir döngü…N basamak için iç içe n

döngü…Peki işi biraz daha karışık hale getirirsek?

Yukarıdaki örneklerimizde sayının basamakları birbiri ile aynı olabilir. Peki 3

basamaklı ve basamakları birbirlerinden farklı olan sayıları nasıl bulabiliriz?

for (int i = 1; i < 10; i++)
{
    for (int j = 0; j < 10; j++)
    {
        for (int k = 0; k < 10; k++)
        {
            if (i != j && i != k && j != k)
                Console.WriteLine(i.ToString() + j.ToString() + k.ToString());
        }
    }
}

En içteki döngüye bir koşul ifadesi eklememiz yeterli oldu. Buraya kadar herşey

kolay…

Şimdi olayın zor olan kısmına gelelim. Eğer 1 ile N basamaklı sayıların tamamını elde

etmek istersek ne yapacağız? Bu halde N adet iç içe döngü oluşturmamız

gerekir (dinamik bir döngü)…Ancak bunu bir programlama dili ile yapmak mümkün değildir (en azından

benim bildiklerim ile -ve emin olun çok fazla dil biliyorum-)

Böyle birşey ne işimize yarar peki? Çok işimize yarar…Oyunlarda kullanılabilir,

istatistik ve olasılık hesaplarında kullanılabilir vs. vs.

Neyse sonuca gelelim…

 
private void DynamicNestedLoop(int number, int index)
{
    // get the current digit
    // sayıdan index ile belirtilmiş basamağı al
    int currentdigit = GetDigitAtIndex(number, index);
 
    // if the current digit is 9 than we have to reset the number
    // eğer şu anki basamak 9 ise sayıyı sıfırlamamız gerekiyor
    if (currentdigit < 9)
    {
        // get the new number. for instance if the current number 1000 
        // and index = 3 than new number will be 1001
        // yeni sayıyı al, örneğin şu anki sayımız 100 ise
        // üretilecek yeni sayımız 1001 olacaktır
        int newnumber = ChangeDigitAtIndex(number, index, currentdigit + 1);
 
        Console.WriteLine(newnumber);
 
        // call the method again with the current index
        // metodu mevcut index ile yeniden çağır
        DynamicNestedLoop(newnumber, index);
    }
    else
    {
        // if the current index greater than 0 
        // (it means if we are not dealing with the first digit)
        // eğer şu anki indeximiz 0'dan büyükse
        // yeni sayının ilk basamağı ile uğraşmıyorsak
        if (index > 0)
        {
            // get the previous digit of the number
            // because we will increase it
            // sayının bir önceki basamağını al
            // önceki basamağı arttıracağız çünkü
            int prevdigit = GetDigitAtIndex(number, index - 1);
 
            // if the previous digit is less than 9
            // eğer bir önceki basamağımız 9'dan küçükse
            if (prevdigit < 9)
            {
                // increase the previous digit
                // bir önceki basamağı arttır
                int newnumber = ChangeDigitAtIndex(number, index - 1, prevdigit + 1);
 
                int numberlength = number.ToString().Length;
 
                // reset the number to its minimum value
                // set every digit to zero beginning from the previous index
                // sayıyı bir önceki basamaktan başlayarak sıfırla
                // diğer basamakları sıfırla
                for (int i = numberlength - 1; i > index - 1; i--)
                    newnumber = ChangeDigitAtIndex(newnumber, i, 0);
 
                Console.WriteLine(newnumber);
 
                // call method again from the beginning
                // metodu en başından yeniden çağır
                DynamicNestedLoop(newnumber, numberlength - 1);
            }
            else
            {
                // if previous digit is 9 than look for other digits
                // eğer bir önceki basamak 9 ise diğer basamakları kontol et
                DynamicNestedLoop(number, index - 1);
            }
        }
    }
}

Yukarıdaki kodu kullanarak dinamik iç içe döngüleri kullanarak elde edeceğiniz

sonuçları, recursive metot kullanarak elde edebilirsiniz. Mesela 3 basamaklı tüm sayıları bulmak için metodu,

DynamicNestedLoop(100, 2);

3 basamaklılar için

DynamicNestedLoop(1000, 3);

şeklinde çağırmanız yeterli olacaktır. Dikkat edin ilk parametre seçilen basamak sayısı kullanılarak oluşturulabilen en küçük sayı. İkinci parametre ise sayıyı bir string dizisi olarak düşünürseniz, bu dizinin son elemanına ait indexi. Bütün yorumları Türkçe ve İngilizce olarak ayrı ayrı yazdım. Yorumları dikkatlice okuyun lütfen…

Peki ya sayıları oluşturmak için kullanabileceğimiz rakamlar sınırlı olursa? Yani yalnızca 2,3,7,6,8,0 rakamlarını

kullanarak N basamaklı sayıları (N rakam havuzunun boyutundan küçük olmak kaydıyla) nasıl bulabiliriz?

Bu sorunun yanıtı da bir sonraki yazımda…Umarım…

Sanırım şaşırmadınız…

TC Kimlik Numaralarının algoritmasının çözüldüğünü bir çoğunuz şu veya bu şekilde duymuşsunuzdur. Bu programcık girdiğiniz geçerli bir TC Kimlik numarasını kullanarak binlerce geçerli TC Kimlik numarası üretebiliyor…

Detaylar için,

http://u2m.me/g6

DOWNLOAD (bilgisayarkorsani.com’a üye olmanız gerekiyor!)

http://u2m.me/gd

YASAL UYARI : TC Kimlik No Üretici deneysel amaçlar için hazırlanmıştır ve bu yazılımın kullanımından doğabilecek tüm maddi ve manevi zararlardan yazılım üreticisi değil, yazılımı kullanan şahıslar sorumludur.

http://u2m.me/b!

Bu yazımda DevExpress v2009 Volume 1′i duyurmuşum ancak aradan nerden baksanız 1 yıl geçmiş. Eee linklerin de yenilenmesi lazım haliyle…İşte size DevExpress’in piyasadaki en son sürümü…

DevExpress DXperience Universal 2010.1.5

SEÇENEK 1…

Components/Bileşenler
http://u2m.me/c7

Documentation/Dökümentasyon
http://u2m.me/cc

Localized Assemblies/Yerelleştirilmiş Assembly’ler
http://u2m.me/cb

SEÇENEK 2

DexExpress’in resmi sitesinden DevExpress DXperience Universal 2010.1.5 paketini indirin
http://u2m.me/ce

Aşağıdaki linkten de crack’i indirin
http://u2m.nu/cg

Crack’in uygulayın ve hepsi bu kadar

Oturdunuz, çok heveslisiniz, .NET framework kullanarak şahane bir uygulama yazmaya karar verdiniz. Ama o da ne? ISerializable implement eden bir sınıftan türettiğiniz bir sınıfı Deserialize ederken aşağıdaki problemle karşılaştınız.

“The constructor to deserialize an object of ‘xxx’ was not found”

Ama abi Serialize ederken sorun olmuyo, bu niye böyle yapıyo şimdi? dediğinizi duyar gibiyim :) Bill amcaya yine selamlarınızı mı ilettiniz gizliden gizliden, ya da niye gizli olsun, bağıra bağıra :)

Durun, rahat bir nefes alın, çözüm burda…

Ne geyik yaptım şaka maka Neyse şakayı bir kenara bırakalım arkadaşlar bir süre için. Yukarıda da kısaca bahsettiğim gibi, ISerializable arayüzünü implement eden bir sınıftan türettiğiniz bir sınıfı deserialize ederken yukarıdaki hatayı almanız muhtemel. Bu sorunun nedeni ise ISerializable arayüzünü gerçekleyen bir sınıftan türettiğiniz bir sınıf, ISerializable metotlarını da gerçeklemelidir (serialization ve deserialization işlemleri için ayrı ayrı). Siz büyük ihtimalle bu kısmı atladınız, es geçtiniz ya da bilmiyorsunuz.

Örnek verelim,

[Serializable]
class Test: Hashtable
{
public Test()
{
}
}
gibi bir sınıf oluşturdunuz. Görüldüğü üzere bu sınıf ISerializable arayüzünü gerçekleyen Hashtable sınıfından türetilmiş. İşte bu “Test” adlı sınıfımızı deserialize işlemine tabi tuttuğumuzda yukarıdaki hatayı alacağız. Bu hatayı engellemek için ise ISerializable arayüzüne ait,

protected Test(SerializationInfo info, StreamingContext context) : base(info, context) { }

constructor ını da gerçeklemeniz gerekmektedir. Yukarıdaki sınıfa bu constructor da eklenirse yukarıdaki hatanın oluşması engellenmiş olur çünkü bu constructor, ilgili sınıfın deserialization işleminde kullanılır.

Son bir not daha düşelim, eğer serialize etmek istediğiniz ek veriler varsa, ISerializable arayüzüne ait GetObjectData() metodunu da gerçeklemeniz gerekiyor arkadaşlar. Benden söylemesi…

Cross-thread operation not valid: Control ‘xxxxx’ accessed from a thread other than the thread it was created on.

Bu istisnai durum herhangi bir kontrole ya da kontrolün özelliklerine, kontrolün oluşturulduğu Thread dışında farklı bir Thread üzerinden erişmeye çalışıldığında ortaya çıkıyor. Dolayısıyla bu durum daha çok Multi-Threading gerektiren uygulamalarda karşımıza çıkıyor. Peki bu sorunu nasıl çözeceğiz? İşte bu noktada .NET’in güçlü yapılarından Delegate (Temsilci) lere başvuracağız. Bu sorunu ortadan kaldırmak Delegate’ler ile inanılmaz kolay. Nasıl mı? Şöyle, bir örnekle açıklayalım;

 
delegate void updateLabelTextDelegate(string newText);
private void updateLabelText(string newText)
{
if (label1.InvokeRequired)
{
// worker thread
updateLabelTextDelegate del = new updateLabelTextDelegate(updateLabelText);
label1.Invoke(del, new object[] { newText });
}
else
{
// UI thread
label1.Text = newText;
}
}

burada yapmak istediğimiz şey, uygulamamızın içerisinde bulunan Label1 adlı Label kontrolünün
Text özelliğine farklı Thread’ ler üzerinde de erişebilmek. Öncelikle ilgili kontrolün Text özelliğini değiştiren bir metodu temsil edene bir temsilci tanımlamak (ve tabii ki metodu da). İşte bu amaçla updateLabelTextDelegate adlı, uygulama içerisinde updateLabelText() metodunu temsil edebilecek bir temsilci tanımlıyoruz. Metodumuzun içerisinde ise, ilgili kontrolün eğer faklı bir Thread üzerinden erişilmişse ayrı bir invocation gerektirip gerektirmediğini kontrol ediyoruz. Artık updateLabelText() metodunu gönül rahatlığı ile uygumamızın herhangi bir yerinde, herhangi bir Thread içerisinde çağırabiliriz. Hepsi bu kadar kolay

Hepsi bu kadar