C# : Resim Üzerindeki Renkleri Kullanma

     Kimi  zaman Visual Studio'nun bize uygulamalarımızda sundu Color Dialog seçeneği uygulamalarımızda yetmeyebilir. Bir resim düzenleme programı yapacaksınız diyelim. Hazırladığınız uygulamayı diğer resim düzenleme uygulamalarından farklı olmasını küçük değişikliklerle sağlayabilirsiniz. En basitinden kendi renk panelinizi oluşturup kullanıcılarınızın bunu kullanmasını sağlayabilirsiniz. Belki de kullanıcının seçtiği resim üzerindeki renkleri kullanmasını ya da resminin üzerindeki renklerle oynamasa fırsat tanıyan uygulamalar geliştirebilirsiniz.

          Bunları nasıl yapabiliriz şimdi ona bakalım biraz. Bir PictureBox nesnesi içerisinde aşağıda yer alan resmin renklerini kullanacağımızı varsayalım.

          Öncelikli yapmamız gereken PictureBox içerisinde resmi Bitmap değişkeni oluşturup onun üzerinde Bitmap olarak işlem yapacağız. Bunun için gerekli kodumuz şu şekildedir. (Aşağıdaki kodu formun Load olayında kullanabilirsiniz):

Bitmap bmp = (Bitmap)PictureBox.Image.Clone();

          Renk panelinin üzerinde olduğu PictureBox nesnesinin Click olayına aşağıdaki kodu yazarak o an resmin üzerinde hangi noktasındaysanız o rengi color değişkenine alarak bir renk olarak kullanabilirsiniz. 

Color renk = bmp.GetPixel(e.X, e.Y);

          Şimdide seçtiğimiz rengin Click olayından hemen sonra başka bir picturebox nesnesine aktarılmasını istiyoruz diyelim. Bunun için ColorShow adında bir picturebox nesnemizin olduğunu varsayalım. Bunun için ColorShow nesnemizin BackColor özelliğini kullanarak rengin değişmesini sağlayacağız. Bu kodu da hemen color olarak tanımladığımız renk değişkeninden sonra kullanabiliriz.

ColorShow.BackColor = renk;

         Bu üç adımı uygulayarak istediğiniz resimler üerindeki renkleri kullanabilir veya bu renkler üzerinde oynayabilirsiniz. 

Satranç Tahtasında A* Algoritması İle En Kısa Yolu Bulma

Bu projede 12*12'lik satranç tahtasında başlangıç ve varış noktalarını kullanıcının seçtiği iki nokta arasındaki en kısa yolu özel bir at taşı(uzun ayağı 3 birim giden) ile A* algoritmasını kullanarak bulacağız.

Problemin çözümünde karşılaşılan zorluklar ve çözümleri:

Çözüm işlemlerini yaparken karşımıza çıkacak zorlukları ve bunlara karşı bulduğumuz çözümleri şu şekilde açıklayabiliriz:

1-Satranç tahtasında at için her zaman 8 alternatif olmayabilir. Bu sorunumuzu atın hareket için yelteneceği yerler arasından, tahtamızın içinde olanları seçerek bir yol izlemesini sağlayarak çözüyoruz.

2-Atın hareket edeceği yer önceden gittiği bir yer olabilir. Bu sorunu da gidilen yerleri bir dizide tutarak ve gidilebilecek yerler için önerilecek listeden çıkartarak çözüyoruz.

3-En son gidilen yerler listesinden; en kısa yol çıkarımını yapmak bu programın belki de en zor kısmıydı. Bu zorluğu da en son bulunduğumuz noktadan sırayla belli kontroller ile geri gelerek aştık. Geri gelme kısmında mantığımız yine oyunun başında kullandığımız “gidebileceği yerleri bulmak” oldu. Bu en zor kısmında biraz ayrıntıya girmek istersek:

Tabloda gittiğimiz her noktanın satır, sütun, F(x) ve derinlik sayılarını tuttuk. Arama işlemini dersteki A* algoritması örneğindeki gibi tree gibi düşünelim. Derinlik sayımız, satır ve sütun değerlerimi de biliyoruz dedik. En son işlemde hedefe ulaşmıştık. Bu hedeften gidilebilecek yerleri buluyoruz ve bu yerlerden hangisinin derinliğinin bizimkinden bir az olduğuna bakıyoruz. Bulduğumuz değer bizim bir önceki geldiğimiz değerdir. Bu değeri kaydetmemiz gerekiyor. Sırayla bu işlemi başlangıç noktasına kadar yapıyoruz ve programımızı bitiriyoruz.

NOT: Şunu söylemeliyiz ki A* arama algoritması bizim belirlediğimiz H(x) veya G(x) değerlerine bağlı olarak değişmektedir. Örneğin programımızda G(x) değerimizi 15 değil de 5 yaparsak herhangi bulduğu bir adımı daha uzun yoldan ya da daha efektif bir şekilde de bulabilir. Bu yüzden programımız her zaman en kısa yolu bulamayacaktır fakat genelleme yaparsak bu olasılığın düşük olduğunu da söyleyebiliriz.

Programın Kodu Şu Şekildedir:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
namespace yapayzeka
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
int isaretleme = 0;
int sat1, sut1, sat2, sut2;

int GX(int i)
{
return i * 15;
}

int mutlak(int h)
{
if (h < 0)
{
return (h * (-1));
}
else
{
if (h > 0)
{
return h;
}
else
{
return -1;
}
}
}

void Form1_Click(object sender, EventArgs e)
{
Label tiklananKare = sender as Label;
string kordinat = tiklananKare.Tag.ToString();
int x = Convert.ToInt32(kordinat.Split(';')[0]);
button1.Enabled = false;
int y = Convert.ToInt32(kordinat.Split(';')[1]);
//ilk işaretleme işlemi ise başlangıçı sececek
if (isaretleme == 0)
{
satrancKareleri[x, y].BackColor = Color.Green;
isaretleme++;
satrancKareleri[x, y].Font = new Font("Times New Roman", 9, FontStyle.Italic);
satrancKareleri[x, y].Text = "Bşlngç";
sat1 = x;
sut1 = y;
}
else
{
//ikinci işaretleme işlemi ise bitişi seçecek
if (isaretleme == 1)
{
if (satrancKareleri[x, y].Text == "Bşlngç")
{
MessageBox.Show("Bitiş için başka seçim yapmalısınız!!");
}
//ikinciden fazla işaretleme olduğu zaman hata verecek
else
{
satrancKareleri[x, y].BackColor = Color.Red;
satrancKareleri[x, y].Text = "Bitiş";
isaretleme++;
sat2 = x;
sut2 = y;
button1.Enabled = true;
}
}
else
{
button1.Enabled = true;
MessageBox.Show("Başka seçim yapamazsınız!!");
}
}
}

private void Form1_Load(object sender, EventArgs e)
{
//satranç tahtasını oluşturyoruz
textBox1.ReadOnly = true;
int kareler_en = 41;
int kareler_boy = 41;
int yukseklik = 50;
for (int satir = 0; satir < 12; satir++)
{
int sol = 50;
for (int sutun = 0; sutun < 12; sutun++)
{
satrancKareleri[satir, sutun] = new Label();
satrancKareleri[satir, sutun].Size = new Size(kareler_en, kareler_boy);
satrancKareleri[satir, sutun].Left = sol;
satrancKareleri[satir, sutun].Top = yukseklik;
satrancKareleri[satir, sutun].BorderStyle = BorderStyle.FixedSingle;
satrancKareleri[satir, sutun].AutoSize = false;
satrancKareleri[satir, sutun].Tag = satir + ";" + sutun;
if ((satir + sutun) % 2 == 0)
{
satrancKareleri[satir, sutun].BackColor = Color.White;
}
else
{
satrancKareleri[satir, sutun].BackColor = Color.Black;
}
satrancKareleri[satir, sutun].Font = new Font("Times New Roman", 10, FontStyle.Italic);
this.Controls.Add(satrancKareleri[satir, sutun]);
satrancKareleri[satir, sutun].Click += new EventHandler(Form1_Click);
sol += kareler_en;
}
yukseklik += kareler_boy;
}
}
Label[,] satrancKareleri = new Label[12, 12];

private void button1_Click(object sender, EventArgs e)
{
try
{
if (isaretleme == 2)
{
Stopwatch sw = Stopwatch.StartNew();
int donguden_cik = 0;//hedefe ulaşıldığında while döngüsünden çıkmak için tanımlandı
int min;//gidilebilecek yerler arasında f(x) fonksiyonun en küçük elemanını bulurken kullandık
int indis = 0;//minimumu bulduğumuz elenın indisini tutacak
int dizi_sonu;//gidilecek yerlerin tutulduğu dizinin sonunu gösterecek
int[,] gidilebilecek_yerler = new int[144, 4];//gidilebilecek yerin tutulduğu dizi
//gidilebilecek_yerler dizisinin 1. sütunu gidilebilecek yerin satır sayısını;
//gidilebilecek_yerler dizisinin 2. sütunu gidilebilecek yerin sütun sayısını;
//gidilebilecek_yerler dizisinin 3. sütunu gidilebilecek yerin F(x) değerini;
//gidilebilecek_yerler dizisinin 4. sütunu gidilebilecek yerin kaçıncı derecede olduğunu göstermektedir;
int[,] HX = new int[12, 12];//H(x) fonksiyonun değerlerinin tutulduğu dizi
int[,] gidilen_yerler = new int[144, 3];//seçilen her node'un tutulduğu dizi
int tmp = 0, sayac, dongu, dongu2;//döngülerde kullanıyoruz
int i, j, m;//döngülerde kullanıyoruz
int liste = 0;//kaç adım ilerlediğimizi tuttuğumuz değişken
int bul;//döngüde kullanıyoruz
int agac_derecesi = 1;//her açtığımız yolun kaçıncı yol olduğunu tutacak değişken
int[,] gercek_yol = new int[144, 2];//en son gidilen yolu atadığımız dizi
//başlangıç yerini gidilen yerlere kaydediyoruz
gidilen_yerler[0, 0] = sat1;
gidilen_yerler[0, 1] = sut1;
gidilen_yerler[0, 2] = 0;
//H(x) fonksiyonunu oluşturuyoruz
for (i = 0; i < 12; i++)
{
for (j = 0; j < 12; j++)
{
if (i == sat2 || j == sut2)
{
HX[i, j] = (mutlak(sat2 - i) + mutlak(sut2 - j) + 1) * 10;
}
else
{
HX[i, j] = (mutlak(sat2 - i) + mutlak(sut2 - j)) * 10;
}
HX[sat2, sut2] = 0;
}
}
dizi_sonu = -1;
//Gidilebilecek yerleri buluyoruz
//Bunu yaparken tablo dışına çıkmayı ve gidilen yerlere gitmeyi engellemeliyiz
while (donguden_cik == 0)
{
if ((sat1 + 3) < 12 && (sut1 - 1) < 12 && (sat1 + 3) >= 0 && (sut1 - 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 3 && gidilen_yerler[m, 1] == sut1 - 1)
{
bul = 1;
}//gidilen yerlerde varsa o noktaya gitmeye gerek yoktur
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 3 && gidilebilecek_yerler[i, 1] == sut1 - 1)
{
bul = 1;
}//gidilebilecek yerlere önceden eklenmişse gitmemeliyiz
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 3, sut1 - 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}//yeni noktayı gidilebilecek yerlere ekliyoruz
bul = 0;
}
if ((sat1 + 3) < 12 && (sut1 + 1) < 12 && (sat1 + 3) >= 0 && (sut1 + 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 3 && gidilen_yerler[m, 1] == sut1 + 1)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 3 && gidilebilecek_yerler[i, 1] == sut1 + 1)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 3, sut1 + 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 3) < 12 && (sut1 - 1) < 12 && (sat1 - 3) >= 0 && (sut1 - 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if ((gidilen_yerler[m, 0] == sat1 - 3) && (gidilen_yerler[m, 1] == sut1 - 1))
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 3 && gidilebilecek_yerler[i, 1] == sut1 - 1)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 3, sut1 - 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 3) < 12 && (sut1 + 1) < 12 && (sat1 - 3) >= 0 && (sut1 + 1) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if ((gidilen_yerler[m, 0] == sat1 - 3) && (gidilen_yerler[m, 1] == sut1 + 1))
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 3 && gidilebilecek_yerler[i, 1] == sut1 + 1)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 3;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 1;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 3, sut1 + 1];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 1) < 12 && (sut1 - 3) < 12 && (sat1 - 1) >= 0 && (sut1 - 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 - 1 && gidilen_yerler[m, 1] == sut1 - 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 1 && gidilebilecek_yerler[i, 1] == sut1 - 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 1, sut1 - 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 - 1) < 12 && (sut1 + 3) < 12 && (sat1 - 1) >= 0 && (sut1 + 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 - 1 && gidilen_yerler[m, 1] == sut1 + 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 - 1 && gidilebilecek_yerler[i, 1] == sut1 + 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 - 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 - 1, sut1 + 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 + 1) < 12 && (sut1 - 3) < 12 && (sat1 + 1) >= 0 && (sut1 - 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 1 && gidilen_yerler[m, 1] == sut1 - 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 1 && gidilebilecek_yerler[i, 1] == sut1 - 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 - 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 1, sut1 - 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
if ((sat1 + 1) < 12 && (sut1 + 3) < 12 && (sat1 + 1) >= 0 && (sut1 + 3) >= 0)
{
bul = 0;
m = 0;
while (bul == 0 && m <= liste)
{
if (gidilen_yerler[m, 0] == sat1 + 1 && gidilen_yerler[m, 1] == sut1 + 3)
{
bul = 1;
}
m++;
}
for (i = 0; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 0] == sat1 + 1 && gidilebilecek_yerler[i, 1] == sut1 + 3)
{
bul = 1;
}
}
if (bul == 0)
{
dizi_sonu++;
gidilebilecek_yerler[dizi_sonu, 0] = sat1 + 1;
gidilebilecek_yerler[dizi_sonu, 1] = sut1 + 3;
gidilebilecek_yerler[dizi_sonu, 2] = HX[sat1 + 1, sut1 + 3];
gidilebilecek_yerler[dizi_sonu, 3] = agac_derecesi;
}
bul = 0;
}
//gidilebilecek yerlerin F(x)'i gidilebilecek_yerler dizisinin 2.satırında tutuluyor
//F(x)=G(x)+H(x) işlemini yapıp 2 satırlara kaydediyoruz
for (i = tmp; i <= dizi_sonu; i++)
{
gidilebilecek_yerler[i, 2] = GX(liste) + gidilebilecek_yerler[i, 2];
}
tmp = dizi_sonu;//
min = gidilebilecek_yerler[0, 2];//minimum için ilk atama
indis = 0;//indis için ilk atama
//minimum F(x) değerini buluyoruz ve indisini kaydediyoruz
for (i = 1; i <= dizi_sonu; i++)
{
if (gidilebilecek_yerler[i, 2] < min)
{
min = gidilebilecek_yerler[i, 2];
indis = i;
}
}
liste++;
//bulduğumuz yeri gidilen yerlere ekliyoruz
gidilen_yerler[liste, 0] = gidilebilecek_yerler[indis, 0];
gidilen_yerler[liste, 1] = gidilebilecek_yerler[indis, 1];
gidilen_yerler[liste, 2] = gidilebilecek_yerler[indis, 3];
agac_derecesi = gidilebilecek_yerler[indis, 3] + 1;
sat1 = gidilebilecek_yerler[indis, 0];//en son satır değerini yine satır değerine atıyoruz
sut1 = gidilebilecek_yerler[indis, 1];//en son sutun değerini yine sutun değerine atıyoruz
//eklediğimiz değerleri gidilebilecek yerler dizisinden çıkartmamız gerekiyor,çıkartıyoruz
for (i = indis; i < dizi_sonu; i++)
{
gidilebilecek_yerler[i, 0] = gidilebilecek_yerler[i + 1, 0];
gidilebilecek_yerler[i, 1] = gidilebilecek_yerler[i + 1, 1];
gidilebilecek_yerler[i, 2] = gidilebilecek_yerler[i + 1, 2];
gidilebilecek_yerler[i, 3] = gidilebilecek_yerler[i + 1, 3];
}
dizi_sonu--;
//hedef yere veya ulaşılamayacağını anladığımız yere gelip gelmediğimizin kontrolü
if (HX[sat1, sut1] == 10)
{
textBox1.Text = "Maksimum yakınlık sağlandı fakat çözüm yok!!";
donguden_cik = 2;
}
if (sat1 == sat2 && sut1 == sut2)
{
textBox1.Text = "Hedefe ulaşıldı!!";
donguden_cik = 3;
}
}
sayac = 0;
dongu2 = gidilen_yerler[liste, 2] - 1;
agac_derecesi = agac_derecesi - 2;//ağaç derecesini istediğimiz başlangıç derecesine getiriyoruz
dongu = agac_derecesi;//en son gidilen adımları yazdırırken kullanacağız
gercek_yol[sayac, 0] = sat1;//ulaşılan sonuç yerinin satırını gerçek yol dizisie atıyoruz
gercek_yol[sayac, 1] = sut1;//ulaşılan sonuç yerinin sutununu gerçek yol dizisie atıyoruz
//kaç adımda gittiğimiz bellidir,dongu2 kadar while yapıyoruz
//son ulaştıgımız yerden geriye doğru gelerek yolu buluyoruz
while (dongu2 > 0)
{
sayac++;
//son bulunduğumuz yerden gidilebilecek yerleri buluyoruz, tahtadan dışarı çıkıp çıkmadığına bakıyoruz
if ((sat1 + 3) < 12 && (sut1 - 1) < 12 && (sat1 + 3) >= 0 && (sut1 - 1) >= 0)
{
//dışarı çıkmıyorsa bir önceki geldiği yerin burası olup olmadığına bakıyoruz
//eğer burasıysa gerçek yol dizimize eklemeliyiz
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 3 && gidilen_yerler[i, 1] == sut1 - 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 3;
gercek_yol[sayac, 1] = sut1 - 1;
sat1 = sat1 + 3;
sut1 = sut1 - 1;
}
}
}
if ((sat1 + 3) < 12 && (sut1 + 1) < 12 && (sat1 + 3) >= 0 && (sut1 + 1) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 3 && gidilen_yerler[i, 1] == sut1 + 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 3;
gercek_yol[sayac, 1] = sut1 + 1;
sat1 = sat1 + 3;
sut1 = sut1 + 1;
}
}
}
if ((sat1 - 3) < 12 && (sut1 - 1) < 12 && (sat1 - 3) >= 0 && (sut1 - 1) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 3 && gidilen_yerler[i, 1] == sut1 - 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 3;
gercek_yol[sayac, 1] = sut1 - 1;
sat1 = sat1 - 3;
sut1 = sut1 - 1;
}
}
}
if ((sat1 - 3) < 12 && (sut1 + 1) < 12 && (sat1 - 3) >= 0 && (sut1 + 1) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 3 && gidilen_yerler[i, 1] == sut1 + 1 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 3;
gercek_yol[sayac, 1] = sut1 + 1;
sat1 = sat1 - 3;
sut1 = sut1 + 1;
}
}
}
if ((sat1 - 1) < 12 && (sut1 - 3) < 12 && (sat1 - 1) >= 0 && (sut1 - 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 1 && gidilen_yerler[i, 1] == sut1 - 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 1;
gercek_yol[sayac, 1] = sut1 - 3;
sat1 = sat1 - 1;
sut1 = sut1 - 3;
}
}
}
if ((sat1 - 1) < 12 && (sut1 + 3) < 12 && (sat1 - 1) >= 0 && (sut1 + 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 - 1 && gidilen_yerler[i, 1] == sut1 + 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 - 1;
gercek_yol[sayac, 1] = sut1 + 3;
sat1 = sat1 - 1;
sut1 = sut1 + 3;
}
}
}
if ((sat1 + 1) < 12 && (sut1 - 3) < 12 && (sat1 + 1) >= 0 && (sut1 - 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 1 && gidilen_yerler[i, 1] == sut1 - 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 1;
gercek_yol[sayac, 1] = sut1 - 3;
sat1 = sat1 + 1;
sut1 = sut1 - 3;
}
}
}
if ((sat1 + 1) < 12 && (sut1 + 3) < 12 && (sat1 + 1) >= 0 && (sut1 + 3) >= 0)
{
for (i = 0; i <= liste; i++)
{
if (gidilen_yerler[i, 0] == sat1 + 1 && gidilen_yerler[i, 1] == sut1 + 3 && gidilen_yerler[i, 2] == agac_derecesi)
{
gercek_yol[sayac, 0] = sat1 + 1;
gercek_yol[sayac, 1] = sut1 + 3;
sat1 = sat1 + 1;
sut1 = sut1 + 3;
}
}
}
dongu2--;
agac_derecesi--;//bir öncekini bulmuşuzdur artık , bir daha geriye gidiyoruz
}
//artık gidilen yolu bulduk
//yollara adımları teker teker yazıyoruz ve tablonun renklerini değiştiriyoruz
for (i = dongu; i >= 0; i--)
{
satrancKareleri[gercek_yol[i, 0], gercek_yol[i, 1]].Font = new Font("Times New Roman", 15, FontStyle.Italic);
satrancKareleri[gercek_yol[i, 0], gercek_yol[i, 1]].Text = (dongu - i + 1).ToString();
satrancKareleri[gercek_yol[i, 0], gercek_yol[i, 1]].BackColor = Color.Aqua;
}
int hafiza = liste + dizi_sonu + sayac + 2;//dizilerde toplam kullanılan hafızayı buluyoruz
label5.Text = (hafiza * 8).ToString();//toplam hafızayı ekrana yazdırıyoruz
sw.Stop();//sayaçı durdurmamız gerekiyor
String metin;
metin = (sw.Elapsed).ToString();//sayaç değerinin döndürdüğü sayıyı stringe çeviriyoruz
metin = metin.Remove(0, 9);//sayaç değerinin döndürdüğü metni kesiyoruz
label3.Text = metin;//süreyi ekrana yazdırıyoruz
isaretleme = 0;
}
else{
MessageBox.Show("Yeni tablo açıp tekrar deneyiniz!!");
}
}
catch (Exception)
{
MessageBox.Show("Hata Oluştu !!");
}
}

private void button2_Click(object sender, EventArgs e)
{
isaretleme = 0;
Form1 yeni = new Form1();//yeni tahta formu oluşturuyoruz
yeni.Show();
}
}
}

Ekran Çıktıları:

Not: Başlangıç noktası yeşil , bitiş noktası kırmızı ile işaretlenmiştir. Karelerdeki sayılar da adım sayılarını göstermektedir. Hedefe ulaşıldığında son kare de işaretlendiği için kırmızı renk de kaybolmaktadır. 

Program Setup Dosyası aşağıdaki linktedir:

Buraya Tıklayın

C#: String Sınıfı(Trim, Substring, Split )

          String sınıfı karakter işlemlerini baz alınarak oluşturmuş bir sınıftır. Karakterler üzerinde sık yapılan işlemler için geliştirilmiş metotlar oluşturulmuştur. Biz Trim, Substring ve Split metotlarından bahsedeceğiz.

Trim

         Trim metodu karakterin başındaki ve sonundaki boşlukları atmak için kullanılır. Eğer ki sadece kelimelerin başındaki ya da sonundaki boşlukları aşmak istiyorsak TrimEnd ve TrimStart metotlarını da kullanabiliriz.

Kullanılabilecek Yer

          Bu metotların yapmış olduğu işlemlere örnek verecek olursak hazırladığımız programda kullanıcının mailden gelen güvenlik kodunu gireceği bir alan var. Genelde mailimizden direkt kopyala yapıştır yaparız ve kimi zaman karakter topluluğunun başında veya sonundaki fazladan boşlukları da alırız. Bu da programın güvenlik kodunu yanlış algılamasına neden olacaktır. Bu gibi durumları engellemek için Trim metotunu kullanabiliriz.

Kod

Substring

         Kelime ve kelime gruplarından istenilen karakter sırasından sonraki belirlediğimiz kadar karakteri alan  metottur.Kullanımı şu şekildedir:

Substring(başlangıç karakter sırası, gözükecek karakter sayısı)

         Örneğin "isimiz yazilim" alanında "imiz ya" kısmını almak istiyoruz. Öncelikle ilk karakterin başlangıç noktası 0 baz alınır. Bunun için biz almak isteğimiz alanının başlangıç sırasını 2 olarak alacağız. bitiş sırasında da boşluğu da saymamız gerekmektedir. Şimdi ise başlangıç sırasından itibaren gözükmesini isteğimiz kelime sayısını gireceğiz. i harfinden a harfine kadar boşluk da dahil olmak üzere 7 karakter olduğu için 7 yazacağız.

Substring(başlangıç karakter sırası)

          Gözükecek karakter sayısı belirtilmediğinde belirtilmediğinde başlangıç sırası belirtilen karakterden sonraki tüm karakterler alınacaktır.

Kullanılabilecek Yer

        Hazırladığımız programda bir metin içerisinde kelime aramak için kullanılabilecek bir kod parçasıdır. 

Kod

Split

          Kelime veya kelime gruplarında belirlenen karakterden sonrasını bölmek için kullanılır. Bu işlem sırasında belirlenen karakteri kaldıracaktır.

Kullanılabilecek Yer

          Çeviri programlarında girilen metinler split komutu sayesinde boşluklardan sonrasında kelime kelime ayrılması sağlanarak bir dizide tutulup var olan kelime veri tabanındakiler ile eşleştirilip ufak çaplı bir çeviri yapılması sağlanan programların yapımında kullanılabilecek bir komuttur.


Uyarı: Split ile böldüğünüz kelime gruplarını bir yerde tutmanız gerekmektedir. Bunun için en uygun yer diziler olacaktır.

Kod

C de Play Fair Şifrelemesi

Bu programda PLAY FAİR şifrelemesinin C kodunu yazacağız.

Kodun Kısa Açıklaması:

Kullanıcıdan anahtar metnini istiyoruz ve metnin uzunluğunu hesaplıyoruz. Bu programda öteleme işlemlerini kullanacağımız için her dizinin bitiş indisini tutuyoruz. Anahtarı aldıktan sonra içinde tekrar eden harfleri siliyoruz. Bu silme işlemini de bahsettiğimiz gibi sola bir kere öteleme yaparak hallediyoruz. Tekrarları sildikten sonra bu dizinin harflerini başta tanımladığımız alfabe dizisinden çıkartıyoruz. Tekrarları sildiğimiz dizinin elemanlarını alfabe dizisinin başına kopyalamamız gerekiyor. Bunun için de alfabe dizisini sağa doğru ötelememiz gerekiyor(tekrarsız kalan harf sayısı kadar). Alfabe dizisinin başına gerekli kopyalamaları yaptıktan sonra bu diziyi tabloya atıyoruz.

Kullanıcıdan şifrelenecek metni girmesini istiyoruz ve ikili olarak kontrole başlıyoruz. İkililerden aynı karakter olan varsa arasına yine öteleme işlemi yaparak ‘X’ karakterini yerleştiriyoruz. Tüm diziye bunu uyguladıktan sonra eğer en son eleman tek kalmışsa dizi sonuna da ‘Z’ karakterini ekliyoruz. Fakat bu son eleman da ‘Z’ ise programımızın sonsuz döngüye girmesini engellemek için ‘X’ karakterini ekliyoruz. Şifreleme işlemine geldiğinde ise her ikili karakterleri bir anda tabloda arıyoruz. Bulduğumuz karakterlerin adreslerini tablo adlı 2x2 lik matriste tutuyoruz. Örneğin HC ikilisini arıyoruz ve bulduğumuzda H karakterinin satır numarasını tutac[0][0] ’a H karakterinin sutun numarasını  tutac[0][1] ‘e ;  C karakterinin satır numarasını tutac[1][0] ’a C karakterinin sutun numarasını  tutac[1][1] ‘e  kaydediyoruz. Daha sonra bunların aynı satırda-sütunda olup olmadığına bu tutaç matrisini kullanarak bakıyoruz ve hemen şifrelenmiş şeklini şifrelenmiş string’i tutacak diziye atıyoruz. Bu işlemleri şifrelenecek string’in sonuna kadar yapıyoruz ve şifreyi ekrana yazdırıyoruz.

Kodun Ayrıntılı Açıklaması:

     Problemin çözüm kısmında öncelikle kullanıcıdan anahtar olacak metni büyük harflerle girmesini istiyoruz ve strlen fonksiyonunu kullanarak girilen dizinin son karakterinin indisini buluyoruz. Daha sonra ilk işimiz girilen bu anahtardaki tekrar eden harfleri çıkartmaktır. Bunu da bir while döngüsü kullanarak yapıyoruz. While döngüsünde aynı harflerin olup olmadığına bakıyoruz. Eğer aynı harfler varsa ikinci olarak bulunan harfi silmemiz gerekiyor. Bu işlemi de o harfin olduğu yere bir kere öteleyerek yapıyoruz. Burada ötelemeden sonra i değişkenini bir azaltmamızın sebebi sildiğimiz harfin üstüne aynı harf geldiği zaman tekrar silmesi gerektiğidir.

     Bahsettiğim başa dönme olayından dolayı bu işlemleri en başta for ile değil de while ile yaptık çünkü for döngüsündeki i değişkenine müdahale etmemiz gerekecekti ve for döngüsünde bu azaltma işlemini yapmak hiç sağlıklı değildir.

     Anahtar dizimizdeki tekrarlı harfleri çıkarttıktan sonra geriye kalan harfleri alfabe dizisinden çıkartmamız gerekiyor çünkü tablomuza alfabede kalan harfleri sırayla ekleyeceğiz.

Tabloya ekleyeceğimiz harfleri alfabe dizisinden alacağız. Bu yüzden sırayla, önce tekrar eden harfleri çıkarttığımız dizideki harfleri alfabe dizisine almalıyız. Bunu da yapmak için öncelikle alfabeden sildiğimiz harf kadar sağa öteleme yapmalıyız ki alfabe dizisinin başına tekrarsız harfleri ekleyebilelim.

     Öteleme işlemini yaptıktan sonra anahtar dizisinde kalan harfleri sırayla alfabe dizisine atıyoruz. Artık alfabe dizisini tabloya atarak şifre metinini kullanıcıdan istiyoruz.

     Bu bölümde öncelikle girilen string’i ikili parçalara ayırıp aynı harf ikililerinin olup olmadığına bakıyoruz. Eğer böyle ikililer varsa o ikililerin arasına ‘X’ karakterini yerleştiriyoruz.  Bu işlemi dizinin sonuna kadar yapıyoruz. Bu işlemleri tamamladıktan sonra eğer en sonda tek karakter kaldıysa onu  ikili yapmak için string’in sonuna ‘Z’ ekliyoruz ve dizinin uzunluğunu bir arttırıyoruz. Eğer son eleman da ‘Z’ ise dizinin sonuna sonsuz döngüyü engellemek için ‘X’ karakterini ekleriz.  Dizilerde son elemanı tutmaktaki amaç öteleme yaptığımız zaman kalan elemanların da diziye dâhil olduğu fakat kullanılmadığından dolayı dizinin asıl son elemanını bulabilmemiz. Görsel amaçlı olarak kullanıcıya burada bir de şifrelenecek string’in son halini gösteriyoruz.

     En son olarak geriye string’i şifrelemek kalıyor. İ değişkenini 0’dan dizi uzunluğuna kadar ikişer olarak arttırıyoruz. Bunu yapmamızdaki amaç her ikilileri bir adımda bulacağımız için teker teker gitmeye gerek kalmamasıdır. Tutaç adlı 2x2 lik matrisimiz bize bulunan harflerin tablodaki indislerini gösterecektir.

Örneğin:

2	4
1	3

     Yukarıdaki tablo bulunan birinci harfin satır sayısının 2 Sütun sayısının 4 olduğunu, ikinci harfin de satır sayısının 1 sütun sayısının 3 olduğunu gösteriyor.

     Programın devamında24’e kadar giden bir t değişkeni tanımladık. Bu bize bulunduğumuz satır ve sütunu verecek. Eğer burada for döngüsü kullansaydık her eleman için 25 elemanı da kontrol etmek zorunda kalacaktık. Örneğin t=13 durumunda satır sayısını 13/5 den 2, sütun sayısını da 13 (mod5 )‘ten 3 olarak bulacağız. Şifrelenecek iki harfin de Satır ve sütun numaralarını bulduktan sonra aynı satır-sütunda olduğuna ya da olmadığına bakıyoruz. Eğer aynı satırdalarsa yanlarındaki, aynı sütundalarsa altlarındaki, ikisi de değilse köşelerindeki elemanları alıyoruz. Bunu tüm stringi dolaşarak yapıyoruz ve bulduğumuz her şifreli harfleri şifre için tanımladığımız diziye atıyoruz. En son da şifrelenmiş string’i ekrana yazdırıyoruz ve programımızı bitiriyoruz. 

Programın Kaynak Kodu:

#include <stdio.h>
#include <stdlib.h>

int main() {
	char tablo[5][5];
	char anahtar[25];//GİRİLECEK ANAHTAR İÇİN KULLANILACAK DİZİ
	char sifrelenmis_dizi[25];//ŞİFRELENEN HARFLERİN YAZILACAĞI DİZİ
	int tutac[2][2];//TABLODA ARANIP-BULUNAN 2 HARFİN ADRESLERİNİN TUTULACAĞI DİZİ
	char alfabe[25]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','R','S','T','U','X','V','W','Y','Z'};
	char sifrelenecek_dizi[30];//ŞİFRELENMEK İÇİN GİRİLEN DİZİ
	int i,j,k,t,indis;
	int anahtar_dizi_sonu;//ANAHTAR DİZİSİNİN SON İNDİSİNİ TUTAN DEĞİŞKEN
	int alfabe_sonu=24;
	int sifrelenecek_dizi_uzunlugu;
	int sifre_onay=0;
	
	printf("Lutfen anahtar metnini buyuk harflerle giriniz !!\n");
	scanf("%s",&anahtar);
	anahtar_dizi_sonu=strlen(anahtar)-1;
	i=1;
	while(i<=anahtar_dizi_sonu){
		j=0;
				while(anahtar[j]!=anahtar[i] && j<i){
					j++;
				}
				if(j!=i){
						for(k=i;k<anahtar_dizi_sonu;k++){
							anahtar[k]=anahtar[k+1];
						}
						anahtar_dizi_sonu--;
						i--; 
				}
		i++;
	}//AYNI HARFLER BULUNUP DİZİDEN ÇIKARTILIYOR
	for(i=0;i<=anahtar_dizi_sonu;i++){
		j=0;
			while(anahtar[i]!=alfabe[j] ){
				j++;
			}
				for(k=j;k<alfabe_sonu;k++){
					alfabe[k]=alfabe[k+1];
				}
					alfabe_sonu--;
	}//GİRDİĞİMİZ ANAHTARDAKİ HARFLER ALFABEDEN ÇIKARTILIYOR	
	for(i=alfabe_sonu;i>=0;i--)
	{
		alfabe[i+anahtar_dizi_sonu+1]=alfabe[i];
	}//SİLİNEN HARFLER KADAR ALFABE DİZİSİNİ SAĞA ÖTELİYORUZ VE ANAHTARDAKİ HARFLERE YER AÇIYORUZ
	
	for(i=0;i<=anahtar_dizi_sonu;i++){
		alfabe[i]=anahtar[i];
	}//ALFABE DİZİSİNDE AÇTIGIMIZ YERLERE TEKRARSIZ ANAHTAR HARFLERİMİZİ YERLEŞTİRİYORUZ
	printf("\nGirdiginiz anahtarin tekrarsiz harfli formati asagidaki gibidir:\n\n");
	for(i=0;i<=anahtar_dizi_sonu;i++){
		printf("%c",anahtar[i]);
	}
	strcpy(tablo,alfabe);//ALFABE DİZİMİZİ TABLOYA YERLEŞTİRİYORUZ
	printf("\n\nAnahtar yerlestirilmis tablo asagidaki gibidir!!\n\n");
	for(i=0;i<5;i++)
	{
		for(j=0;j<5;j++){
			printf("%c ",tablo[i][j]);
		}
			printf("\n");
	}
	
	
		printf("\nLutfen sifrelenecek metni giriniz!!\n");
		scanf("%s",&sifrelenecek_dizi);
		sifrelenecek_dizi_uzunlugu=strlen(sifrelenecek_dizi);
		indis=0;
		while(indis<sifrelenecek_dizi_uzunlugu){
				if(sifrelenecek_dizi[indis]==sifrelenecek_dizi[indis+1]){
					for(j=strlen(sifrelenecek_dizi)-1;j>indis;j--){
						sifrelenecek_dizi[j+1]=sifrelenecek_dizi[j];
					}
							sifrelenecek_dizi_uzunlugu++;
							sifrelenecek_dizi[indis+1]='X';
		  		}
				else{
					indis=indis+2;
	        	}
		}//AYNI HARF OLAN İKİLİLER VARSA ARAYA 'X' YERLEŞTİRİYORUZ
		
		
			if(sifrelenecek_dizi_uzunlugu%2==1){
				if(sifrelenecek_dizi[sifrelenecek_dizi_uzunlugu-1]=='Z'){
					sifrelenecek_dizi[sifrelenecek_dizi_uzunlugu]='X';
					sifrelenecek_dizi_uzunlugu++;	
				}//EN SON HARF 'Z' İSE SONUNA 'X' EKLİYORUZ
				else{
					sifrelenecek_dizi[sifrelenecek_dizi_uzunlugu]='Z';
					sifrelenecek_dizi_uzunlugu++;	
				}//EN SON HARF TEK KALMIŞSA SONUNA 'Z' EKLİYORUZ
						
			}
		
    
		printf("\nGirdiginiz metnin sifrelenmeye uygun son hali :\n\n");
		for(i=0;i<sifrelenecek_dizi_uzunlugu;i++){
				if(i%2==0&&i!=0){
						printf("-");
				}
				printf("%c",sifrelenecek_dizi[i]);
		}
		printf("\n\n ***ACIKLAMALAR***\n");
		
		for(i=0;i<sifrelenecek_dizi_uzunlugu;i=i+2){
				for(k=i;k<i+2;k++){
					t=0;
						while(sifrelenecek_dizi[k]!=tablo[t/5][t%5]){
								t++;
				   		}
			    		tutac[k%2][0]=t/5;
			    		tutac[k%2][1]=t%5;
				}
			if(tutac[0][0]==tutac[1][0]){
				sifrelenmis_dizi[i]=tablo[tutac[0][0]][(tutac[0][1]+1)%5];
				sifrelenmis_dizi[i+1]=tablo[tutac[1][0]][(tutac[1][1]+1)%5];
	printf("\n%c ve %c ayni satirdadirlar!!\n",tablo[tutac[0][0]][tutac[0][1]],tablo[tutac[1][0]][tutac[1][1]]);
			}//AYNI SATIRDALARSA
			else{
				if(tutac[0][1]==tutac[1][1]){
				
				sifrelenmis_dizi[i]=tablo[(tutac[0][0]+1)%5][tutac[0][1]];
				sifrelenmis_dizi[i+1]=tablo[(tutac[1][0]+1)%5][tutac[1][1]];
       printf("\n%c ve %c ayni sutundadirlar!!\n",tablo[tutac[0][0]][tutac[0][1]],tablo[tutac[1][0]][tutac[1][1]]);
				}//AYNI SUTUNDALARSA
				else{
					sifrelenmis_dizi[i]=tablo[tutac[0][0]][tutac[1][1]];
					sifrelenmis_dizi[i+1]=tablo[tutac[1][0]][tutac[0][1]];
printf("\n%c ve %c ayni satir-sutunda degildirler!!\n",tablo[tutac[0][0]][tutac[0][1]],tablo[tutac[1][0]][tutac[1][1]]);
				}//AYNI SATIR VEYA SUTUNDA DEĞİLLERSE
			}
		}
		printf("\n\nMetnin sifrelenmis hali asagidaki gibidir:\n");
		for(i=0;i<strlen(sifrelenmis_dizi);i++){
				if(i%2==0&&i!=0){
						printf("-");
				}
				printf("%c",sifrelenmis_dizi[i]);
		}	
	return 0;
}

 

Programın Ekran Çıktıları:

C Diliyle Tic Tac Toe Oyunu Yazımı

Tic tac toe oyununun mantığı 3x3 lük karelerde yan yana, alt alta ve ya çapraz biçimde 3’lü seri yapmaya çalışmaktır. Bu örneğimizde de bu oyunun konsol kodunu yazacağız.

Oyunumuzun genel mantığını şöyle özetleyebiliriz:

Kullanıcı oyunu bir yer seçerek başlatacaktır. Daha sonra ise bilgisayar random olarak boş bir yer bulup hamlesini yapacaktır. Bu şekilde sırayla, kullanıcı veya bilgisayar oyunu kazanıp –oyun berabere bitene kadar hamlelerini gerçekleştirecektir.

Kod kısmını ayrıntılı olarak ele almaya başlarsak:

Öncelikle programda kullandığımız değişkenleri ve dizimizi tanımlıyoruz. Daha sonra ekran çıktısı için sade ve anlaşılır bir tablo hazırlamamız gerekiyor. 

Tablomuzu da oluşturduktan sonra sıra geliyor kullanıcıdan girdileri almaya. Burada bir for döngüsü kullanıyoruz. Bu for döngüsü içinde indeks olarak kullandığımız k değişkenini 0’dan 9’a kadar artırıyoruz. Bunu yapmamızdaki neden oyunda maksimum 9 adım olabilmesidir. For döngüsünün ardından k olarak belirlediğimiz indeksin 2’ye göre modunu alıyoruz. Buradaki mantık da k değişkenin ikiye göre modu 0(sıfır) ise sıranın kullanıcıda, 1 ise sıranın bilgisayarda olduğunu belirtmemizdir.

Oyuna hamle sırası kullanıcıda olduğu zaman kullanıcı_girisi adlı fonksiyonumuzu çalıştırıyoruz. Bu fonksiyonumuz ise önce kullanıcıdan satır ve sütun değerlerini istiyor ve hemen ardından while döngüsüne giriyor. Eğer bu girdiğimiz değer 0-2 aralığı dışında veya herhangi dolu bir yere denk geliyorsa ekrana bir bildirim yazdırıp yeni değerler girmesini istiyoruz. Bu işlem kullanıcının geçerli değerleri girene kadar devam ediyor ve en sonunda aldığımız geçerli değişkenlere denk gelen yeri ‘x’ yapıyoruz. Fonksiyon geriye,  düzelttiğimiz ‘matris’ matrisini döndürüyor ardından for döngüsü de k değişkeni bir arttırıp sırayı bilgisayara veriyor.

Bilgisayara sıra geldiğinde ise bilgisayar_girisi adlı fonksiyonumuzu devreye sokuyoruz. Bu fonksiyon da öncelikle rastgele satır ve sütun değerleri seçiyor ardından da yine bir while döngüsüne girdiriyoruz. Burada da boş yer bulana kadar sürekli random fonksiyonuyla satır ve sütun değerleri yakalıyoruz. En son yakaladığımız geçerli yeri bilgisayarı temsilen ‘o’ yapıyoruz. Bu işlemler oyun sonlana kadar devam ediyor.

 Oyunun sonlandığını kontrol etmek için bazı if deyimlerine ihtiyacımız var. Bu if’lerin başlaması için en az 4 el oynanmış olmalıdır, bu yüzden kontrolleri en baştan itibaren değil de k değişkenimizin 4’lenmesinden itibaren başlatıyoruz. Oyunun kazanının olup olmadığını kontrol eden if’ler sekiz adet olmalı çünkü oyunun bir kazananı olup da bitebilmesi için sekiz farklı kombinasyon vardır(3 yatay,3 dikey veya 2 çapraz olarak). Oyunun bittiğini gösteren if deyimlerinin içine birer if deyimi daha eklemeliyiz. Bu son ekleyeceğimiz if’ler ise kazananın bilgisayar mı yoksa kullanıcı mı olduğunu anlamamıza yarayacak. Eğer 3’lü oluşturan karakterler ‘x’ ise kullanıcı,  ’o’ ise bilgisayar kazanmış demektir. Bunların dışında bir de berabere bitme olasılığını da göz önünde bulundurmamız gerekiyor. Oyunların bitme kontrollerini teker teker sekiz adet kontrolle yapacağız. Oyunun berabere bittiğini ise bu kontrollerin sonuna, hamleler için oluşturduğumuz for döngüsünün sonuna gelip gelmediğimizin kontrolünü yaparak anlayabiliriz. Bu kullandığımız if’lerin sonlarına da birer break eklemeliyiz çünkü oyun bittiği zaman programımız sonlanmalıdır.

C Kodunun Tamamı:

#include <stdio.h>
#include <stdlib.h>

char kullanici_giris(char matris[][3]){
int sat,sut;
printf("Oynamak istediginiz satir/sutun giriniz :\n");
scanf("%d%d",&sat,&sut);

while(sat>2||sat<0||sut<0||sut>2||matris[sat][sut]!='-'){
 printf("Girdiginiz aralik gecersiz tekrar girin : \n");
 scanf("%d%d\n",&sat,&sut);
 scanf("%d%d\n",&sat,&sut);
}

matris[sat][sut]='x';//doğru değer girilmiştir, atamayı yapıyoruz
return matris[3][3];//matrisimizi döndürüyoruz 
}

char bilgisayar_giris(char matris[][3]){
int sat,sut;
sat=rand()%3;//satır için ilk random atamyı yapıyoruz
sut=rand()%3;// sutun için ilk randım atamayı yapıyoruz
while(matris[sat][sut]!='-'){//adres doluysa yeniden random atama yapmalıyız
sat=rand()%3;
sut=rand()%3;
}
printf("\nBilgisayarin hamle yaptigi yer\n");
printf("Satir: %d \n",sat);
printf("Sutun: %d \n\n",sut);
matris[sat][sut]='o';//boş yer bulunmuştur, atamayı yapıyoruz
return matris[3][3];//matrisimizi döndürüyoruz
}

int main() {
 int i,j,k,sat,sut;//değişkenlerimiz
 srand(time(NULL));//random fonksiyonun her seferinde 
                               //farklı değer vermesi için gerekli kod
 char matris[3][3]={{'-','-','-'},
      {'-','-','-'},
             {'-','-','-'}};//ilklendirme
printf("  0  1  2\n"); 
for(i=0;i<3;i++){
 printf("%d",i);
 for(j=0;j<3;j++){
  printf(" %c ",matris[i][j]);
 }
 printf("\n");
}//ekran göstergesi

 for(k=0;k<9;k++){//maksimum hamle sayısı 9 olduğundan 9'a kadar döndürürüz
  
  if(k%2==0){//kullanıcının başlaması için mod kullanıyoruz
        kullanici_giris(matris);//kullanıcıdan değer isteme fonksiyonu
      
  }
  else{
  //system("CLS");//ekran temizleyicisi
  bilgisayar_giris(matris);//blgsyrın boş yer bulması ve
      //atama yapması için kullanılan foksiyon 
      printf("  0  1  2\n"); 
       for(i=0;i<3;i++){
          printf("%d",i);
           for(j=0;j<3;j++){
                               printf(" %c ",matris[i][j]);
            }
       printf("\n");
       }//ekran göstergesi
    }
 if(k>3){//oyunun kimin kazandığını ya da oyunun berabere bitip bitmediğini
                                      //kontrol ettiğimiz if dizimleri
  
  if(matris[0][0]==matris[0][1]&&matris[0][1]==matris[0][2]){
   printf("OYUN BITTI!!");
   if(matris[0][0]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }   
  }
  if(matris[1][0]==matris[1][1]&&matris[1][1]==matris[1][2]){
   printf("OYUN BITTI!!");
   if(matris[1][0]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }
  }
  if(matris[2][0]==matris[2][1]&&matris[2][1]==matris[2][2]){
   printf("OYUN BITTI!!");
   if(matris[2][0]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }
  }
  if(matris[0][0]==matris[1][0]&&matris[1][0]==matris[2][0]){
   printf("OYUN BITTI!!");
   if(matris[0][0]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }
  }
  if(matris[0][1]==matris[1][1]&&matris[1][1]==matris[2][1]){
   printf("OYUN BITTI!!");
   if(matris[0][1]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }
  }
  if(matris[0][2]==matris[1][2]&&matris[1][2]==matris[2][2]){
   printf("OYUN BITTI!!");
   if(matris[0][2]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }
  }
  if(matris[0][0]==matris[1][1]&&matris[1][1]==matris[2][2]){
   printf("OYUN BITTI!!");
   if(matris[0][0]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }
  }
  if(matris[2][0]==matris[1][1]&&matris[1][1]==matris[0][2]){
   printf("OYUN BITTI!!");
   if(matris[2][0]=='x'){
    printf("TEBRIKLER KAZANDINIZ!!");
    break;
   }
   else{
    printf("MALESEF KAYBETTINIZ");
    break;
   }
  }
  if(k==8){
   printf("OYUN BERABERE BITTI!!");
   break;
  }
  
 }
} 
 return 0;
}

Ekran Çıktıları:

JAVA da Arayüz Kullanarak Kütle İndeksi Bulma

Vücut kitle indeksi kişinin boy ve kilo bilgilerini kullanarak hesaplanır. Bu hesaplama kişinin kilosunun-kg cinsinden- kişinin boy uzunluğunun-cm cinsinden- karesine bölünmesiyle elde edilir. Bu uygulamamızda kişinin vücut kitle indeksini bulan bir program yazacağız.

Programımız için öncelikle bir ara yüz tasarlamalıyız. Tasarladığımız bu ara yüzde  giriş için iki tane textbox , sonucu bulmamız için bir adet buton ve çıktılar için ise iki adet daha textbox’a ihtiyacımız olacak. Bunların için oluşturulan örnek ara yüz  aşağıdaki gibidir:

Programımıza geçmek istersek kısaca şu şekilde işlemeli:

           Öncelikle kişinin boy ve kilo değerlerini istenilen türde kullanıcıdan almalıyız. Daha sonra kullanıcı sonuç bulunması için butona tıkladığında arka planda işlemleri yapmalıyız. Bu işlemin sonucuna göre değerleri belli aralıklarda belli açıklamalarla kullanıcıya bildirmeliyiz.

Programın detaylı açıklaması:

        Öncelikle boy, kilo ve sonuç bilgilerini saklayacağımız değişkenleri tanımlıyoruz. Textbox aracılığıyla alacağımız değerleri String olarak, sonuç değişkenini ise float olarak tanımlayabiliriz. 

         Programın asıl işlem kısmında geçtiğimizde ise butona tıklandığı zaman işlemlerin gerçekleştirmemiz gerekiyor. Bu aşamada ilk önce boy ve kilo değerlerini okumamız gerekiyor. Textbox’lardan gerekli girdileri alıp boy ve kilo String’lerine atıyoruz. Kütle indeksini bulabilmemiz için string olarak aldığımız bu kilo ve boy değerlerini float’a çevirmemiz gerekiyor. Bu çevirme işlemlerini “parse” fonksiyonuyla yapacağız. Kodda göreceğiniz üzere  girdi aldığımız boy string’ini Float.parseFloat(boy) kod satırıyla float değere çeviriyoruz. Aynı şekilde kişinin kilosunu da floata çevirip başta bahsettiğimiz şekilde indeksini buluyoruz ve bu çıkan float sonucu “sonucc” değişkenine atıyoruz. Bulduğumuz sonucu ara yüzümüzde yer alan indeks textbox’una set etmemiz gerekiyor. Ancak sonuç değerimiz float olduğu için bunu öncelikle String’e çevirmeliyiz daha sonra set etmeliyiz. Bunu de 149. Satırdaki gibi String.valueOf(sonucc) koduyla çevirebiliriz. Çevirdiğimiz sonuç değerini de setText() metoduyla ara yüzümüze gönderiyoruz.

Ara yüzümüzde bir de açıklama diye bölümümüz var. Burada da bulduğumuz sonuca göre kişinin ayrıntılı indeksini ekrana yazdıracağız. Kullanacağımız sonuçların aralıkları ve açıklamaları şunlardır:

0-18.4: Zayıf

18.5-24.9: Normal

25.0-29.9: Fazla Kilolu

30.0-34.9: Şişman (Obez) - I. Sınıf

35.0-44.9: Şişman (Obez) - II. Sınıf

45.0 ve üstü: Aşırı Şişman (Aşırı Obez) - III. Sınıf

Programın bu kısmında da sonucc değerinin bu aralıklardan hangisine dahil  olduğunu bulmamız gerekiyor. Gerekli kontrolleri yapıp bulduğumuz aralığın açıklamasını da açıklama textbox’una set ederek programımızı sonlandırıyoruz.

Programın Kodu:

Programın Ekran Çıktıları:                          

C# : Access Veri Tabanı Kayıt Ekleme

          Veri tabanının yazacağımız programa eklenmesinin en büyük nedenlerinden biri, eklediğimiz kayıtları tutmak ve bunları görüntülemektir. Bunun için form üzerine gerekli nesneleri kullanarak bir kayıt ekleme arayüzü oluşturup kayıtları bu arayüz üzerinden eklemek daha kullanışlı olacaktır.

          Access üzerine kayıt eklemek için Insert Into SQL veri ekleme komutunu kullanacağız. Bunun için sırasıyla aşağıdaki işlemleri yapacağız:

1. Öncelikle verileri ekleyeceğimiz veri tabanının yüklü olması gerekmektedir. Yüklü değilse bunu yükleyeceğiz. Bu yükleme işlemini tıklayarak buradaki gibi adım adım yapacağız.

2. Access'ten veri çekebilmemiz ve access veri tabanı işlemleri için Data ve Data.OleDb sınıflarını projemize eklemek zorundayız.

3. Eklediğimiz access veri tabanı ile projemiz arasında bağlantı kurmamız gerekiyor. Bunun için OleDbConnection bağlantı nesnesini kullanacağız.

"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" yolu mdb ve accdb uzantılı access dosyalarında farklılık göstermektedir. Bunu Server Explorer penceresine tıklayıp Properties penceresinde Connection String alanından bakarak kullanacağımız yolu bulabiliriz. Adres uzantısını Application.Startup kod parçacığı ile değiştirirsek veri tabanımız verileri projemizdeki ekli olan kaynaktan alacaktır.

4. SQL komutunu kullanıyoruz ve ekleyeceğimiz verileri form üzerindeki textboxlardan alıyoruz. Kodlarda karışıklığı önlemek için bu SQL komutumuzu kod adındaki bir string değişkene atıyoruz.

5. 

           Bu kod parçası ile urun_kayit tablosuna kaydımızı ekliyoruz. Kaydı eklemek için OleDbCommand ' ın  ExecuteNonQuery özelliğini kullanıyoruz. Kayıt ekleme işlemimizden sonra kaydın eklendiğine dair mesaj ekliyoruz.

Kodun Tamamı

C# : Olasılık Hesabı - 1

          Bir torbanın içinde 60 tane topumuz var. Bunların 10 tanesi kırmızı, 50 tanesi de mavidir. Bu torbanın içerisinden her bir top geri atılmak koşulu ile 5 kez top alınacaktır. Topların kırmızı gelme olasılığı nedir?

İpucu: 5 defa random ile 1 ile 60 arasında bu sayılar dahil olmak üzere sayı seçilecektir. Tabi biz 60 kadar olan sayılardan ardışık 10 sayıyı kırmızı topumuz olarak alacağız(12-21,1-10, vb.)

Kod

Başlıca Yapılanlar:

• Kırmızı toplarımızın sayısını tutacak bir değişken tanımlıyoruz.
• rast_sayi adında 1'den 60'a kadar olan sayılardan rastgele bir değer seçmesi için random değişken tanımlıyoruz. 
• Torbanın içerisinden 5 kez top seçileceği için 5 kez dönen bir for döngüsü tanımlıyoruz.
• Her bir adımda 1'den 60'a kadar rastgele bir sayı seçilip top değişkenine atılıyor. Kırmızı toplar için belirlediğim 1 ile 10 arasındaki aralıkta olup olmadığı kontrol ediliyor. Eğer ki istenilen aralıkta ise kırmızı topların sayısı 1 artıyor.
• Sonucumu da kırmızı topların sayısını tutan değişkeni 5' e bölerek olasılığımı hesaplıyorum ve console üzerine yazdırıyorum.

NOT:  Olasılık hesabı olduğu için kodlar her çalıştırıldığında farklı sonuçlar gelecektir.

İpucu:

          Olasılık hesaplarında sonuç 0 ile 1 arasında olduğundan ondalıklı değerler çıkmaktadır. Fakat bizim değerleri tuttuğumuz değişkenler tam sayı türündeki integer değerlerdir. Double ya da ondalık değer yazacak bir değişken türü kullanmadan olasılık hesabımda virgülden sonraki kaç değeri görmek istiyorsam nokta koyup bir o kadar da sıfır koymalıyız. 

Ekran Görüntüsü

C# : XML Dosyasından Veri Alma

          Visual Studio üzerinde C# ile hazırlayacağımız uygulamalara dışarıdan veri çekmek için kullandığımız yöntemlerden biri de XML dosyasından veri çekmektir. XML dosyasından veri almak için öncelikle XML dosyasının nasıl oluşturulduğunu ve hazırlanan projeler kapsamında nasıl kullanıldığını göreceğiz. Bunun için programlama dersi kapsamında gördüğüm örnek üzerinden XML dosyasının bir proje üzerinde kullanımını göstereceğim.

         Basit bir resimli sözlük uygulaması üzerinden gideceğiz. Öncelikle aşağıdaki şekilde formumuzu tasarlıyoruz.

          Tasarımımızı tamamladıktan sonra projemize Project menüsünden Add New Item seçeneği ile XML File seçeneğini tıklayarak ve isim vererek dahil ediyoruz. Bunu Solution penceresinde.xml uzantılı bir dosya olarak görebiliriz. Fakat oluşturduğunuz bu XML dosyasını debug klasörü içine de kopyalayacağız. Ya da var olan XML leri projemize dışarıdan ekleyerek de kullanabiliriz.

          Karşımıza aşağıdaki şekilde boş bir XML dosyası açılacaktır.

          Sözlükte kullanacağımız her bir kelimenin türkçe, ingilizce ve resim adını kelime adında bloklar adında XML dosyası içerinde gruplayacağız. Kelime blogu adı altında türkçe kelimeleri turkce blogundan, resimlerin isimlerini resim blogu adı altında, ingilizce kelimeleri ingilizce blogu adında toplayacağız.

Not: Bloglar arasında veri eklerken boşlukların da dikkate alındığı unutulmamalıdır. Özellikle de yol belirten verilerin yazımında sorun çıkabilir.

          Projemizde ekli olan bu XML dosyasını kullanmak için projemize XML kütüphanesini dahil edeceğiz.

          XML dosyasını XML kütüphanesinin sınıfları olan  XmlDocument, XmlNodeList sınıfları ile projemizde kullanacağız. XmlDocunent ile XML nesnemizi oluşturuyoruz. XmlNodeList ile de aynı etiketteki blogları tutmak için bir liste oluşturur. Ayrıca kelimelerin gösteriminde listedeki konumunu tutması için global bir sira değişkeni tanımladık.

          Projemizde uygulama çalıştığı anda XML üzerinden işlem yapılacağı için Public Form1( ) blogu içinde yapılması gerekenleri yazacağız. XmlDocunent.Load ile kullanacağımız XML dosyasını belirteceğiz. XmlDocunent.SelectNodes özelliği ile de hangi etiket altındaki blogları kelimeler listesine atayacağımızı belirtiyoruz. Form açıldığında XML dosyası üzerinde yer alan ilk kelime olacağı için buton ile geri alınacak bir kelime olmadığı için geri al butonunu pasif yapıyoruz. XML dosyası üzerinden sıradaki çağrılan  kelimeyi getiren show adında oluşturduğumuz metotu çağırıyoruz.

          XML dosyasındaki verilerin form üzerindeki nesnelere yerleştirilmesi için bir show adında bir metot oluşturduk. Burada yapılanları açıklayacak olursak; daha sonradan ilk ve son kelime olduğunu belirten kontrolümüzü yaptığımız için öncelikle her iki butonumuzu da aktif yapıyoruz. XmlNode sınıfında dugum adında kelime gruplarının bir alt blokları olan resim, turkce ve ingilizce bloklarındaki verileri tutmak için bir değişken oluşturuyoruz. Sırası ile resim, ingilizce, turkce bloklarındaki verileri çekip bunları XmlNode.InnerText komutu ile form üzerindeki atamak istediğimiz nesnelere atıyoruz. Son olarak XML dosyasından çekilen kelimenin ilk ya da son kelime olup olmadığını kontrol eden bir if yapısı ile kontrol yapıyoruz. Kontrol sağlandığında da butonların pasif olmasını sağlıyoruz.

         Ardından ileri ve geri butonlarımızda oluşturduğumuz show metodunu çağrıyoruz. Onun öncesinde geriyse sıramızı azaltıyor ileriyse artırıyoruz ve ona göre XML dosyasındaki indeksini belirliyoruz.

Not: Verileri çekeceğimiz XML dosyasının, kullanacağımız resimlerin debug altında tek bir klasörde bulunmasına dikkat etmeliyiz.

Ekran Görüntüsü

Kodların Tamamı