Eğer genleşme ve aşınma hakkında daha fazla bilgi istiyorsanız Dilation – Erosion bağlantılarını takip edebilirsiniz.

void Dilation()
{
    if (!dilationDone)
    {

        dilationPixelArray = new int[imageWidth, imageHeight];
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (binaryPixelArray[i, j] == 255)
                {
                    dilationPixelArray[i - 1, j] = 255;
                    dilationPixelArray[i, j - 1] = 255;
                    dilationPixelArray[i, j + 1] = 255;
                    dilationPixelArray[i + 1, j] = 255;
                }
            }
        }
    }
    else
    {
        int[,] tempArray = new int[imageWidth, imageHeight];
        Array.Copy(dilationPixelArray, tempArray, imageWidth * imageHeight);
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (tempArray[i, j] == 255)
                {
                    dilationPixelArray[i - 1, j] = 255;
                    dilationPixelArray[i, j - 1] = 255;
                    dilationPixelArray[i, j + 1] = 255;
                    dilationPixelArray[i + 1, j] = 255;
                }
            }
        }
    }

}
void Erosion()
{
    if (!erosionDone)
    {
        erosionPixelArray = new int[imageWidth, imageHeight];
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (binaryPixelArray[i, j] == 255)
                {
                    if (binaryPixelArray[i, j - 1] == 0 ||
                        binaryPixelArray[i - 1, j] == 0 ||
                        binaryPixelArray[i + 1, j] == 0 ||
                        binaryPixelArray[i, j + 1] == 0
                        )
                    {
                        erosionPixelArray[i - 1, j] = 0;
                        erosionPixelArray[i, j - 1] = 0;
                        erosionPixelArray[i, j + 1] = 0;
                        erosionPixelArray[i + 1, j] = 0;
                        erosionPixelArray[i, j] = 0;
                    }
                    else
                    {
                        erosionPixelArray[i, j] = binaryPixelArray[i, j];
                    }
                }
                else
                {
                    erosionPixelArray[i, j] = binaryPixelArray[i, j];
                }
            }
        }
    }
    else
    {
        int[,] tempArray = new int[imageWidth, imageHeight];
        Array.Copy(erosionPixelArray, tempArray, imageWidth * imageHeight);
        for (int i = 1; i < imageWidth - 1; i++)
        {
            for (int j = 1; j < imageHeight - 1; j++)
            {
                if (tempArray[i, j] == 255)
                {
                    if (tempArray[i, j - 1] == 0 ||
                        tempArray[i - 1, j] == 0 ||
                        tempArray[i + 1, j] == 0 ||
                        tempArray[i, j + 1] == 0
                        )
                    {
                        erosionPixelArray[i - 1, j] = 0;
                        erosionPixelArray[i, j - 1] = 0;
                        erosionPixelArray[i, j + 1] = 0;
                        erosionPixelArray[i + 1, j] = 0;
                        erosionPixelArray[i, j] = 0;
                    }
                    else
                    {
                        erosionPixelArray[i, j] = tempArray[i, j];
                    }
                }
                else
                {
                    erosionPixelArray[i, j] = tempArray[i, j];
                }
            }
        }
    }
}

Bundan önceki yazılardaki yapıyı kullandığınızı varsayarak yukarıdaki iki fonksiyonu aşağıdaki şekilde çağırmanız gerekli. Bu fonksiyonların yaptığı iş ise eğer resim ikili seviyeye indirgenmemişse (siyah-beyaz) önce bu işlemi yapmak. Tabii ikiliye çevirmek için herhangi bir eşik değeri belirlenmemişse otsu fonksiyonunu çağırarak önce bir eşik değeri hesaplatıyoruz. Binary fonksyionu ise 0-255 arasındaki parametreyi eşik değeri olarak kullanarak resmi ikili seviyeye indirgiyor, parametrenin 256 olması ise otsu ile hesaplanan eşik değerini alması içindir.

public void ShowDilation()
{
    if (!dilationDone)
    {
        if (!binaryDone)
        {
            if (otsuValue == 0)
                Otsu();
            Binary(256);
        }
        Dilation();
        dilationDone = true;
    }
    else
    {
        Dilation();
    }
    SetImage(ref dilationPixelArray);
}

public void ShowErosion()
{
    if (!erosionDone)
    {
        if (!binaryDone)
        {
            if (otsuValue == 0)
                Otsu();
            Binary(256);
        }
        Erosion();
        erosionDone = true;
    }
    else
    {
        Erosion();
    }
    SetImage(ref erosionPixelArray);
}

Önceki yazıda gri seviyeye çevirilmiş görüntümüz vardı eğer bu görüntüyü siyah beyaza çevirmek istiyorsanız bunun için bir eşik değeri seçerek 0-255 arasındaki gri seviye görüntüyü bu seviyeye göre siyah veya beyaz olarak ayırmak gerekiyor. Eşik değerini sabit bir değer olarak belirleyebileceğiniz gibi her görüntüye göre dinamik olarak bir eşik değeri belirleyebilen bir yöntem de mevcuttur: otsu. Otsu algoritması sayesinde üzerinde çalıştığınız görüntüye özel bir eşik değerini otomatik olarak belirleyebilirsiniz. Bunun için görüntünün histogram dizisine ihtiyacınız olacak. İlk yazıda verdiğim kodda histogram çıkartma özelliği yoktu. Bunun için aşağıdaki kodu kullanabilirsiniz:

int[,] pixelArray = new int[pictureBox1.Image.Height, pictureBox1.Image.Width];
int[,] greyPixelArray = new int[pictureBox1.Image.Height, pictureBox1.Image.Width];
int[] histogram = new int[256];

void BuildPixelArray(ref Image myImage)
{
pixelArray = new int[imageWidth, imageHeight];
greyPixelArray = new int[imageWidth, imageHeight];
Rectangle rect = new Rectangle(0, 0, myImage.Width, myImage.Height);
Bitmap temp = new Bitmap(myImage);
BitmapData bmpData = temp.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
int remain = bmpData.Stride - bmpData.Width * 3;
unsafe
{
byte* ptr = (byte*)bmpData.Scan0;
for (int j = 0; j < bmpData.Height; j++)
{
for (int i = 0; i < bmpData.Width; i++)
{
pixelArray[i, j] = ptr[0] + ptr[1] * 256 + ptr[2] * 256 * 256;
greyPixelArray[i, j] = (int)((double)ptr[0] * 0.11 + (double)ptr[1] * 0.59 + (double)ptr[2] * 0.3);
histogram[greyPixelArray[i, j]]++;
ptr += 3;
}
ptr += remain;
}
}
temp.UnlockBits(bmpData);
}

Burada histogram dizisini de oluşturduktan sonra artık otsu algoritması sayesinde dinamik olarak eşik değerini belirleyebiliriz:

int otsuValue;

void Otsu()
{
double fmax = -1.0;
double m1, m2, S, toplam1 = 0.0, toplam2 = 0.0;
int nTop = 0, n1 = 0, n2;

for (int i = 0; i < 256; i++)
{
toplam1 += (double)i * (double)histogram[i];
nTop += histogram[i];
}

for (int i = 0; i < 256; i++)
{
n1 += histogram[i];
if (n1 == 0)
continue;
n2 = nTop - n1;
if (n2 == 0)
break;
toplam2 += (double)i * (double)histogram[i];
m1 = toplam2 / n1;
m2 = (toplam1 - toplam2) / n2;
S = (double)n1 * (double)n2 * (m1 - m2) * (m1 - m2);
if (S > fmax)
{
fmax = S;
otsuValue = i;
}
}
}

Otsu veya sabit bir değere göre görüntüyü siyah beyaza çevirecek kod ise aşağıdadır. Bu fonksiyonun aldığı argThreshold parametresi eşik değerini belirtern 0-255 arasında bir değerdir.

void Binary(int argThreshold)
{
binaryPixelArray = new int[imageWidth, imageHeight];
for (int i = 0; i < imageWidth; i++)
{
for (int j = 0; j < imageHeight; j++)
{
if (greyPixelArray[i, j] < threshold)
binaryPixelArray[i, j] = 0;
else
binaryPixelArray[i, j] = 255;
}
}
}

Görüntüyü siyah beyaza çevirdikten sonra eğer kenar bulma algoritmalarını kullanmak isterseniz bir kaç seçeneğiniz mevcut. Bunlardan en popüleri sobel kenar bulma filtresidir. Aşağıdaki fonksiyonda type parametresi hangi tür kenarların bulunacağını belirtmek içindir. Dikey, yatay, köşegen şeklindeki kenarları veya tamamını ayrı ayrı bulabilirsiniz.

void Sobel(int type)
{
int normalizeMax = 0;
int normalizeMin = maxIntVal;

sobelPixelArray = new int[imageWidth, imageHeight];
int[,] sobelArray1 =
new int[3, 3] {
{ 1, 0, -1 },
{ 2, 0, -2 },
{ 1, 0, -1 }
};

int[,] sobelArray2 =
new int[3, 3] {
{ 1, 2, 1 },
{ 0, 0, 0 },
{-1,-2,-1 }
};
int[,] sobelArray3 =
new int[3, 3] {
{ 2, 1, 0 },
{ 1, 0,-1 },
{ 0,-1,-2 }
};

int G1, G2, G3;
for (int i = 1; i < imageWidth - 1; i++)
{
for (int j = 1; j < imageHeight - 1; j++)
{
G1 = 0;
G2 = 0;
G3 = 0;
for (int k = -1; k < 2; k++)
{
for (int l = -1; l < 2; l++)
{
G1 += greyPixelArray[i + k, j + l] * sobelArray1[k + 1, l + 1];
G2 += greyPixelArray[i + k, j + l] * sobelArray2[k + 1, l + 1];
G3 += greyPixelArray[i + k, j + l] * sobelArray3[k + 1, l + 1];
}
}
if(type == 0)
{
sobelPixelArray[i, j] = Math.Abs(G1) + Math.Abs(G2) + Math.Abs(G3);
}
else if (type == 1)
{
sobelPixelArray[i, j] = Math.Abs(G2);
}
else if (type == 2)
{
sobelPixelArray[i, j] = Math.Abs(G1);
}
else if (type == 3)
{
sobelPixelArray[i, j] = Math.Abs(G3);
}

if (normalizeMax < sobelPixelArray[i, j])
normalizeMax = sobelPixelArray[i, j];
if (normalizeMin > sobelPixelArray[i, j])
normalizeMin = sobelPixelArray[i, j];
}
}

NormalizeArray(ref sobelPixelArray, normalizeMax, normalizeMin);
}

Yukarıda bulunan kodun en altında çağırılan normalize fonksiyonu ise sonuç dizisini 0-255 değerleri arasına düşürmek içindir:

void NormalizeArray(ref int[,] sourceArray,int normalizeMax,int normalizeMin)
{

int factor = normalizeMax - normalizeMin;
for (int i = 0; i < sourceArray.GetLength(0); i++)
{
for (int j = 0; j < sourceArray.GetLength(1); j++)
{
sourceArray[i, j] = (sourceArray[i, j] - normalizeMin) * 255 / factor;
}
}
}

Bir diğer kenar bulma yöntemi ise Prewitt’tir:

int[,] prewittPixelArray;

void Prewitt()
{
int normalizeMax = 0;
int normalizeMin = maxIntVal;
prewittPixelArray = new int[imageWidth, imageHeight];
int[,] PrewittArray1 =
new int[3, 3] {
{-1,-1,-1 },
{ 0, 0, 0 },
{ 1, 1, 1 }
};

int[,] PrewittArray2 =
new int[3, 3] {
{ -1, 0, 1 },
{ -1, 0, 1 },
{ -1, 0, 1 }
};
int[,] PrewittArray3 =
new int[3, 3] {
{-1,-1, 0 },
{-1, 0, 1 },
{ 0, 1, 1 }
};

int[,] PrewittArray4 =
new int[3, 3] {
{ 1, 1, 0 },
{ 1, 0,-1 },
{ 0,-1,-1 }
};

int G1, G2, G3, G4;
for (int i = 1; i < imageWidth - 1; i++)
{
for (int j = 1; j < imageHeight - 1; j++)
{
G1 = 0;
G2 = 0;
G3 = 0;
G4 = 0;
for (int k = -1; k < 2; k++)
{
for (int l = -1; l < 2; l++)
{
G1 += greyPixelArray[i + k, j + l] * PrewittArray1[k + 1, l + 1];
G2 += greyPixelArray[i + k, j + l] * PrewittArray2[k + 1, l + 1];
G3 += greyPixelArray[i + k, j + l] * PrewittArray3[k + 1, l + 1];
G4 += greyPixelArray[i + k, j + l] * PrewittArray4[k + 1, l + 1];
}
}

prewittPixelArray[i, j] = Math.Abs(G1) + Math.Abs(G2) + Math.Abs(G3) + Math.Abs(G4);
if (normalizeMax < prewittPixelArray[i, j])
normalizeMax = prewittPixelArray[i, j];
if (normalizeMin > prewittPixelArray[i, j])
normalizeMin = prewittPixelArray[i, j];
}
}

int factor = normalizeMax - normalizeMin;
for (int j = 1; j < imageHeight - 1; j++)
{
for (int i = 1; i < imageWidth - 1; i++)
{
prewittPixelArray[i, j] = (prewittPixelArray[i, j] - normalizeMin) * 255 / factor;
}
}
}

Prewitt ve sobel’e alternatif olarak Robert kenar bulma filtresi de mevcuttur :

int[,] robertPixelArray;

void Robert()
{

robertPixelArray = new int[imageWidth, imageHeight];
for (int i = 1; i < imageHeight - 1; i++)
{
for (int j = 1; j < imageWidth - 1; j++)
{
robertPixelArray[j, i] = Math.Abs(greyPixelArray[j, i] - greyPixelArray[j - 1, i - 1]) + Math.Abs(greyPixelArray[j, i - 1] - greyPixelArray[j - 1, i]);
}
}
}

Eğer kenar bulma algoritmalarını kullanmadan önce görüntüdeki gürültüleri temizlemek istiyorsanız mean, median ve gaussian filtereleri ile bu işlemi yapabilirsiniz.

Mean filtresi :

int[,] meanPixelArray;

void Mean()
{
meanPixelArray = new int[imageWidth, imageHeight];
for (int i = 1; i < imageHeight - 1; i++)
{
for (int j = 1; j < imageWidth - 1; j++)
{
meanPixelArray[j, i] =
(
greyPixelArray[j, i - 1]
+ greyPixelArray[j, i + 1]
+ greyPixelArray[j, i]
+ greyPixelArray[j - 1, i - 1]
+ greyPixelArray[j - 1, i + 1]
+ greyPixelArray[j - 1, i]
+ greyPixelArray[j + 1, i - 1]
+ greyPixelArray[j + 1, i + 1]
+ greyPixelArray[j + 1, i]
) / 9;
}
}
}

Median filtresi:

int[,] medianPixelArray;

void Median()
{

medianPixelArray = new int[imageWidth, imageHeight];
int[] tempArray = new int[9];
for (int i = 1; i < imageHeight - 1; i++)
{
for (int j = 1; j < imageWidth - 1; j++)
{
int counter = 0;
for (int k = -1; k < 2; k++)
{
for (int l = -1; l < 2; l++)
{
tempArray[counter++] = greyPixelArray[j + l, i + k];
}
}
System.Array.Sort(tempArray);
medianPixelArray[j, i] = tempArray[4];
}
}
}

Gaussian filtresi

int[,] gaussianPixelArray;

void Gaussian()
{
gaussianPixelArray = new int[imageWidth, imageHeight];

int[,] gaussianArray =
new int[5, 5] {
{1,4,7,4,1},
{4,16,26,16,4},
{7,26,41,26,7},
{4,16,26,16,4},
{1,4,7,4,1}
};
int tempSum;
for (int i = 2; i < imageHeight - 2; i++)
{
for (int j = 2; j < imageWidth - 2; j++)
{
tempSum = 0;
for (int k = -2; k < 3; k++)
{
for (int l = -2; l < 3; l++)
{
tempSum += greyPixelArray[j + l, i + k] * gaussianArray[k + 2, l + 2];
}
}
gaussianPixelArray[j, i] = tempSum / 273;
}
}
}

Daha sonraki yazıda yapısal (morfolojik) işlemleri yapan filtreleri de açıklamalarıyla birlikte vermeyi düşünüyorum. O zamana kadar hepinize kolay gelsin.

DOMAINS
liste=integer*
matris = liste*
int=integer

PREDICATES
ilkEleman(liste,int)
uzunluk(liste,int)
detBul(liste,liste,int)
ilkleriSil(matris,matris)
negatif(int,int)
sonaAt(matris,matris)
tersCevirListe(matris,matris)
tersCeviriciListe(matris,matris,matris)
det(matris,int,int,int)

CLAUSES
ilkEleman([X|_],X).

uzunluk([],0).
uzunluk([_|K],U):-uzunluk(K,X),U=X+1.

ilkleriSil([],[]).
ilkleriSil([[_|BasKuyruk]|Kuyruk1],[ BasKuyruk |SonucKuyruk]):-
ilkleriSil(Kuyruk1,SonucKuyruk).

negatif(-1,1).
negatif(1,-1).

sonaAt([Bas|Kuyruk],Sonuc):-
tersCevirListe(Kuyruk,TersKuyruk),
tersCevirListe([Bas|TersKuyruk],Sonuc).

tersCevirListe(X,Y):-tersCeviriciListe(X,[],Y).
tersCeviriciListe([],X,X).
tersCeviriciListe([B|K],TMP,SONUC) :-
tersCeviriciListe(K,[B|TMP],SONUC).

detBul([Bas1,Kuyruk1|_],[Bas2,Kuyruk2|_],Sonuc):-
Sonuc = Bas1*Kuyruk2-Bas2*Kuyruk1.

det([Bas1,Bas2|_],_,Sonuc,_):-
uzunluk(Bas1,En),
En<=2,
detBul(Bas1,Bas2,Sonuc),!.

det([Bas|_],Sayac,0,_):-uzunluk(Bas,En),En<=Sayac,!.

det([Bas|Kuyruk],Sayac,Sonuc,_):-
YeniSayac=Sayac+1,
uzunluk(Bas,En),
En>Sayac,
En<=3,
sonaAt([Bas|Kuyruk],Sonda),
ilkEleman(Bas,KatSayi),
ilkleriSil(Kuyruk,KuyrukOrta),
det(KuyrukOrta,0,OrtaSonuc,_),
det(Sonda,YeniSayac,YanSonuc,_),
Sonuc=(KatSayi*OrtaSonuc)+YanSonuc,!.

det([Bas|Kuyruk],Sayac,Sonuc,X):-
YeniSayac=Sayac+1,
uzunluk(Bas,En),
En>Sayac,
sonaAt([Bas|Kuyruk],Sonda),
ilkEleman(Bas,KatSayi),
ilkleriSil(Kuyruk,KuyrukOrta),
negatif(X,Y),
det(KuyrukOrta,0,OrtaSonuc,Y),
det(Sonda,YeniSayac,YanSonuc,Y),
Sonuc=(X*KatSayi*OrtaSonuc)+YanSonuc.

GOAL
write("_____"),nl,det([[1,2,4,8],[2,2,7,11],[3,6,3,12],[4,13,0,5]],0,Sonuc,1),write(Sonuc).

Programda kullanılan yüklemlere tek tek bakacak olursak yüklemlerin yaptığı görevler aşağıda açıklanmıştır:

• ilkEleman(liste,int):  aldığı tamsayı listesinin ilk elemanını vermektedir.
• uzunluk(liste,int) :  aldığı tamsayı listesinin eleman sayısını vermektedir.
• detBul(liste,liste,int) :  2×2 matrisin çarpımını yapar. Aldığı iki listenin uzunluğu da birbirine eşit ve iki olmalıdır.
• ilkleriSil(matris,matris) :  Minörleri ilk satıra göre açtığım için verilen matrisin ilk satırını silmek için bu yüklem kullanılmıştır.
• negatif(-1,1) :  Kofaktörlerin katsayılarını hesaplamak için kullanılmıştır. Her kofaktörde bir önceki kofaktörün katsayısının negatifi hesaplanmıştır.
• sonaAt(matris,matris) :  Minörlerin hesabında bir sonraki sütuna göre açılım yapıldığında bu yüklem sayesinde ilk sütun sona atılarak ikinci sütun ilk sütun haline getirilir. Ayrıca 3×3 matrislerde determinant hesaplanırken katsayılarının sırasıyla +1 ve -1 ile çarpılmasına bu yüklem sayesinde gerek kalmamıştır.
• tersCevirListe(matris,matris) :  Sona at yükleminde ilk sütunu sona atmak için varolan matrisin ilk sütunu alınarak kalan matris ters çevirilerek ilk sütun başa koyulduktan sonra matris tekrar ters çevrilmiştir. Bu yüklem ters çevirme işlemini yapmaktadır.
• tersCeviriciListe(matris,matris,matris) :  tersCevirListe yükleminde kullanılan geçici matrisi bu yüklem ile tanımlayarak asıl yüklemin iki parametre ile gerekli çevirmeyi yapması sağlanmıştır.
  det(matris,int,int,int) ) : det yüklemi bütün determinant çarpım işlemlerini gerçekleştirmektedir.

Yukarıdan aşağıya doğru yazılmış dört yüklemi sırasıyla incelersek;

1. İlk yüklem 2×2 matris kaldığı zaman bunu detBul yüklemi sayesinde hesaplar ver geri döndürür.
2. İkinci yüklem ise ilk sütunu sona atarak hesaplanan determinantların durma koşulunu belirler. Eğer sayac değişkeni sıfır olmuşsa yani n sütun varsa ve her biri için açılım yapılmışsa sonuç değeri sıfır olarak döndürür.
3. Üçüncü yüklem ise 3. dereceden matrislerin determinant hesabında kullanılmıştır. 3. Dereceden matrislerde daha fazla alt matris olmadığından dolayı katsayı değişimine gerek kalmamıştır.
4. Dördüncü yüklem ise 4. derece ve üstü matrislerin determinantını hesaplarken kofaktörü değiştirmek için kullanılmıştır.

PREDICATES
listeGoster(liste)
uzunluk(liste,int)
uye(int,liste)
ekle(int,liste,liste)
yoksaEkle(int,liste,liste)
sil(int,liste,liste)
hepsiniSil(int,liste,liste)
elemanTopla(liste,int)
arttir(int,liste,liste)
birles(liste,liste,liste)
birlesim(liste,liste,liste)
kesisim(liste,liste,liste)
buda(liste,liste)
tersCevir(liste,liste)
tersCevirici(liste,liste,liste)
prefix(liste,liste)
suffix(liste,liste)

CLAUSES
listeGoster([]).
listeGoster([B|K]):-write(B),nl,listeGoster(K).

uzunluk([],0).
uzunluk([_|K],U):-uzunluk(K,X),U=X+1.

uye(X,[X|_]).
uye(X,[_|K]):-uye(X,K).

ekle(X,L,[X|L]).

yoksaEkle(X,L,L):-uye(X,L),!.
yoksaEkle(X,L,[X|L]).

sil(X,[X|L],L).
sil(X,[B|K1],[B|K2]):-sil(X,K1,K2).

hepsiniSil(_,[],[]).
hepsiniSil(X,[X|L],M):-sil(X,L,M),!.
hepsiniSil(X,[Y|K1],[Y|K2]):-sil(X,K1,K2).

elemanTopla([],0).
elemanTopla([X|K],T):-elemanTopla(K,Y),T=Y+X.

arttir(_,[],[]).
arttir(X,[B1|K1],[B2|K2]):-B2=B1+X,arttir(X,K1,K2).

birles([],L,L).
birles([B|K1],L2,[B|K2]):-birles(K1,L2,K2).

birlesim([],L,L).
birlesim([B|K1],L2,K2):- uye(B,L2),birlesim(K1,L2,K2),!.
birlesim([B|K1],L2,[B|K2]):- birlesim(K1,L2,K2).

kesisim([],_,[]).
kesisim(_,[],[]).
kesisim([B|K1],L2,[B|K2]):-uye(B,L2),kesisim(K1,L2,K2),!.
kesisim([_|K1],L2,K2):-kesisim(K1,L2,K2).

buda([],[]).
buda([B|K],L):- uye(B,K),buda(K,L),!.
buda([B|K1],[B|K2]):- buda(K1,K2).

tersCevir(X,Y):-tersCevirici(X,[],Y).
tersCevirici([],X,X).
tersCevirici([B|K],TMP,SONUC) :- tersCevirici(K,[B|TMP],SONUC).

prefix([],_).
prefix([B|K1],[B|K2]):-prefix(K1,K2).

suffix(X,Y):-tersCevir(X,TX),tersCevir(Y,TY),prefix(TX,TY).

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.awt.datatransfer.Clipboard;

public class SozLook extends JFrame implements ActionListener,KeyListener
{

public File dosya;					//Kelimelerin okunacağı dosya
public FileReader acilan_dosya;
public BufferedReader girdi;
public String yazilar="";			//Dosyadan okunan veriler
public int myIndex;					//TR->ING  ING->TR çevrim türünü tutuyor

public JTextField Word;				//Kelime girilen TextField
public JTextField Sonuc;			//Sonucu gösteren TextField
public JPanel myPanel1,myPanel2;

public JList list;					//Seçim listesi
public JListData ldata;

public JRadioButton trButton,ingButton;
public ButtonGroup 	myGroup;

public String urlString;
public String gelen;
public Boolean bulundu=false;
public Pattern urlPattern;
public Matcher urlMatcher;

public void init()
{
Container container = getContentPane();
container.setLayout(new BorderLayout(25,5));

myPanel1 = new JPanel();
myPanel1.setLayout(new BorderLayout(25,5));

myPanel2 = new JPanel();
myPanel2.setLayout(new FlowLayout());

Word = new JTextField(25);
Word.addKeyListener(this);

Sonuc = new JTextField(50);
Sonuc.setEditable(false);

ingButton = new JRadioButton("İngilizce -> Türkçe", true);
trButton  = new JRadioButton("Türkçe -> İngilizce", false);
trButton.addActionListener(this);
ingButton.addActionListener(this);

myGroup= new ButtonGroup();
myGroup.add(trButton);
myGroup.add(ingButton);

myPanel2.add(ingButton);
myPanel2.add(trButton);
myPanel1.add(Word,BorderLayout.NORTH);
myPanel1.add(Sonuc,BorderLayout.SOUTH);

JScrollPane sp = new JScrollPane();
myPanel1.add("Center", sp);

ldata = new JListData();
list= new JList(ldata); 	//data verisiyle yeni liste oluşturuyor
sp.getViewport().add(list); //scrollpane

container.add(myPanel1,BorderLayout.CENTER);
container.add(myPanel2,BorderLayout.SOUTH);

setSize(500,300);
setResizable(false);

list.addMouseListener(new MouseAdapter()
{
public void mouseReleased( MouseEvent e )
{
if(!list.isSelectionEmpty())
elemanSecildi();
}
}
);

}

public SozLook()
{
super("SözLook - KTÜ");
init();
setVisible(true);
}

public static void main(String args[])
{
new SozLook();
}

public void actionPerformed( ActionEvent actionEvent )
{
Sonuc.setText("");
ldata.temizle();
ldata.addElement("");
list.disable();
harfYazildi();
return;
}

public void keyPressed( KeyEvent event )
{
}
public void keyTyped( KeyEvent event )
{
}
public void keyReleased( KeyEvent event )
{
harfYazildi();
}

public void harfYazildi()
{
Sonuc.setText("");
if(Word.getText().toLowerCase().length()==0)
{
ldata.temizle();
ldata.addElement("");
list.disable();
return;
}

bulundu=false;
ldata.temizle();
list.enable();
list.clearSelection();

if(ingButton.isSelected())
urlString ="^"+Word.getText().toLowerCase()+"[^\t]*";
else
urlString ="\t"+Word.getText().toLowerCase()+".*$";

bul(0);
}

public void elemanSecildi()
{
if(ingButton.isSelected())
{
urlString ="^"+list.getSelectedValue().toString()+".*\t.*";
myIndex=1;
}
else
{
urlString ="^.*"+list.getSelectedValue().toString()+".*$";
myIndex=0;
}
bul(1);
}

public void bul(int tur)
{
try
{
dosya = new File( "kelimeler.txt" );
acilan_dosya = new FileReader ( dosya );
girdi = new BufferedReader ( acilan_dosya );
urlPattern = Pattern.compile(urlString);

while ( (yazilar=girdi.readLine()) != null )
{
urlMatcher = urlPattern.matcher(yazilar);
if(urlMatcher.find())
{
if(tur==0)	//harfe göre kelime aranıyor
{
bulundu=true;
ldata.addElement(urlMatcher.group());
}
else		//listeden seçilen kelimenin karşılığı aranıyor
{
String [] bulunan=urlMatcher.group().split("\t");
Sonuc.setText(bulunan[myIndex]);
break;
}
}
if(yazilar.toLowerCase().toCharArray()[0]>Word.getText().toLowerCase().toCharArray()[0])
break;
}

if(tur==0 && !bulundu)
{
ldata.addElement("");
list.disable();
return;
}

}
catch ( IOException exception )
{
System.out.println("Dosyadan okurken hata oluştu");
}
finally
{
try
{
girdi.close();
}
catch( IOException exception )
{
System.out.println("Dosya kapatılırken hata oluşturuldu.");
}
}

}

}

class JListData extends AbstractListModel {
private Vector dlist;

public JListData()
{
dlist = new Vector();
makeData();
}
public int getSize()
{
return dlist.size();
}
private Vector makeData()
{
dlist = new Vector();
return dlist;
}
public Object getElementAt(int index)
{
return dlist.elementAt(index);
}
public void addElement(String s)
{
dlist.addElement(s);
fireIntervalAdded(this, dlist.size()-1, dlist.size());
}
public void temizle()
{
dlist.clear();
}
}

DOMAINS
liste=integer*
matris = liste*
int=integer

PREDICATES
listeGoster(liste)
matrisGoster(matris)
listeTopla(liste,int)
listeCarp(liste,liste,liste)
listeVeMatris(liste,matris,liste)
matrisCarp(matris,matris,matris)

CLAUSES
listeGoster([]).
listeGoster([B|K]):-write(B," "),listeGoster(K).

matrisGoster([]).
matrisGoster([B|K]):-
write("["),
listeGoster(B),
write("]"),nl,
matrisGoster(K).

listeTopla([],0).
listeTopla([X|K],T):-listeTopla(K,Y),T=Y+X.

listeCarp([],[],[]).
listeCarp([Bas1|Kuyruk1],[Bas2|Kuyruk2],[SonucBas|SonucKuyruk]):-
SonucBas=Bas1*Bas2,
listeCarp(Kuyruk1,Kuyruk2,SonucKuyruk).

listeVeMatris(_,[],[]).
listeVeMatris(Liste1,[MatrisBas|MatrisKuyruk],[CarpimBas|CarpimKuyruk]):-
listeCarp(Liste1,MatrisBas,Carpim),
listeTopla(Carpim,CarpimBas),
listeVeMatris(Liste1,MatrisKuyruk,CarpimKuyruk).

matrisCarp([],_,[]).
matrisCarp([Bas1|Kuyruk1],Matris2,[SonucBas|SonucKuyruk]):-
listeVeMatris(Bas1,Matris2,SonucBas),
matrisCarp(Kuyruk1,Matris2,SonucKuyruk).

GOAL
matrisCarp(
[[1,2,3],[3,4,5],[3,1,1]],
[[1,5,5],[2,3,3],[3,4,1],[5,5,1]], Y),
matrisGoster(Y).

Programda kullanılan yüklemlere tek tek bakacak olursak yüklemlerin yaptığı görevler aşağıda açıklanmıştır:

• listeGoster : Liste elemanlarını write iç yüklemi ile göstermek yerine bu yüklem kullanılmıştır.

• matrisGoster : Matris elemanlarını write iç yüklemi ile göstermek yerine bu yüklem kullanılmıştır, aldığı matrisin her bir satırını listeGoster yüklemi sayesinde ekrana yazdırır.

• listeTopla: Listenin elemanlarını toplayan bir yüklemdir. Çarpım sonucu elde edilen listeyi toplamada kullanılmıştır.

• listeCarp: Uzunluğu eşit iki liste elemanlarını birebir çarpan bir yüklemdir.

• listeVeMatris: Birinci matrisin ilk satırı ile ikinci matrisin tamamını çarpmak için bu yüklem kullanılmıştır.

• matrisCarp: Verilen iki matrisin birincisini satır satır alıp ikinci matrisle listeVeMatris yüklemi saysinde çarpar.

Programa goal kısmındaki ikinci matris transpozesi alınmış şekilde yazılmıştır. Transpozesini hesaplayacak bir yüklem yazmayı gözüme kestiremediğim için bu şekilde yaptım :) Umarım işinize yarar ;)

Sadece kod verip bırakmak istemedim ve az da olsa ne yaptığımı açıklayım dedim. Öncelikle programın üç ana özelliğini belirtmeliyim sanırım;

-Her seferinde rasgele bir labirent oluşturulacak

-Labirent üzerinde kapalı yani ulaşılamayan bir bölge olmayacak

-Son olarak labirent çözülecek :)

Ana hatları söyledikten sonra programın çalışmasına gelelim.

Labirenti oluşturacak alan belirlendikten sonra (ör 10×10) bu çerçeve üzerinde bulunan her noktayı bir listeye ekleniyor. Daha sonra bu noktalardan biri rasgele olarak seçiliyor. Bu nokta başlangıç alınarak daha önceden belirlenen adım sayısı kadar rasgele yönlerde ilerlenerek duvar örülüyor. Rasgele yönlerde atılan bu adımlar sonrasında oluşan yeni duvarlar çerçevenin olduğu listeye ekleniyor. Başlangıç olarak seçtiğimz ilk nokta ise listeden siliniyor.Yeni bir adım atılıp duvar örüldüğünde dikkat edilmesi gereken nokta ise kapalı alan oluşturmamaktır.

Labirenti çözmek ise oluşturmaktan çok daha kolay. Klasik self avoding walk algoritmasıyla çözüme gidilmiştir. Labirentin sol en üst köşesi başlangıç, sağ en alt köşesi ise bitiş noktası olarak belirlenmiş ve çözüm ona göre çalışmaktadır. Tabii değiştirmek sizin elinizde :)

///////////////////////////////////////////////////
/*             HEADER DOSYALARI                  */
///////////////////////////////////////////////////
#include "conio.h"
#include "stdlib.h"
#include "stdio.h"
#include "iostream.h"
#define STEP 5
#define YOL 0
#define YOL2 1
#define GEREKSIZ -6
#define DUVAR -2
#define pasifDUVAR -5
#define DUGUM -1
#define eskiDUGUM -3
#define pasifDUGUM -4
#include <time.h>

///////////////////////////////////////////////////
/*                LISTE YAPISI                   */
///////////////////////////////////////////////////
struct Item {
	struct Item *next;
	int val1,val2;    // Dizi iki boyutlu oldugu icin 2 elemanli liste olusturdum.
};

struct List {
	struct Item *list;
};

///////////////////////////////////////////////////
/*     LISTE FONKSIYONLARININ PROTOTIPLERI       */
///////////////////////////////////////////////////
	struct List *liste_yarat(struct List *pl);			//Liste Olusturuyor
	void listeye_ekle(struct List *pl,int,int);			//Listeye eleman ekliyor
	void listeden_sil(struct List *pl,int,int);			//Listeden eleman siliyor
	void liste_gez(struct List *pl,int ,int& , int&);	//Listeden n. siradaki elemani aliyor
	void liste_goster(struct List *pl);					//Lisde degerlerini yazdiriyor
	int  uzunluk(struct List *pl);						//Liste uzunlugunu veriyor
	bool arama(int,int);								//listede eleman ariyor
///////////////////////////////////////////////////
/*         DIGER FONKSIYON PROTOTIPLERI          */
///////////////////////////////////////////////////
	void degeryaz(int **);                             	//ekrana labirenti ciziyor
	void diziyap();                                    	//dinamik dizi olusturuyor
	void duzenle();                                    	//bos labirent olusturuyor
	void kontrol(int,int);                             	//kapali alan kontrolu yapiyor
	void ilerle(int ,int);                             	//duvar olusturuyor
	int rasgele(int);                                  	//random sayi uretiyor
	void devam(int, int);                              	//adim sayisini tutuyor
	void ayikla();                                     	//gereksiz dugumleri ayikliyor
	void labirent();                                   	//Genel fonksiyon
	void yonbul(int , int );                           	//cikis yolunu buluyor
	int adim_sayisi();									//cikisa kac adim var
///////////////////////////////////////////////////
/*       KULLANACAGIM DEGISKENLER, GLOBAL        */
///////////////////////////////////////////////////
	int **dizi,**dizii,x,y,val1,val2,yon,adim=0,varmi=0;
/*/////////////////////////////////////////////////////
//dizi=>Labirenti tutuyor                            //
//x,y=> labirent boyutlari                           //
//val1,val2=>Liste degerlerini almak icin kullandim  //
//yon=>gidilecek yonu tutuyor                        //
//adim=>kac adim gidildigini tutuyor                 //
//varmi=>labirent olup olmadigini tutuyor            //
*//////////////////////////////////////////////////////

	struct List *l1;

//###############################################//
/*               MAIN FONKSIYONU                 */
//###############################################//

main(){

	l1=liste_yarat(l1);                // Listemi yaratyiyorum
	char ch='1';                      // Kullanici arayuzu
	while(ch!='2')   {
		cout<<endl<<
		"0-Ekrani temizle"<<endl<<
		"1-Yeni labirent Olustur"<<endl<<
		"2-Programdan Cik"<<endl;
		if(varmi==1){
			cout<<"3-Labirenti Coz"<<endl;
		}
		ch=getch();
		if(ch=='1'){
			clrscr();labirent();yonbul(1,1);varmi=1;
		}
		else if (ch=='2'){
			clrscr();
			cout<<endl<<
			"Veri Yaplilari Labirent Olusturma Odevi\nYazan:Ahmet KAKICI - 150165\nCikmak icin herhangi bir tusa basiniz.";
			getch();
		}
		else if(ch=='3'){
			clrscr();
			degeryaz(dizi);
			cout<<endl;
			degeryaz(dizii);
			cout<<"Labirentten "<<adim_sayisi()<<" adimda cikildi."<<endl;
			varmi=0;
		}
		else if(ch=='0'){
			clrscr();
		}
	}
}

//////////////////////////////////////////////////
/*  SELF AVOIDING WALK ve LABIRENTTEN CIKIS     */
//////////////////////////////////////////////////

void yonbul(int a, int b){

	int xMax=x-1,yMax=y-1;
	if(a==x-2 && b==y-2){
		for(int i=0;i<x;i++)
		for(int j=0;j<y;j++)
		dizii[i][j]=dizi[i][j];
		return;
	}

	if(b+2<yMax && dizi[a][b+1]==pasifDUVAR && dizi[a][b+2]==YOL){
		dizi[a][b+2]=YOL2;
		yonbul(a,b+2);
		dizi[a][b+2]=YOL;
	}
	if(a-2>0 && dizi[a-1][b]==pasifDUVAR && dizi[a-2][b]==YOL){
		dizi[a-2][b]=YOL2;
		yonbul(a-2,b);
		dizi[a-2][b]=YOL;
	}
	if(b-2>1 && dizi[a][b-1]==pasifDUVAR && dizi[a][b-2]==YOL){
		dizi[a][b-2]=YOL2;
		yonbul(a,b-2);
		dizi[a][b-2]=YOL;
	}
	if(a+2<xMax && dizi[a+1][b]==pasifDUVAR && dizi[a+2][b]==YOL){
		dizi[a+2][b]=YOL2;
		yonbul(a+2,b);
		dizi[a+2][b]=YOL;
	}
}
///////////////////////////////////////////////////
/*      LABIRENT OLUSTURMA FONKSIYONU            */
///////////////////////////////////////////////////
void labirent(){
	srand(time(NULL));
	cout<<endl<<"Labirent boyutlarini gir"<<endl<<"x=";
	cin>>x;
	cout<<endl<<"y=";
	cin>>y;
	diziyap();
	duzenle();

	while((uzunluk(l1))>0){
		liste_gez(l1,rasgele(uzunluk(l1)),val1,val2);
		ilerle(val1,val2);
		ayikla();
	}
	degeryaz(dizi);
}
///////////////////////////////////////////////////
/*          DIZI OLUSTURMA FONKSIYONU            */
///////////////////////////////////////////////////
void diziyap()
{
	x=x*2+1;
	y=y*2+1;
	dizi=new int *[x];
	dizii=new int *[x];
	for(int i=0;i<x;i++){
		dizi[i]=new int[y];
		dizii[i]=new int[y];
	}
}
///////////////////////////////////////////////////
/*       RASGELE SAYI URETEN FONKSIYON           */
///////////////////////////////////////////////////
int rasgele(int n)
{
	return rand()%n;
}
///////////////////////////////////////////////////
/*       ADIM SAYISINI TUTAN FONKSIYON           */
///////////////////////////////////////////////////
int adim_sayisi()
{
	int adimSayisi=0;
	for(int i=0;i<x;i++){
		for(int j=0;j<y;j++){
			if(dizii[i][j]==YOL2){
				adimSayisi++;
			}
		}
	}
	return adimSayisi;
}
///////////////////////////////////////////////////
/*   DIZI DEGERLERINI YAZAN FONKSIYON            */
///////////////////////////////////////////////////
void degeryaz(int **dizim){
	for(int i=0;i<x;i++){
		for(int j=0;j<y;j++){
			if(dizim[i][j]==DUVAR)
			cout<<'\xDB'<<'\xDB';
			else if(dizim[i][j]==YOL)
			cout<<" "<<" ";
			else if(dizim[i][j]==YOL2)
			cout<<"_"<<"_";
			else if (dizim[i][j]==pasifDUGUM)
			cout<<'\xDB'<<'\xDB';
			else if (dizim[i][j]==eskiDUGUM ||dizim[i][j]==GEREKSIZ || dizim[i][j]==-2 )
			cout<<'\xDB'<<'\xDB';
			else cout<<' '<<" ";
		}
		cout<<endl;
	}
}
///////////////////////////////////////////////////
/*      LABIRENTIN BOS HALINI OLUSTURUYOR        */
/*     ILK DUGUM NOKTALARINI LISTEYE ATIYOR      */
///////////////////////////////////////////////////
void duzenle(){
	int xx,yy;
	xx=x-1;
	yy=y-1;
	for(int i=0;i<x;i++){
		for(int j=0;j<y;j++){
			if( i==0 || j==0 || i==xx || j==yy)
				dizi[i][j]=GEREKSIZ;          			//KENARLARDAKI GEREKSIZ YERLER
			if(  (  (j==0 ||j==yy) && j%2==0)|| ( (i==0||i==xx) && i%2==0) ){
				dizi[i][j]=DUGUM;    					//LABIRENTIN KENARLARINI
				listeye_ekle(l1,i,j);     				//LISTEYE EKLE
			}
			else if (i%2!=0 && j%2!=0){     			//GIDILECEK YOLLAR
				dizi[i][j]=YOL;
			}
			else if( ((i%2!=0 && j!=0 && j!=yy) &&  j%2==0)||(i%2==0 && (i!=0 && i!=xx &&  j%2!=0)) ){
				dizi[i][j]=pasifDUVAR;            		//PASIF DUVARLAR
			}
			else if(i%2==0 && j%2==0){
				dizi[i][j]=pasifDUGUM;           		//PASIF DUGUMLER
			}
			//else dizi[i][j]=8;
		}
	}
	//LABIRENTIN KOSELERINDEKI DUGUMLERI LISTEDEN SIL
	listeden_sil(l1,0,0);dizi[0][0]=eskiDUGUM;
	listeden_sil(l1,xx,0);dizi[xx][0]=eskiDUGUM;
	listeden_sil(l1,0,yy);dizi[0][yy]=eskiDUGUM;
	listeden_sil(l1,xx,yy);dizi[xx][yy]=eskiDUGUM;
}
///////////////////////////////////////////////////
/*  LABIRENTTE DUVAR OREREK ILERLEME FONKSIYONU  */
///////////////////////////////////////////////////
void ilerle(int Xnokta,int Ynokta){
	yon=rasgele(4);
	int a=Xnokta;
	int b=Ynokta;

	if(Xnokta==0)yon=3;
	if(Ynokta==0)yon=1;
	if(Xnokta==x-1)yon=0;
	if(Ynokta==y-1)yon=2;
    //liste_goster(l1);

	// Kuzey => 0 , dogu =>1 , bati=>2 , guney=> 3,
	if(yon==0){             //KUZEY
		if(a-2>0){
			if(dizi[a-2][b]==pasifDUGUM){
				dizi[a-1][b]=DUVAR;
				kontrol(a-2,b);
				kontrol(a,b);
				devam(a-2,b);
			}
		}
	}

	if(yon==1){         // DOGU
		if(b+2<y){
			if(dizi[a][b+2]==pasifDUGUM){
				dizi[a][b+1]=DUVAR;
				kontrol(a,b+2);
				kontrol(a,b);
				devam(a,b+2);
			}
		}
	}
	if(yon==2){        // BATI
		if(b-2<0){
			if(dizi[a][b-2]==pasifDUGUM){
				dizi[a][b-1]=DUVAR;
				kontrol(a,b-2);
				kontrol(a,b);
				devam(a,b-2);
			}
		}
	}
	if(yon==3){             // GUNEY
		if(a+2<x){
			if(dizi[a+2][b]==pasifDUGUM){
					dizi[a+1][b]=DUVAR;
					kontrol(a+2,b);
					kontrol(a,b);
					devam(a+2,b);
			}
		}
	}

}  //gezi func. sonu

void devam(int Xnokta,int Ynokta)
{
	if(adim<STEP){
		adim++;
		ilerle(Xnokta,Ynokta);
    }
	else{
		adim = 0;
	}
}
 ///////////////////////////////////////////////////
/*                   AYIKLA  FONKSIYONU          */
//////////////////////////////////////////////////
void ayikla(){
	for (int i=0;i<uzunluk(l1);i++){
		liste_gez(l1,i,val1,val2);
		kontrol(val1,val2);
	}
}
////////////////////////////////////////////////////
/*                KONTROL  FONKSIYONU            */
//////////////////////////////////////////////////
void kontrol(int Xnokta,int Ynokta)
{
	int cevre = 0;

	if(Ynokta+2<y){
		if(dizi[Xnokta][Ynokta+2]==pasifDUGUM ){
			cevre++;
		}
	}
	if(Ynokta-2>0){
		if(dizi[Xnokta][Ynokta-2]==pasifDUGUM ){
			cevre++;
		}
	}
	if(Xnokta+2<x){
		if(dizi[Xnokta+2][Ynokta]==pasifDUGUM ){
			cevre++;
		}
	}
	if(Xnokta-2>0){
		if( dizi[Xnokta-2][Ynokta]==pasifDUGUM){
			cevre++;
		}
	}
	if (cevre==0){
		dizi[Xnokta][Ynokta]=eskiDUGUM;
		listeden_sil(l1,Xnokta,Ynokta);
	}
	else if( cevre!=0 && (dizi[Xnokta][Ynokta]!=DUGUM)){
		if(!(arama(Xnokta,Ynokta))){
			listeye_ekle(l1,Xnokta,Ynokta);
		}
		dizi[Xnokta][Ynokta]=DUGUM;
	}
}
 ///////////////////////////////////////////////////
/*             LISTE FONKSIYONLARI                */
///////////////////////////////////////////////////

///////////////////////////////////////////////////
/*           LISTE YARATMA FONKSIYONU           */
//////////////////////////////////////////////////
struct List *liste_yarat(struct List *pl){
	pl=(struct List *)malloc(sizeof(struct List));
	pl->list=0;
	return pl;
}
///////////////////////////////////////////////////
/*      LISTE UZUNLUGUNU BULAN FONKSIYON         */
///////////////////////////////////////////////////
int uzunluk(struct List *pl){
	struct Item *tmp=pl->list;
	int uzun=0;
	while(tmp){
		uzun++;
		tmp=tmp->next;
	}
	return(uzun);
}
///////////////////////////////////////////////////
/*      LISTEDEN ELEMAN SILEN FONKSIYON          */
///////////////////////////////////////////////////
void listeden_sil(struct List *pl,int val1,int val2){
	struct Item *prv, *pt = pl->list;
	if ( (pt) && (pt->val1==val1)&&(pt->val2==val2)  ){
		pl->list= pt->next;
		free(pt);
	}
	else if (pt){
		for ( prv=pt, pt= pt->next;
			  ((pt) && ((pt->val1 != val1) || (pt->val2 != val2)));
			  prv=prv->next, pt=pt->next);
		if ( (pt)&& (pt->val1==val1) && (pt->val2==val2) ){
			prv->next=pt->next;
			free(pt);
		}
	}
}
///////////////////////////////////////////////////
/*    LISTE ELEMANLARINI YAZDIRAN FONKSIYON      */
///////////////////////////////////////////////////
void liste_goster(struct List *pl){
	struct Item *tmp=pl->list;
	while (tmp){
		printf("%d ", tmp->val1) ;
		printf("%d \n", tmp->val2) ;
		tmp=tmp->next;
	}
}
///////////////////////////////////////////////////
/*  LISTE BASINA ELEMAN EKLEYEN FONKSIYON        */
///////////////////////////////////////////////////
void listeye_ekle(struct List *pl,int val1, int val2) {
	struct Item *pt=(struct Item *)malloc(sizeof(struct Item));
	pt->val1=val1;
	pt->val2=val2;
	pt->next=pl->list;
	pl->list=pt;
}
///////////////////////////////////////////////////
/*    LISTEDEN n. ELEMANI ALMA FONKSIYONU        */
///////////////////////////////////////////////////
void liste_gez(struct List *pl,int n,int &val1, int &val2){
	struct Item *tmp=pl->list;
	while(n-->0){
		tmp=tmp->next;
	}
	val1=tmp->val1;
	val2=tmp->val2;
}
bool arama(int xVal,int yVal){
	struct Item *tmp=l1->list;
	int uzun=uzunluk(l1);
	while(uzun-->0){
		if(tmp->val1==xVal && tmp->val2==yVal){
			return true;
		}
		tmp=tmp->next;
	}
	return false;
}

İlk defa HTML ve PHP yazmaya başladığımda NotePad kullanıyordum şimdilerde ise yelpaze oldukça genişledi ve haliyle kalite de arttı. Yazının devamında kullandığım programlama dilleri ve bu dillere ait editörler/derleyicileri sıraladım. Umarım biraz da olsa fikir sahibi olmanıza yardımcı olurum. Eğer önerileriniz varsa lütfen yorum yapmaktan çekinmeyin, keşfedilmeyi bekleyen programlara da şans verelim :)

HTML (CSS/JS)

HTML yazmaya başladığımda ki bu kod yazma sürecimin başlangıcına denk geliyor, elimde not defterinden başka bir alternatif yoktu. Zaten o sıralarda 33.6k dial-up bağlantı kullandığımdan bir program bilsem/bulsam bile indirmem eziyet olacaktı. Uzun bir süre not defteri ile devam ettikten sonra FrontPage’i bulmuştum. İşleri çok kolaylaştırmasına rağmen arka planda olan işlerden haberdar olmamak ve neyi nasıl yaptığımı bilmeyişim bu programdan soğumama sebep oldu. Bir dili öğrenme aşamasında bu tip programların kullanılması bence pek doğru değil.

Daha sonra aşağıda bir çok dil için de kullandığımı belirteceğim NotePad++ kullanmaya başladım. Genelde pek fazla tasarım ile uğraşmadığımdan dolayı HTML yazma işine de girmem. Eğer ufak tefek düzenleme işleri dışında büyük bir iş ile uğraşacaksam Visual Studio’ya geçiş yaparım. VS 2008′in Hotfix‘i çıkmadan önce dizayn arayüzü gerçekten yavaştı ama şimdi nispeten daha hızlı ve iş görebilecek seviyede.

Sonuç olarak HTML yazarken işin büyüklüğüne göre NotePad++ veya VS2008 kullanıyorum

PHP

Bu dil ile tanıştığım zamanlarda da not defterinden başka bir alternatifim yoktu. Daha sonra PHP Designer, PHPed gibi programlar kullandım. Ancak en hızlı ve efektif kullanıma yine NotePad++ ile eriştim. Geçen sene ilk defa büyük ve ciddi bir projeye başladığımda ise Zend Development Environment kullanmayı denedim. Gerçekten denemeye değer bir program. PHP’nin yaratıcılarından olan Zend firması tarafından çıkarılması destek ve güncellik konusunda herhangi bir kaygınızın oluşmaması için yeterli olur.

NotePad++ bir çok dili desteklediğinden dolayı her dilin en ince ayrıntısına kadar destek veremiyor. Ancak ZDE bu konuda PHP için oldukça kaliteli bir program. Eğer büyük bir proje ile uğraşıyorsanız ZDE’yi denemenizi tavsiye ederim. Ufak çaplı işler peşindeyseniz NotePad++ hızı ile en sadık editörünüz olacaktır.

JAVA

Java (hala javascript ile karıştıran var mı ?) ile üniversiteye gittikten sonra tanıştım ve çevremdeki arkadaşlarım ve öğretim görevlileri sayesinde az çok ufkum açılmıştı. En azından not defteri ile işe başlamayacağımı biliyordum :).

Derste örnekleri işlerken JCreator kullanılıyordu ve gözüme gayet güzel bir program gibi göründü. Hemen gidip JCreator’ı denemeye başladım. Olabilecek en temel Java editörü olduğunu çok daha sonradan ve acı bir tecrübe ile öğrendim. Java ile Tr<->İng sözlük programı yazmaya başladığımda programın ana işlevi arama işlevini bitirmemin ardından tam program bitti edasıyla rahatlamışken arayüz yapmadığımı hatırladım. Konsol üzerinden çalışan bir sözlüğü kim kullanır ki? Arayüz tasarlamaya başladığımda ise programın ana işlevinden çok arayüzle uğraştığımı farkettim. Sürükle bırak gibi bir özelliği olmadığından ve Java’nın layout özelliklerinde yeni olmamdan dolayı epey zaman harcadım ve JCreator ile aram bozuldu.

JCreator sonrasında Eclipse ile tanıştım. Eklenti özelliği gerçekten mükemmel görünüyordu. Ancak eklentilerin bağımlılıkları baş ağrıtıyordu. Yeni çıkan bir eklenti yüklediğimde bağımlı olduğu eklentilerin de düzenlenmesi gibi sorunlardan (acemiliğim) dolayı sürükle bırak tipi bir eklentiyi kuramadım ve NetBeans’e geçiş yaptım.

Evet NetBeans java konusunda aradığım yegane programdır. Java ile yazılmış olmasından dolayı biraz yavaş çalışmasına ve biraz fazla bellek tüketmesine rağmen kullandığım en iyi editördür. Kod tamamlama özelliğinin yanı sıra değişken tamamlama özelliği de mevcut. Bir fonksiyonun prototipinde alacağı veri tipini belirttikten sonra o fonkisyonu çağıracağınız zaman yazabileceğiniz değişkeni tipine göre tahmin edip tamamlaması çok kullanışlı bir özellik.

C/C++/C#

Bilgisayar mühendisliği birinci sınıfta okuyorsunuz ve bir gün o çok korktuğunuz programlama dili C ile karşılaşıyorsunuz. Turbo C denilen mavi bir ekranda (mavi ekran zaten bir kabus :] ) birşeyler yazıldığını görüyorsunuz. Evet işte korkutucu C maceram böyle başladı, dili kavrama konusunda bir sorunum olmasa da (php tabanımdan dolayı) editör gözümü korkutmuştu. Turbo C’yi bir kere bile kullanmadan dönemi bitirdim ve o dönem boyunca herşeyi defterime yazdım :)

Daha sonra C++ ile tanıştığımızda Borland C++ Builder ile haşır neşir olduk. İlk defa sürükle bırak tarzında bir editör kullanmanın verdiği zevk ile BCB’ye tutulmuştum. Yazdığım şeylerin arkaplanında ne olduğunu bilmeden uzun süre BCB ile birlikteliğim devam etti. Daha sonraları derinlere indikçe az buz birşeyler öğrendim ve sürükle bırak yapmama rağmen arka planda olan işlerin farkına vardım. Ancak bir gün Visual Studio diye bir program ile tanıştım ve BCB’yi bir daha kurmamak üzere sildim.

Visual Studio’dan sonra C/C++/C# yazarken herhangi bir alternatifi göz önüne almadım bile. Halen daha kullanmaya devam ediyorum. Sadece küçük düzenlemeler için sadık dostum NotePad++’ı kullanıyorum.

Prolog

Öğrendiğim en ilginç dillerden biri olan prolog için adını bile hatırlamadığım editörleri deneyip bıraktım. Sonunda ise kullanımı eziyet verse de TurboProlog’a döndüm. Ancak kodlarımı halen daha NotePad++ ile yazıp derleme işlemini Turbo Prolog ile yapıyorum.

Assembly

Assembly yazarken de kullandığım en pratik program yine NotePad++. Derleme ve trace aşamasında MPLab’dan yararlansak da NotePad++ bu işte de sadık programım oldu. Ancak şunu belirteyim ki Assembly ile yazdığım çok az program var. Odtü robot yarışlarında ve mikroişlemciler ödevim dışında assembly yazdığımı hatırlamıyorum :)

Özet olarak en iyi editörüm hiç kuşkusuz NotePad++ hele stil dosyasını değiştirip arka planı siyah yaptıktan sonra gözleri de yormadan rahatça saatlerinizi ona bakarak geçirebilirsiniz :)