Sitede gelen bir soru üzerine bu yazıyı yazmaya karar verdim. Bilgisayar dilleri (makine işlemeli diller, machine processing languages) tasnif edilirken, visual basic gibi görsel tasarıma dayalı diller üst seviye dil (high level langauge) olarak kabul edilirler. Hatta hiç kod yazmadan program üretilmesine izin verdiği için visual basic’i bir dilden çok görsel geliştirme ortamı olarak kabul eden (basic’i dil ancak visual basic’i bir geliştirme ortamı) tasnifler söz konusudur.

Göstericiler (pointers) ise tam tersine düşük seviyeli dillerde daha çok ihtiyaç duyulan ve programın geliştirildiği bilgisayarın hafızasına (ram) doğrudan erişim yapan yapılardır. Dolayısıyla tanım itibariyle visual basic ve gösterici (pointer) kavramları birbiri ile uyuşmazlar. Ancak .Net teknoloji ile birlikte nesne yönelimli programlama (object oriented programming) yapısı kazanan adeta kabuk değiştiren visual basic ile gösterici kullanımı ihtiyacı artmıştır.

Nesne yönelimli dillerin çoğunda (örn. JAVA) doğrudan gösterici kullanımı bulunmaz. Bunun yerine nesne atfı ismi verilen (object referrer) yapılar kullanılır ve bu yapılar aslında birere göstericidir.

Visual basic de nesne yönelimli programlama ile birlikte bu nesne atıflarını içermiş ve artık gösterici yapısını nesne yönelimli olarak içermiştir ancak biz bu yazı kapsamında, nesne yönelimli programlanın bize sunduğu bu imkanı bir kenara bırakarak, saf visual basic dilinde göstericileri nasıl kullanabileceğimizi irdeleyeceğiz.

Konuyu aşağıdaki örnek üzerinden anlamaya çalışalım.

Yukarıda, C dilinde yazılmış basit bir gösterici kodu bulunmaktadır. Kodumuzun 7. Satırında p isimli bir tam sayı göstericisi (integer pointer) tanımlanmış, 8 . satırda bu göstericinin gösterdiği yerde 1 tam sayı konulacak bir yer hafızada ayrılmış (memory allocation) ve 9. Satıda bu göstericinin gösterdiği adrese 10 değeri konulmuştur.

Kodun 10. Satırında göstericinin adresi (hafızada nereyi gösterdiği ) ve gösterdiği yerdeki değerler ekrana basılmış ve 11. Satırda gösterici için ayrılan hafıza bölmesi serbest bırakılmıştır (free).

Yukarıdaki bu kodun çalışan hali aşağıda verilmiştir:

Şimdi yukarıdaki bu basit C dili ile yazılmış gösterici kodunu Visual Basic dili ile kodlamaya çalışalım.

Yukarıdaki kodu inceleyecek olursak, yapı olarak bir form yükleme fonksiyonuna yazılmış kodumuz, p ve hHeap isimli iki adet Long tipinde değişken tanımlayarak başlıyor. Buradaki p değişkenini bir gösterici olarak kullanacağız. Dikkat edilmesi gereken husus, p değişkeninde gösterici mantığında olduğu üzere bir hafıza bölmesinin adresinin tutulmasıdır. Yani C dilinde olan p göstericisinde nasıl hafızanın bir adresi tutuluyorsa, visual basic örneğinde de hafıza adresini tutmaya çalışacağız.

Öncelikle çalışan programımızın yani işlemin (process) çalıştığı alanı tutan hHeap isimli değişkenimizden HeapAlloc fonksiyonu ile (C dilindeki malloc benzeri) hafızada bir alan ayırması yapılıyor.

Bu ayırma sırasında 0′dan başlanarak 2 boyutunda ayırma işlemi yapılmıştır. 2 sayısı, visual basic dilindeki bir tamsayının (integer) hafızada kapladığı alan boyutudur.

Sonuçta kodun 22. Satırı itibariyle, p isminde bir değişken ve bu değişkenin içinde, hafızada bize ayrılmış 2 byte uzunluğunda bir alanın adresi bulunmaktadır.

Ardından 23. Satırda böyle bir adres ayrımı başarılı olduysa, artık bu adres alanına bir integer değer koymayı deneyebiliriz.

24. satırda i isimli bir tam sayı değişkeni tanımlanıyor, 25. Satırda bu değişkene sayısal olarak 10 değeri konuluyor ve sonunda 26. Satırda, p göstericimizin gösterdiği adrese, i değişkenin içindeki değer konuluyor. Bu sırada CopyMemoryWrite fonksiyonu kullanılmıştır. Bu fonksiyon kernel32 dinamik kütüphanesi içinde bulunan RtlMoveMemory fonksiyonudur. Dolayısıyla bu fonksiyonu kullanmak için aşağıdakine benzer bir şekilde kodun başında tanım yapılmalıdır:

Private Declare Sub CopyMemoryWrite Lib “kernel32″ Alias _
“RtlMoveMemory” (ByVal Destination As Long, _

ByVal Source As Long, ByVal Length As Long)

Ardından j isimli bir değişken tanımlanarak, p göstericimizin gösterdiği hafıza alanına daha önceden (kodun 26. Satırında) yazdığımız değeri okumaya çalışıyoruz. Bunun içinde yine kernel32.dll kütüphanesinden tanımladığımız fonksiyonumuzu kullanıyoruz.

Sonuç bir mesaj kutusu içerisinde gösteriliyor ve nihayetinde 31. Satırda bu ayrılan hafıza alanı serbest bırakılmaktadır.

Visual basic ile yazılan bu kodun tamamını bu bağlantıdan indirerek deneyebilirsiniz.

Kısaca üçgenin her parçası, üç adet alt üçgen oluşturacak şekilde bölünür.

Örneğin aşağıdaki eşkenar üçgeni ele alalım:

Bu üçgenin üç köşesinde üç ayrı üçgen oluşturarak işlemimize başlayabiliriz.

Yukarıdaki şekilde görüldüğü üzere 3 adet siyah eşkenar üçgen oluştu. Bu üçgenlerin her birisini ilk başta ele aldığımız üçgen gibi bir adım daha ilerleyerek üç parçaya bölmeye çalışalım:

Görüldüğü üzere bölme işlemi sonucunda her alt üçgeninin üç köşesinde, ilk adımda yapılan işleme benzer şekilde 3 ayrı üçgen oluşturulmuştur.

Bu işlem sonsuza kadar devam ettirilebilir. Ancak bilindiği üzere bilgisayar bilimlerinde sonsuz yoktur. Dolayısıyla bu işlem için bir limit belirlenir ve belirlenen limite kadar işlem devam ettirilir.

Sierpinski üçgeninin kodlanması

Yukarıda anlatılan üçgeni, Scheme dilinde programlamaya çalışalım. Bu kodlama sırasında PLT Scheme kullanılacaktır.

Öncelikle gerekli olan bazı bilgilerimizi hatırlayalım. Çizim için draw.ss teachpackinin yüklü olması gerekiyor.

Bunun için Language menüsünden Add Teachpack seçeneğini seçip draw.ss paketini yüklüyoruz.

Ardından basit bir üçgenin scheme ile nasıl çizileceğine bakalım.

Ne yazık ki üçgen çizen hazır bir fonksiyonumuz bulunmuyor. Bunun için üçgeni oluşturan üç ayrı doğruyu ayrı ayrı çizdiren bir fonksiyonu bizim yazmamız gerekiyor.

(define (draw-triangle a b c)( and (draw-solid-line a b)(draw-solid-line b c)(draw-solid-line c a)))

Yukarıdaki draw-triangle fonksiyonu üç ayrı nokta almaktadır. Bu noktaları birleştiren üç ayrı doğruda fonksiyon içerisinde çizilmektedir. Bilindiği üzere draw-solid-line fonksiyonu verilen iki nokta arasında bir doğru çizer. Bu noktalar make-posn yapısında olmalıdır. Örneğin çizim ekranında (ki ekranın sol üst köşesi 0,0 olarak kabul edilir) 100, 150 koordinatlarından 200, 250 koordinatlarına bir doğru çizmek istiyorsak aşağıdaki şekilde komut vermemiz gerekir:

(draw-solid-line (make-posn 100 150) (make-posn 200 250))

Üçgen çizen fonksiyonumuz olduğuna göre artık sirepinski üçgenini kodlamaya geçebiliriz.

Kodumuzu yukarıdaki şekilde yazabiliriz. Kodda dikkat edilirse üçgen çizimi sırasında orta nokta bulma yöntemi kullanılmıştır. Buradaki amaç, üçgenin köşelerinde 3 ayrı üçgen elde etme işlemi sırasında üçgenin kenarlarının orta noktalarının birleştirilmesi ile bir ters üçgen oluşturulması olarak düşünülebilir.

Yukarıdaki şekilde de gösterildiği üzere alsında kenarların orta noktalarını birleştiren bir üçgen çizilmektedir.

İşte üçgeni meydana getiren 3 nokta ve bu noktaların oluşturduğu 3 doğru için orta noktalar bulunmakta ve bulunan bu orta noktaları birleştiren yeni bir üçgen çizilmektedir. Bu noktaları bulan kodumuz, yukarıda verilen mid-point fonksiyonudur. Bu mid-point fonksiyonu da, aritmetik ortalama kullanarak, nokta koordinatlarını toplayıp ikiye bölmekte ve bu işlem için yine yukarıdaki kodda verilen mid fonksiyonunu kullanmaktadır.

Ardından üçgenin 3 alt üçgeni yeniden sierpinski üçgeni çizen fonksiyonumuzu yeni noktalar ile verilmektedir.

Sierpinski üçgeninde dikkat edilirse, üçgeni oluştran 3 nokta (a b ve c) dışında ilave olarak bir n parametresi kullanıyoruz. Bu parametrenin amacı, fonksiyonun belirli bir yerde durmasıdır. Bu sayede kullanıcı, işlemimizin kaç adım gidilebileceğini parametre olarak girebilmekte ve belirtilen adım dolduğunda işlem durmaktadır.

Yukarıdaki kodun çalıştırılması aşağıdaki şekilde olabilir:

Görüldüğü üzere, üçgenin içerisine çizileceği üç nokta belirlenmiştir. Burada noktaları belirlerken, üçgenin eşkenar üçgen olması için ufak bir hesaplama yapılmıştır. Çizim tuvalimiz, 400 400 olarak verilmiş yani bize ekranda 400e 400 pixellik (imgecik) bir alan açılmaktadır. Bu alanı nispeten ortalayan bir üçgende A B ve C noktalarının birleştirilmesi ile teşekkül etmiş olur.

Son olarak sierpinski üçgenini çizen özyineli (recursive) fonksiyonumuzu bu üç noktanın koordinatları ve 10 adım gidileceğini belirten 10 sabit sayısı ile çağırıyoruz.

Sonuç olarak ekrana çizilen görüntü aşağıdaki şekildedir:

Yukarıdaki şekilde, 10 adım ilerlenmiş ve 10 adım sonunda detaylı bir görüntü oluşmuştur. Örneğin aynı üçgeni 3 parametresi ile, yani 3 adım ilerleyecek şekilde çağırsaydık:

Yukarıda verilen biraz daha ilkel halini görecektik.

Soru 1) Bir dosyaya isminizi yazdırınız.

Çözüm 1) dosyaya ismimizi yazdıran kodu aşağıdaki şekilde yazabiliriz:

Yukarıdaki kodda dikkat edilecek bir husus, dosyanın “r” değil “w” şekliyle açılması ve dosyanın mutlaka kapatılmasıdır. Bilindiği üzere kapatılmayan dosyalara yazıldığından kesin olarak emin olamayız ve dosya kapatılmadıysa içerisine bilgi yazılmamış olabilir.

Yukarıdaki kod çalıştırıldıktan sonra aynı dizin içerisinde “dosya.txt” isimli bir dosya oluşturulur ve bu dosyanın wordpad benzeri bir programla açılması durumunda içinde ismimizin yazdığını görebiliriz.

Soru 2) Klavyeden okunan bir sayının asal çarpanlarını ekrana basan kodu yazınız.

Çözüm 2)

Yukarıdaki kodda görüldüğü üzere önce bir sayı okunmuş (kodun 7. Satırı) ardından bir döngü içerisinde, 2′den başlayarak bütün sayılara bu girilen sayıyı bölme denenmiştir. For döngüsünün (8. Satır) koşulu, sayının 1′den büyük olmasıdır. Dolayısıyla sayı 1 olunca yani bütün asal sayılara bölümü tamamlanınca çalışma duracaktır.

Yukarıdaki kodda bulunan iç döngü (9. Satırdaki while döngüsü) ise bir asal sayının birden fazla kere bölme ihtimaline karşı yazılmıştır. Örneğin 60 girdisi için 2 asal sayısı, 2 kere bölebilir. Bu durumda bir sonraki asal sayı ile deneme yapılmadan önce, şu anda bölmeyi denediğimiz asal sayı ile bölünmeyinceye kadar deneme yapıyoruz.

Kodun 11. Satırında ise, denediğimiz sayının, girilen sayıyı tam bölmesi durumunda bölerek sayıyı küçültüyor ve başarılı olarak bölebildiğimiz bu sayıyı bir çarpan olarak ekrana yazıyoruz.

Kodun örnek çalışması aşağıdaki şekildedir.

Soru 3) Bir dizgideki kelime sayısını ekrana bastıran kod yazınız.

Çözüm 3)

Soruda, girilen bir dizgideki (String) kelime sayısının saydırılması istendiği için, dizginin scanf ile okunması mümkün değildir. Bilindiği üzere scanf tek bir kelime okur ve bu durumda işe yaramaz. Birden fazla kelimenin boşlukları ile okunması istenen durumda gets fonksiyonu kullanılabilir. Yukarıdaki kodun 6. Satırında da bu şekilde dizgi okunmuştur. Ardından dizgide bulunan boşluklar dizgi sonuna kadar saydırılmıştır. Dizgi sonu kontrolü 8. Satırda bulunan for döngüsünde yapılırken, dizgi içerisinde o anda bakılan karakterin boşluk karakteri olup olmadığı 9. Satırdaki if kontrolü ile yapılmıştır. Şayet boşluk karakteri ise, kelimesayısı değişkeni 1 arttırılmıştır.

Basitçe hesaplanacağı üzere, bir dizgideki boşluk sayısı, kelime sayısından 1 eksik olur. Bu problemin çözümü için kelimesayısı değişkeni 0 yerine 1′den başlatılmıştır.

Kodun çalışan hali aşağıda verilmiştir.

Soru 4) Bir dizgideki en uzun kelimeyi bularak ekrana bastıran kodu yazınız

Çözüm 4)

Yukarıdaki kod, 3. Sorudaki koda benzer şekilde, dizgi sonuna kadar bütün karakterleri kontrol etmekte ve boşluk karakterlerinde kodun 15. Satırında bulunan if kontrolüne girmektedir. Bu kodda farklı olan bir özellik, iki adet karakter göstericisi (character pointer) ile dizgi üzerinde işaretleme yapılmasıdır.

Bu göstericilerden kelimebasi isimli gösterici, o ana kadar bulunan en uzun kelimeyi göstermekte, yenikelime göstericisi ise, üzerinden geçilen son kelimeyi göstermektedir.

Kodun çalışmasını aşağıdaki şekilde anlayabiliriz:

Yukarıda gösterildiği üzere, ilk başta iki gösterici de dizginin ilk karakterini göstermektedir. Ayrıca kelimeboyu ve yeniboy değişkenlerinin değeri 0′dır.

Ardından kodumuz döngü içerisinde karakter karakter ilerlemekte ve ilk boşluğu gördüğü anda aşağıdaki şekilde yeni kelim değişkeni hareket ettirilmektedir.

İlk boşluğa gösterici hareket ettirildikten sonra boşluğa kadar olan harf sayısı sayılmakta ve yeniboy 3 olmaktadır.

Tekrar bir boşluk karakterine kadar göstericimiz hareket eder:

Bulduğumuz yeni kelimenin boyu 4 olduğu ve şimdiye kadar bulduğumuz en uzun kelimeden daha uzun olduğu için kelimebasi göstericisini ilerletiyor ve yukarıdaki şekilde bulunan yeni kelimenin ilk karakterine atıyoruz, ayrıca yenikelime göstericisi, mevcut konuma ilerletiliyor ve bir sonraki kelimenin aranmasında kullanılıyor.

Yeni bulunan kelime boyu, o ana kadar bulunan kelime boyundan daha küçük olduğu için kelimebasi değişkenimiz hala o ana kadar bulunmuş en uzun kelimeyi göstermeye devam ediyor.

Bir önceki örnekte olduğu gibi, bulunan yeni kelimenin boyutu, ilk kelimeden büyük olmadığı için değişkenimiz ilerlemiyor.

Son olarak bulduğumuz yeni kelimenin boyu, şimdiye kadar bulunan kelimelerden uzun olduğu için, göstericiyi ilerletiyor ve kelimebasi olara bu kelimenin ilk harfini gösteriyoruz. Sonuçta dizgi sonuna kadar giderken, anlık olarak bir kelimenin boyutu değişkende tutuluyor, bir kelimenin boyutunun bu değişkende tutulan boyuttan daha uzun olması durumunda bu kelimeyi gösteren bir gösterici işaretleniyor ayrıca bu yeni kelimenin boyutu, elimizde o ana kadar bulunan en uzun kelime boyutu olarak tutuluyor.

Kodun çıktısı aşağıdaki şekildedir:

Soru 5) Kullanıcıdan bir sayı okuyarak, okunan bu sayı boyutlarında bir kare matrisi, her hücresine, en yakın kenara olan uzaklığı ile doldurunuz.

Çözüm 5)

Soruda her hücreye, en yakın kenara olan uzaklık yazılması istenmiş, bu durumda örneğin 5×5 boyutunda bir matris için aşağıdaki şekilde veri girilmesi gerekir:

Görüldüğü üzere kenar değerlerine 1 , bir içerdeki hücrelere 2 ve en ortadaki hücreye 3 yerleştirilmesi istenmiş.

Bu dorunun çözümünde sadece döngüler kullanılarak bir döngünün kenara olan uzaklığı hesaplanıp ekrana yazdırılabilir. Bu yöntemin çözümü aşağıdaki şekildedir:

Yukarıdaki kodda görüldüğü üzere, her hücre için, hücrenin kenara olan 4 farklı uzaklığı hesaplanmıştır. Bu değerlerden iki tanesi, koordinatları olan i ve j değerleridir ki bu değerler, sol kenara ve üst kenara olan uzaklık olarak düşünülebilir.

Ayrıca sağ kenar ve alt kenara olan uzaklıkların hesaplanması kodun 20. Ve 21. Satırlarında bulunan a ve b değişkenleri ile yapılmıştır. Matrisin boyutundan koordinat çıkarılmış ve 1 ilave edilmiştir.

Sonuçta elimizde 4 farklı kenara olan 4 farklı uzaklık bulunmaktadır. Bizden istenen bu uzaklıklardan en küçüğünü ekrana basmamız. Bu durumda kodun 4-13 satırları arasında bulunan ve verilen 4 sayıdan en küçüğünü döndüren fonksiyonu çağırarak bu 4 uzaklıktan en küçüğünü bulabiliriz.

Kodun çalışan hali aşağıdaki şekildedir:

Gelen bir soru üzerine aşağıdaki yazıyı yazıyorum. Soru şu şekilde:

“Konsol programında rastgele zar atan ve çıkan zarı ekrana bastıran kodu yazınız. ”

Konsol ekranında zar çizdirmek için öncelikle bir tasarım yapmamız gerekiyor. Konsol ekranında sadece ascii karakterlerini basabileceğimizi düşünürsek, zarları aşağıdaki şekilde ascii ekranda göstermemiz mümkün olabilir.

Yukarıdaki her 3 satırda bir zar resmi olduğunu düşünelim. Örneğin zar ile 4 atıldığında 10 -12 satırlar arasındaki karakterler ekrana basılacak olsun.

Şimdi java ile rast gele sayı üretme işi ile ilgilenebiliriz. Bunun için java dilinde bulunan Math.random() fonksiyonunu kullanmamız gerekiyor.

Öncelikle zarları yukarıdaki şekillerde basacak bir program yerine zarın sonucunu doğrudan sayı olarak ekrana basan bir kod yazmaya çalışalım:

İlk denememizde Math.random() fonksiyonunu çalıştırmaya çalışıyor ve aşağıdaki hatalı kodu yazıyoruz:

Yukarıdaki kodu çalıştırdığımızda doğal olarak aşağıdaki hatayı alıyoruz:

Görüldüğü üzere bize Math.random() fonksiyonunun bir double değeri döndürdüğü ve bir int değerinin içerisine konulamayacağı hatası geliyor. Gerçekten de ilgili java API’si okunduğunda Maht.random() fonksiyonunun 0 ile 1 arasında bir sayı döndürdüğü görülebilir.

Zar değerimiz 1 ile 6 arasında olacağına göre (0 yok 1den başlayacağız), rastgele sayımızı 5 ile çarpıp 1 ekliyoruz.

Bu durum ilk kez rast gele sayılar ile uğraşırken karışık görülebilir ancak şöyle anlatmaya çalışalım

0 < a <1

Aralığında olan a sayısı (ki bu değer aslında Math.random() fonksiyonunun orijinal olarak ürettiği değerdir)

a * 5 yapıldığında:

0 < a < 5

Aralığında olur. a+1 yapıldığında da

1 < a < 6

Aralığında olmuş olur.

Elbette bu değer aralığına getirdikten sonra da Math.random() fonksiyonu hâlâ double değer üretmektedir. Çözüm olarak tip inkılabı yapmak (type casting) ve tipini int değerine çevirmek gerekir. Öyleyse ilgili satır aşağıdaki şekle çevrilmelidir:

int z = (int) Math.random() * 5 + 1

Kodun çalışan hali ise aşağıda verilmiştir:

Kodda dikkat edilirse 4. Satırda Math.random()*5+1 ibaresi parantez içerisine alınmıştır. Bunun sebebi başta bulunan ve tip inkılabı yapan (int) komutunun önce Math.random değerini int yapmasıdır. Dolayısıyla sonuçlar her zaman için 1 çıkacaktır (Math.random her zaman 0 ile 1 arasında değer üretecek, int çevriminden 0 olacak 5 ile çarpılıp 1 eklenince de hep 1 sonucu çıkacaktır)

Kodun çalışan hali aşağıdaki şekildedir:

Son olarak çizimi yaptıran kısma geçebiliriz. Çıkan sonuca göre ekrana farklı bir değer bastırmamız gerekiyor.

Kodu aşağıdaki şekilde yazabiliriz:

Kodun çalışan hali aşağıda verilmiştir:

Yukarıdaki kod, hedefimize ulaşmamızı sağlamasına karşılık kodda ufak bir değişiklik yapmamız mümkündür. Kodda 9×9 bir matris üzerinde * karakteri ile kodlama yaptığımıza dikkat etmişsinizdir. Bu değerlerin basıldığı durumları gösterecek olursak:

Görüldüğü üzere zar değerine bağlı olarak bazı karelerde * sembolü olmakta ve bazılarında olmamaktadır. Dolayısıyla kodu aşağıdaki şekilde yazmak da mümkün olabilir:

Kodun çalışması sonucu aşağıda verilmiştir:

Çözen : Şadi Evren ŞEKER

Yukarıdaki soruyu 4 ayrı dil için (C,C++,JAVA ve C#) ayrı ayrı çözeceğim. Böylelikle okuyucu bu diller arasında mukayese yapabilecek ve bildiği bir dilden diğer dillere kolayca geçebilecektir.

Çözüm:

Soru, yapısı itibariyle 2 boyutlu bir şekil gerektirmektedir. 2 boyutlu bir şekil için 2 adet iç içe döngü (nested loop) kullanılması yeterlidir. Buradaki amaç, döngülerden birisinin yatay diğerinin düşey eksende çalışmasıdır. Sorunun a şıkkı için JAVA dilinde çözüm aşağıdaki şekilde yazılabilir:

import java.util.Scanner;
public
class kare{
public
static
void main(String args[]){
   Scanner in = new Scanner(System.in);
   int boyut;
   System.out.println("Karenin boyutlarını giriniz: ");
   boyut = in.nextInt();
   for(int i = 0;i<boyut;i++){ //her satir icin
      for(int j = 0;j<boyut;j++){ // boyut kadar yildiz bas
         System.out.print("*");
      }
      System.out.println(); // alt satira gec
   }
 }
}

Yukarıdaki kodun çalışan hali aşağıdaki şekildedir:

ÏϧÏKarenin boyutlarını giriniz:
¼¼§Ï5
ÏϧÏ*****
ÏϧÏ*****
ÏϧÏ*****
ÏϧÏ*****
ÏϧÏ*****

Benzer uygulamayı C dilinde aşağıdaki şekilde yazabiliriz:

#include <stdio.h>
#include <conio.h>
int main () {
   printf("boyutu giriniz");
    int boyut;
    scanf("%d",&boyut);
    for(int i = 0;i<boyut;i++){ //her satir icin
       for(int j = 0;j<boyut;j++){ // boyut kadar yildiz bas
          printf("*");
       }
       printf("\n"); // alt satira gec
    }
    getch();
    return 0;
}

Yukarıdaki kodun örnek ekran çıktısı da aşağıda verimiştir:

Yukarıdaki soruyu C++ dilinde çözecek olursak:

#include <iostream.h>

int main () {
cout << "boyutu giriniz" ;
int boyut;
cin >> boyut;
for(int i = 0;i<boyut;i++){ //her satir icin
   for(int j = 0;j<boyut;j++){ // boyut kadar yildiz bas
      cout <<"*" ;
   }
   cout << endl; // alt satira gec
}
system("PAUSE");
return 0;
}

Yukarıdaki kod Dev-CPP ile kodlanmıştır ve ekran çıktısı aşağıdaki şekildedir:

Son olarak aynı soruyu C# dilinde yazacak olursak:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

class
Program

{

static
void Main(string[] args)

{

Console.WriteLine(“boyutu giriniz”);

int boyut;

boyut = Console.Read();

boyut = boyut – 48;

// ascii int çevir (0-9 arasi için)

for (int i = 0; i < boyut; i++)

{ //her satir icin

for (int j = 0; j < boyut; j++)

{ // boyut kadar yildiz bas

Console.Write(“*”);

}

Console.WriteLine(); // alt satira gec

}

}

}

}

Çözen : Şadi Evren ŞEKER

Çözüm:

Hızlı sıralama algoritması hatırlanacağı üzere parçala fethet (divide and conquere) yaklaşımı kullanmaktadır. Buna göre problem önce iki parçaya bölünür ve her iki parça kendi içerisinde sorun çözülene kadar parçalanır. En sonunda tek eleman kalınca problem çözülür ve sonuçlar birleştirilir.

Kodumuzu yazarken verilen bir kerteriz değerinden (pivot) büyük ve küçük sayıları toparlamak için iki ayrı fonksiyon yazacağız. Fonksiyonlardan birisi büyük sayıları, diğeri ise küçük sayıları döndürecek:

(define (larger-items alon threshold)

  (cond

    [(empty? alon) empty]

    [else (if (>= (first alon) threshold)

          (cons (first alon) (larger-items (rest alon) threshold))

          (larger-items (rest alon) threshold))]))

 (define (smaller-items alon threshold)

  (cond

    [(empty? alon) empty]

    [else (if (< (first alon) threshold)

          (cons (first alon) (smaller-items (rest alon) threshold))

          (smaller-items (rest alon) threshold))]))

Yukarıdaki iki fonksiyonda özyineli (recursive) olarak verilen listeyi dolaşarak listedeki büyük veya küçük değerleri ayıklamaktadır. Burada iki fonksiyon arasındaki tek farkın if koşulunda bulunan >= veya < değerleri olduğuna dikkat ediniz.

Problemi bölen fonksiyonları yukarıdaki şekilde tanımladıktan sonra artık sırlama işlemini yapan fonksiyonu sayıları ayırıp birleştirmek üzere aşağıdaki şekilde yazabiliriz:

(define (quick-sort alon)

  (cond

    [(empty? alon) empty]

    [else (append (quick-sort (smaller-items (rest alon) (first alon)))

              (list (first alon))

          (quick-sort (larger-items (rest alon) (first alon))))]))

Görüldüğü üzere listenin ilk elemanı kerteriz (pivot) olarak seçiliyor ve bu değerden küçükler +kerteriz + büyükler şeklinde sıralama işlemi yapılıyor.

Çözüm çalıştırması:

(quick-sort (list 11 8 8 9 9 14 8 7))

Şeklinde fonksiyona bir liste verilmesi yeterlidir.

Yukarıda örnek çalışma verilmiştir buna göre verilen listenin sıralanmış hali (list 7 8 8 8 9 9 11 14) olarak doğru bir şekilde bulunur.

Çözen : Şadi Evren ŞEKER

Çözüm:

Bezier eğrisini çizebilmek için ikinci dereceden bir denkleme ihtiyaç duyulur. Burada denklemin ikinci derece olmasının sebebi 3 nokta ile çizim yapılmasının istenmesidir.

Öncelikle programımızda kullanacağımız basit temel fonksiyonları kodlayalım:

İki nokta verildiğinde bu iki noktanın ortasındaki noktayı hesaplayan fonksiyonu kodlayalım:

(define (mid-point a-posn b-posn)

(make-posn

(mid (posn-x a-posn) (posn-x b-posn))

(mid (posn-y a-posn) (posn-y b-posn))))

Yukarıda iki sayının orta değerini (aritmetik ortalamasını) hesaplayan mid fonksiyonunu kullandık. Bu fonksiyonu basitçe iki sayının toplamının yarısı olarak aşağıdaki şekilde tanımlayabiliriz:

(define (mid x y)

(/ (+ x y) 2))

Artık bezier fonksiyonumuzu kodlayabiliriz. Buradaki püf noktası sürekli olarak noktaların arasındaki noktaların hesaplanmasıdır. Bu açıdan bir fraktal üretimine benzetilebilir:

(define ( bezier p1 p2 p3) (cond

[(too-small? p1 p2 p3) true]

[else (and (draw-solid-disk (mid-point (mid-point p1 p2) (mid-point p2 p3)) 3)

(bezier (mid-point (mid-point p1 p2) (mid-point p2 p3)) (mid-point p2 p3) p3)

(bezier p1 (mid-point p1 p2) (mid-point (mid-point p1 p2) (mid-point p2 p3)))

)]))

Yukarıdaki kod 3 nokta alıp bu noktalar arasındaki mesafe çizilemeyecek kadar küçük oluncaya kadar (bu mesafe aynı zamanda çizimdeki noktaların seyrekliğini de belirtmektedir) ara nokta hesaplamakta ve hesaplanan bu ara noktaları çizmektedir. Yukarıdaki fonksiyonda bitişi belirten too-small? Fonksiyonunu aşağıdaki şekilde tanımlayabiliriz:

(define (too-small? p1 p2 p3)(cond[(< (abs(- (posn-x p1) (posn-x p2))) 10) true]

[else false]

))

Burada noktalar arası mesafe 10 veya daha düşükse artık yeni nokta üretimi duracaktır.

Çözüm çalıştırması:

(define p1 (make-posn 50 50))

(define p2 (make-posn 150 150))

(define p3 (make-posn 250 100))

Üç nokta tanımlanmıştır

(start 300 200)

Çizim alanı açılmıştır

(bezier p1 p2 p3)

Ve son olarak fonksiyonumuza üç nokta parametre verilmiştir.

Kodun çalıştıktan sonra ekranda oluşturduğu çizim aşağıdaki şekilde görülebilir

Çözen : Şadi Evren ŞEKER

Çözüm :

Bu tip bir soruda verilerin tutulması ve işlenmesi önemli bir yer tutar. Verilerin tutulması için scheme dilinde bulunan struct özelliğinden faydalanacağız. Öncelikle verimizi tanımlayalım:

(define-struct tree (ssn label left right))

Yukarıdaki bu tanımda ağacın bir düğümü (node) için kullanılacak yapı verilmiştir. Bu yapıda bir düğümde ssn, label ve ağacın solunu gösteren left, sağını gösteren right değişkenleri bulunmaktadır. Yani solu ve sağı yine kendi yapısından birer üye olacaktır.

(define tree-1 (make-tree 1 ‘x null null))

(define tree-2 (make-tree 3 ‘y null null))

(define tree-3 (make-tree 2 ‘z tree-1 tree-2))

(define tree-4 (make-tree 5 ‘p null null))

(define tree-5 (make-tree 4 ‘q tree-3 tree-4))

Yukarıda örnek ağaç tanımları verilmiştir. Buna göre yukarıdaki ağacı çizecek olursak:

Yukarıdaki şekilde bir ağaç elde ederiz. Bu ağaçta en tepede tree-5 ile tanımlanan ve içerisinde 4,q bulunan düğüm bulunmaktadır. Bu düğümün solunda tree-3 yani 3,y ve sağında ise tree-4 yani 5,p bulunmaktadır ve ağaç bu şekilde birbirine düğümler eklenerek devam etmektedir.

Şimdi ağacı dolaşan fonksiyonumuzu yazalım:

(define (inorder bt) ( cond[(null? bt) null][else (cond[(and (null? (tree-left bt ))(null? (tree-right bt))) (list(tree-label bt) (tree-ssn bt))][else (append (inorder (tree-left bt)) (list(tree-label bt) (tree-ssn bt)) (inorder (tree-right bt)))])]))

Fonksiyon basitçe ağacın önce sol, sonra düğüm sonra sağ değerini ekrana bastırmaktadır. Yani gidebildiği kadar sola gidip en sondaki elemanı basıp bir yukarı çıkmakta ve sonra sağa gitmektedir. Bunu sağlayan sadece yukarıdaki fonksiyonda bulunan dolaşma sırasıdır. Fonksiyonu çalıştırmak için aşağıdaki komut verilebilir.

(inorder tree-5)

Kodun çalışması sonucunda yukarıdaki ekranda görüldüğü üzere ağacın sol-orta-sağ sırasıyla dolaşılmış hali ekrana basılmaktadır:

(x 1 z 2 y 3 q 4 p 5)

Şimdi sorunun ikinci kısmına yani ağaçta arama yapan kısma geçebiliriz:

(define (search bt n)(cond [(eq? (tree-ssn bt) n) (tree-label bt)][(and (null? (tree-left bt)) (null? (tree-right bt))) false]

[else (cond [(eq? (tree-ssn bt) n) (tree-name bt)]

[else (cond [(> (tree-ssn bt) n) (search (tree-left bt) n)][else (search (tree-right bt) n)])

])]))

Yukarıdaki kodu çalıştırmak için aşağıdaki komut verilebilir:

(search tree-5 4)

Yukarıda dikkat edilirse inorder fonksiyonunun aynısı kullanılmıştır. Tek farkı arama işlemi sırasında eşitlik durumu kontrol edilmiş ve bu sayede şayet aranan elemana ulaşıldıysa aram işlemi bitirilmiştir.

Bu kodun çalışan hali ise yukarıdaki şekildedir. Yani aranan değer 4 olarak verildiğinde, 4 ssn değerine sahip q label’ı döndürülmüştür.

Çözen : Şadi Evren ŞEKER

Çözüm fonksiyonları:

Bu tip bir soruda verilerin tutulması ve işlenmesi önemli bir yer tutar. Verilerin tutulması için scheme dilinde bulunan struct özelliğinden faydalanacağız.

Öncelikle dersin yapısını tanımlayalım:

(define-struct course (name credit grade))

Ardından bir öğrencinin yapısını tanımlayalım:

(define-struct student (id listofcourses))

Yukarıda görüldüğü üzere bir ders, isim, kredi ve nottan; öğrenci ise bir numara ve aldığı derslerden oluşur. Şimdi fonksiyonları yazmaya başlayabiliriz:

Öncelikle bir harf notu verildiğinde sayısal karşılığını döndüren fonksiyonu yazalım:

(define (letter-grade grade)(cond [(eq? grade 'A) 4][(eq? grade 'A-) 3.70][(eq? grade 'B+) 3.30][(eq? grade 'B) 3][(eq? grade 'B-) 2.70][(eq? grade 'C+) 2.30][(eq? grade 'C) 2][(eq? grade 'C-) 1.70][(eq? grade 'D+) 1.30][(eq? grade 'D) 1][else 0]))

Ardından verilen bir listedeki dersler için ağırlıklı ortalama hesaplayan fonksiyonu yazalım:

(define (weightedaverage acourse) ( * (course-credit acourse)(letter-grade (course-grade acourse))))

(define (weightedaverage-sum acourselist)( cond [(null? acourselist) 0][else (+ (weightedaverage-sum (rest acourselist)) (weightedaverage (first acourselist)))]))

Yukarıdaki kodda derslerin bir liste olarak verildiği kabul edilmiştir. Buradaki weightedaverage-sum fonksiyonu özyineli (recursive) olarak listenin üzerinden geçer. Her geçişinde sıradaki elemanın değerini toplar ve sonuçta bütün elemanların toplam değerini döndürür.

Yukarıdaki toplamları alan fonksiyonlara ilave olarak derslerin kredilerinin toplamını veren bir fonksiyona ve nihayetinde bu not toplamını kredi toplamına bölen bir fonksiyona daha ihtiyaç vardır. Bunlar aşağıdaki şekilde yazılabilir:

(define (course-credits acourselist)( cond [(null? acourselist) 0][else (+ (course-credits (rest acourselist)) (cond[(eq? 'Z (course-grade (first acourselist))) 0][else ( course-credit (first acourselist))]))]))

(define (calculated-gpa astudent)(/ ( weightedaverage-sum (student-listofcourses astudent))(course-credits (student-listofcourses astudent))))

Sonuçta bir öğrenci dersleri ile birlikte aşağıdaki şekilde verilince ortalama GPA değeri başarıyla hesaplanır:

Çözüm çalıştırması:

(calculated-gpa (make-student 10022021 (list (make-course ‘Comp111 3 ‘B+) (make-course ‘Comp112 3 ‘D+) (make-course ‘FM302 3 ‘C+)(make-course ‘EC232 3 ‘A-)(make-course ‘FM412 3 ‘C+)(make-course ‘FM496 4 ‘C+))))

Yukarıdaki örnek öğrenci için ortalama 2.52 olarak bulunmuştur.

Çözen : Şadi Evren ŞEKER

Çözüm fonksiyonları:

Öncelikle çizim yapacağımız için dr. Scheme üzerinde draw.ss teachpack’ini yüklememiz gerekiyor:

Ardından poligonu çizim için değişkenlerimizi tanımlayalım:

;;6.2.1

(define WIDTH 50)

(define HEIGHT 160)

(define BULB-RADIUS 20)

(define BULB-DISTANCE 10)

;; the positions of the bulbs

(define X-BULBS (quotient WIDTH 2))

(define Y-RED (+ BULB-DISTANCE BULB-RADIUS))

(define Y-YELLOW (+ Y-RED BULB-DISTANCE (* 2 BULB-RADIUS)))

(define Y-GREEN (+ Y-YELLOW BULB-DISTANCE (* 2 BULB-RADIUS)))

Yukarıdaki tanımlamada öncelikle trafik ışıklarının boyutları (width , height) yarı çapları ve birbirine mesafeleri tanımlanmıştır. Ardından aynı x değerine sahip farklı y değerlerindeki 3 adet x,y ikilisi hesaplanmıştır. Işıklar alt alta duracağı için tek x değeri bütün 3 ışık içinde yeterlidir.

Işıkları draw.ss kullanarak çizmek için aşağıdaki kod gerekmektedir:

(start WIDTH HEIGHT)

(draw-solid-disk (make-posn X-BULBS Y-RED) BULB-RADIUS ‘red)

(draw-circle (make-posn X-BULBS Y-YELLOW) BULB-RADIUS ‘yellow)

(draw-circle (make-posn X-BULBS Y-GREEN) BULB-RADIUS ‘green)

Ardından sorunun ilk fonksiyonu olan ve bir trafik ışığını temizleyen koda geçebiliriz:

(define (clear-bulb color) ( cond [ (eq? color 'red) (draw-solid-disk (make-posn X-BULBS Y-RED) (- BULB-RADIUS 2) 'white)]

[ (eq? color 'yellow) (draw-solid-disk (make-posn X-BULBS Y-YELLOW) (- BULB-RADIUS 2) 'white)]

[ (eq? color 'green) (draw-solid-disk (make-posn X-BULBS Y-GREEN) (- BULB-RADIUS 2) 'white)]

))

Yukarıdaki kodda verilen renk 3 ihtimalden birisi ile kontrol edilmektedir. Hangi ihtimal ise ilgili rengin bulunduğu koordinata yarı çapı 2 küçük yeni ve beyaz bir daire çizilmektedir. Bu sayede trafik ışığının içi boş izlenimi verilmektedir.

Sorudaki ikinci fonksiyon olan ve trafik ışığını yakan fonksiyonu yazacak olursak:

(define (draw-bulb color) ( cond [ (eq? color 'red) (draw-solid-disk (make-posn X-BULBS Y-RED) BULB-RADIUS 'red)]

[ (eq? color 'yellow) (draw-solid-disk (make-posn X-BULBS Y-YELLOW) BULB-RADIUS 'yellow)]

[ (eq? color 'green) (draw-solid-disk (make-posn X-BULBS Y-GREEN) BULB-RADIUS 'green)]

))

Yukarıdaki fonksiyonda bir öncekine benzer şekilde verilen renk 3 ihtimal ile kontrol edilmekte hangisine eşitse o ışık koordinatına ilgili renkte bir daire yerleştirilmektedir. Bu sayede ilgili renkteki ışık yanmış izlenimi verilmektedir.

Işık değiştirmek için, bir ışığın sönüp diğerinin yanması gerekir. Bunun için öncelikle renk söndürülür ve sonra istenen diğer renk yakılır.

(define (switch color1 color2)( and (clear-bulb color1)(draw-bulb color2)))

Son olarak sorudaki son fonksiyon olan sıradaki rengin yakılması yani kırımızı->sarı->yeşil->kırmızı döngüsünü yapan fonksiyon için mevcut rengi alan ve bu rengi söndürüp döngüdeki bir sonraki rengi yakan fonksiyon aşağıdaki şekilde yazılabilir

(define (next color) (cond [ (eq? color 'red) (switch 'red 'yellow)]

[ (eq? color 'yellow) (switch 'yellow 'green)]

[ (eq? color 'green) (switch 'green 'red)]))

Çözüm çalıştırması:

İlk fonksiyon olan ışığı söndürme:

(clear-bulb ‘red)

İkinci fonksiyon ışığı yakma

(draw-bulb ‘green)

Üçüncü fonksiyon ışığı değiştirme

(switch ‘green ‘yellow)

Son fonksiyon sıradaki ışığı yakma

(next ‘yellow)

(next ‘green)

Açıklama:

Çalışmanın sonucunda görülen ekran aşağıda verilmiştir: