C# İle biLGİsayar programlama temelleri (C# Programlama Kitabı) Svetlin Nakov & Co

6.4.5 N^M Hesaplanması – Örnek

Bir başka örnek olarak, “n üssü m” sayısını hesaplayan bir program yazacaksınız ve bu amaçla bir for-döngüsü kullanacağız:

Console.Write("n = "); int n = int.Parse(Console.ReadLine()); Console.Write("m = "); int m = int.Parse(Console.ReadLine()); decimal result = 1; for (int i = 0; i < m; i++) { result *= n; } Console.WriteLine("n^m = " + result);

İlk olarak, result değişkenini başlatıyoruz (result = 1). Döngü sayaç değişkeni için bir başlangıç ​​değeri belirleyerek başlar (int i = 0). Döngünün yürütme koşulunu (i < m) tanımlıyoruz. Bu şekilde döngü 0’dan m-1’e kadar tekrarlayarak, yani tam m kere yürütülür. Döngünün her yinelemesi sırasında, sonucu n ile çarpıyoruz, böylece n her tekrarda (1, 2, ..., m) bir sonraki kuvvete yükseltilmiş olacaktır.
n = 2 ve m = 10 için çalıştırıldığında programın çıktısı aşağıdaki gibidir:

n = 2 m = 10 n^m = 1024

6.4.6 Birden Çok Değişkenli For-Döngüsü

Daha önce gördüğümüz gibi, bir for-döngüsü yapısında aynı anda birden çok değişken kullanabilirsiniz. İki sayacı olan bir döngüye örnek aşağıda verilmiştir. Sayaçların biri 1’den başlayarak bir birim artarak hareket eder ve diğeri 10’dan başlayarak bir birim azalarak hareket eder:

for (int small=1, large=10; small{ Console.WriteLine(small + " " + large); }

Döngünün sona erme koşulu sayaçlardan birinin diğerinin değerini geçmesidir. Sonuç aşağıdaki gibidir:

1 10 2 9 3 8 4 7 5 6

6.4.7 "continue" İşleci
continue işleci iç döngünün halihazırda yürütülen yinelemesini durdurur, ancak döngüyü sonlandırmaz. Aşağıdaki örnekte bu işlecin nasıl kullanılacağını inceleyeceğiz.
[1 ... n] aralığında bulunan ve 7 ile bölünemeyen tüm tek sayıların toplamını for-döngüsü kullanarak hesaplayacağız.

int n = int.Parse(Console.ReadLine()); int sum = 0; for (int i = 1; i <= n; i += 2) { if (i % 7 == 0) { continue; } sum += i; } Console.WriteLine("sum = " + sum);

İlk olarak döngü değişkenine 1 değerini atayarak başlıyoruz, çünkü [1 ... n] aralığı içinde ilk tek tamsayı 1’dir. Döngü tekrarından sonra i ≤ n koşulunu, i değerinin n değerini aşıp aşmadığını kontrol ediyoruz. Değişkenin güncellenmesini 2 birim artırıyoruz, çünkü sadece tek sayılar göz önünde olmalıdır. Mevcut sayının 7 ile bölünebilir olup olmadığını döngü gövdesi içinde kontrol ediyoruz. Eğer öyleyse, döngü gövdesinin geri kalanını atlamak üzere continue işlecini çağırıyoruz (sum değişkeni içine geçerli sayıyı ekleyen kodu atlar). Sayı 7 ile bölünebilir değilse, sum değişkeni sayı ile toplanarak güncellenir ve döngü devam eder.
n = 11 için örnek kod çalıştırıldığında sonucu aşağıdaki gibidir:

11 sum = 29

6.5 Foreach Döngüsü
Foreach döngüsü (genişletilmiş for-döngüsü), C/C++/C# dil ailesi için yenidir, ancak VB ve PHP programcıları tarafından iyi bilinir. Bu programlama yapısı bir dizi, liste veya diğer eleman toplulukları (IEnumerable) üzerinde her eleman için yinelemeye hizmet verir. Endekslenmemiş olsa bile, belirtilen topluluğun tüm elemanları üzerinden geçmeye yarar.
Dizileri "Diziler" Bölümü’nde daha fazla ayrıntıyla tartışacağız, ancak şimdilik dizi olarak sayıların yada diğer elemanların düzenli sıralanışını düşünebiliriz.
foreach döngüsünün yapısı şöyledir:

foreach (type variable in collection) { statements; }

Görüldüğü gibi, döngü standart for-döngüsüne göre belirgin olarak daha basittir ve bu nedenle çok sıklıkla geliştiriciler tarafından tercih edilir, çünkü belirli bir topluluğun tüm elemanları üzerinden geçilmesi gerektiğinde program kodunu yazmakta hız kazandırır. Foreach döngüsünü nasıl kullanabileceğinizi gösteren bir örnek aşağıda verilmiştir:

int[] numbers = { 2, 3, 5, 7, 11, 13, 17, 19 }; foreach (int i in numbers) { Console.Write(" " + i); } Console.WriteLine(); string[] towns = { "London", "Paris", "Milan", "New York" }; foreach (string town in towns) { Console.Write(" " + town); }

Örnekte bir dizi sayı oluşturuyoruz, sayılar sonra foreach döngüsü içinden geçiyorlar ve elemanları konsolda yazdırılıyor. Daha sonra şehir adlarından (dize türünde) bir dizi oluşturuluyor ve bir başka döngüden geçirilerek benzer şekilde adları konsolda yazdırılıyor. Örnek kod çalıştırıldığında, aşağıdaki çıktı olarak sonucu aşağıdaki gibidir:

2 3 5 7 11 13 17 19 London Paris Milan New York

6.6 İçiçe Döngüler
İçiçe döngüler birkaç döngünün birbirinin içinde yer almasıyla oluşturulan programlama yapılarıdır. İçteki döngüler daha çok ve dıştaki döngüler - daha az kere çalıştırılırlar. İki içiçe döngünün yapısına bir bakalım:

for (initialization, verification, update) { for (initialization, verification, update) { executable code } … }

İlk for-döngüsünün başlatmasından sonra, gövdesi çalıştırılmaya başlayacaktır, ki bu da ikinci (içiçe) döngüyü içeriyor. İkinci döngünün değişkeni başlatılır, koşulu kontrol edilir ve gövde kodu çalıştırılır, daha sonra değişken güncellenir ve koşul false dönünceye kadar yürütme devam eder. Bundan sonra, ilk for-döngüsünün ikinci yinelemesi ile kodun yürütülmesine devam edilir, ilk döngü değişkeni güncellenir ve ikinci döngünün tamamı bir kez daha gerçekleştirilir. İç döngü tamamen dış döngünün gövdesi çalıştırıldığı sürece pek çok kere baştan sona yürütülür.
Şimdi içiçe döngülerin ne kadar yararlı olduklarını gösteren gerçek bir örnek düşünelim.

6.6.1 Bir Üçgen Yazdırılması – Örnek
Belirli bir sayı, n, için n satırdan oluşan bir üçgeni konsolda yazdıracağız. Üçgen şöyle görünecektir:

1 1 2 1 2 3 … 1 2 3 … n

İki içiçe-döngü kullanarak problemi çözeceğiz. Dış döngü, satırlar üzerinden hareket eder, ve iç döngü içindeki elemanları hesaplar. Birinci satırda olduğumuzda, "1" yazdırmak zorundayız (1 eleman, iç döngünün 1 yinelemesi). İkinci satırda "1 2" yazdırmak zorundayız (2 eleman, iç döngünün 2 tekrarlaması). Üzerinde bulunduğumuz satır ile yazdırdığımız elemanların sayısı arasında bir ilişki olduğunu görüyoruz. İç döngünün yapısını düzenlemek için ipucumuzu bu korelasyon söylemektedir:

• 
  Döngü değişkenini 1 ile başlatıyoruz (yazdıracağımız ilk sayı): col = 1;
  
• 
  Tekrarlama koşulu hangi satırda bulunduğumuza bağlıdır: col ≤ row;
  
• 
  İç döngünün her tekrarında döngü değişkenini bir birim artırırız.
  

Temel olarak, döngü değişkeni 1’den başlayarak n’e kadar tekrar eden bir for-döngüsünü (dış döngü) uygulamamız (satırlar için) ve bunun içine başka bir for-döngüsü (iç döngü) koymamız gerekiyor. İçteki döngü bulunduğumuz satırdaki sayılar için, 1’den başlayarak satır numarasına kadar devam edecektir. Dış döngü satırlar üzerinden gitmelidir ve iç döngü mevcut satırın sütunların üzerinden gitmelidir.
Sonuç olarak, aşağıdaki kodu yapılandırabiliriz:

int n = int.Parse(Console.ReadLine()); for (int row = 1; row <= n; row++) { for (int col = 1; col <= row; col++) { Console.Write(col + " "); } Console.WriteLine(); }

Çalıştırmak istediğimizde, doğru çalıştığından emin olmalıyız. n=7 için çalıştırıldığında çıktı olarak sonuç aşağıdaki gibidir:

1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 1 2 3 4 5 6 1 2 3 4 5 6 7

Not: n > 9 için üçgenin küçük bir kusuru olacaktır. Bunu nasıl düzeltebileceğinizi düşünün!
6.6.2 Bir Aralıktaki Asal Sayılar – Örnek
İçiçe döngülere başka bir örnek düşünelim. Amacımız [n ... m] aralığındaki tüm asal sayıları konsolda yazdırmaktır. Aralığı for-döngüsü tarafından sınırlayacağız ve bir sayının asal olup olmadığını kontrol etmek için içiçe while-döngüsü kullanacağız:

Console.Write("n = "); int n = int.Parse(Console.ReadLine()); Console.Write("m = "); int m = int.Parse(Console.ReadLine()); for (int num = n; num <= m; num++) { bool prime = true; int divider = 2; int maxDivider = (int)Math.Sqrt(num); while (divider <= maxDivider) { if (num % divider == 0) { prime = false; break; } divider++; } if (prime) { Console.Write(" " + num); } }

Dıştaki for-döngüsünü kullanarak, n, n+1, …, m sayılarının her biri için asal olup olmadıkları kontrol ediliyor. Dıştaki for-döngüsünün her yinelemesinde döngü değişkeni olan num değerinin bir asal sayı olup olmadığını kontrol ediyoruz. Asal sayının kontrolü için gerekli mantık bize zaten tanıdıktır. İlk olarak prime değişkenini true olarak başlatırız. İçteki while döngüsü ile [2…√num] aralığındaki sayıların her biri için num tarafından bölünebildiğini kontrol ederiz ve eğer öyleyse prime değerini false olarak ayarlarız. While döngüsü sona erdikten sonra Boole değişkeni prime sayının asal olup olmadığını gösterir. Sayı asal ise konsolda yazdırabilirsiniz.
n = 3 ve m = 75 için örnek kod çalıştırıldığında, çıktı olarak sonuç aşağıdaki gibidir:

n = 3 m = 75 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73

6.6.3 Şans Sayıları – Örnek
İkiden çok döngüyü içiçe koyabileceğimizi gösteren başka bir örnek düşünelim. Amacımız ABCD formatında dört basamaklı sayıları bulmak ve yazdırmaktır, öyle ki A+B = C+D olsun (şans sayıları denir). Her basamak için bir tane olmak üzere dört for-döngüsü ile bu uygulamayı gerçekleştireceğiz. En dıştaki döngüde binler basamağı tanımlıdır. 1’den başlayacak ve içteki geri kalan döngüler 0’dan başlayacaktır. İç döngüler sırasıyla yüzler, onlar ve birler basamağını belirleyecektir. En içteki döngünün içindeki mevcut sayının şanslı olup olmadığı için bir kontrol yapacağız, ve eğer öyleyse, sayıyı konsolda yazdıracağız. Kodun uygulanmış bir örneği aşağıda verilmiştir:

for (int a = 1; a <= 9; a++) { for (int b = 0; b <= 9; b++) { for (int c = 0; c <= 9; c++) { for (int d = 0; d <= 9; d++) { if ((a + b) == (c + d)) { Console.WriteLine( " " + a + " " + b + " " + c + " " + d); } } } } }

Çok uzun olan sonucun bir kısmı aşağıdaki gibidir:

1 0 0 1 1 0 1 0 1 1 0 2 1 1 1 1 1 1 2 0 1 2 0 3 1 2 1 2 1 2 2 1 …

Dört yerine sadece üç içiçe döngü kullanarak, aynı soruna daha etkin bir çözüm sunmayı da çalışkan okuyucu için ödev olarak bırakıyoruz.

6.6.4 6/49 Piyango Oyunu – Örnek
Aşağıdaki örnekte "6/49" piyango oyununun tüm muhtemel kombinasyonlarını bulabilirsiniz. 6 farklı sayının her biri [1..49] aralığında olan tüm muhtemel bileşenlerini bulmak ve yazdırmak zorundayız. 6 for-döngü kullanacağız. Önceki örneklerden farklı olarak, sayılar tekrarlanmaz. Tekrarlardan kaçınmak için sonraki her sayının bir öncekinden daha büyük olması için çaba göstereceğiz. Bu nedenle, iç döngüler 1 ile başlatılmaz, ancak bir önceki döngü sayaç değerinin + 1 fazlasından başlatılır. İlk döngü sayacı 44’e ulaşana kadar (49 değil) döngü devam eder. İkincisi 45’e ulaşana kadar döngü devam eder. Son döngü sayacı 49 değerine ulaşana kadar çalışır. Eğer tüm döngüleri 49 üst sınırına kadar çalıştırırsanız belirli kombinasyonlarda eşleşen sayıları sonuç çıktısında görebilirsiniz. Aynı nedenle, sonraki her döngü önceki döngü sayacının + 1 fazlasından başlatılmıştır. Neler olduğunu aşağıda verilen örnek uygulamada görelim:

for (int i1 = 1; i1 <= 44; i1++) { for (int i2 = i1 + 1; i2 <= 45; i2++) { for (int i3 = i2 + 1; i3 <= 46; i3++) { for (int i4 = i3 + 1; i4 <= 47; i4++) { for (int i5 = i4 + 1; i5 <= 48; i5++) { for (int i6 = i5 + 1; i6 <= 49; i6++) { Console.WriteLine(i1 + " " + i2 + " " + i3 + " " + i4 + " " + i5 + " " + i6); } } } } } }

Her şey doğru görünüyor. Programı çalıştıralım. Kod çalışacak gibi görünüyor, ancak bir sorun var - çok kombinasyon var ve program bitmiyor (pek az insanın bekleyebileceği kadar çok yavaş çalışıyor). Bu doğrudur ve Piyango 6/49 oyununun varlık nedenlerinden biridir, gerçekten birçok kombinasyon vardır. Yukarıdaki örneğin sadece tüm piyango kombinasyonlarını yazdırma olmaksızın sadece hesaplamak için değiştirilerek uygulanmasını meraklı okuyucuya bırakıyoruz. Bu değişiklik önemli ölçüde konsolda basılı sonuçların miktarını azaltacaktır ve program şaşırtıcı derecede hızlı sona erecektir.

Konsolda aşırı miktarda metin yazdırmak çok yavaştır ve kaçınılmalıdır. (2012 itibarıyla) Modern bir bilgisayar saniyede 300.000.000 işlem gerçekleştirebilir, ancak saniyede 10.000 – 20.000 metin satırı yazdırabilir.

6.7 Alıştırmalar

3. 
   1’den N’e kadar olan sayıları konsolda yazdıran bir program yazın. N sayısı standart girdiden okunmalıdır.
   

2. 
   1’den N’e kadar olan aralıkta aynı anda 3’e ve 7’e bölünemeyen sayıları konsolda yazdıran bir program yazın. N sayısı standart girdiden okunmalıdır.
   
3. 
   Konsoldan bir dizi tamsayı okuyan ve bu sayıların en küçüğünü ve en büyüğünü yazdıran bir program yazın.
   
4. 
   Standart bir iskambil destesinden joker olmadan, tüm olası kartları yazdıran bir program yazın (her biri 13’er karttan oluşan 4 takım, toplam 52 kart vardır).
   
5. 
   Konsoldan N sayısını okuyan ve Fibonacci dizisinin ilk N teriminin toplamını yazdıran bir program yazın: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, …
   
6. 
   Verilen bir N ve K için N!/K! sayısını hesaplayan bir program yazın (1
   
7. 
   Verilen bir N ve K için N!*K!/(N-K)! sayısını hesaplayan bir program yazın (1
   
8. 
   Kombinatorik’te, Katalan sayıları şu formül ile hesaplanır: , n ≥ 0. Verilen bir n için n.inci Katalan sayısını hesaplayan bir program yazın.
   
9. 
   Verilen bir n ve x tamsayısı için toplamını hesaplayan bir program yazın.
   

2. 
   Pozitif bir N tamsayısını konsoldan okuyan (N < 20) ve aşağıdaki şekillerde olduğu gibi sayıların matrisini yazdıran bir program yazın.
   

N = 3 N = 4

1 2 3 2 3 4 3 4 5

1 2 3 4 2 3 4 5 3 4 5 6 4 5 6 7

2. 
   Belirli bir sayının faktöriyelinin kaç sıfır ile biteceğini hesaplayan bir program yazın. Örnekler:
   

N = 10 -> N! = 3628800 -> 2

N = 20 -> N! = 2432902008176640000 -> 4

2. 
   Verilen bir sayıyı ondalık (decimal) gösterimden ikili (binary) gösterime (rakam sistemi) çeviren bir program yazın.
   
3. 
   Verilen bir sayıyı ikili (binary) gösterimden ondalık (decimal) gösterime çeviren bir program yazın.
   
4. 
   Verilen bir sayıyı ondalık (decimal) gösterimden onaltılık (hexadecimal) gösterime çeviren bir program yazın.
   
5. 
   Verilen bir sayıyı onaltılık (hexadecimal) gösterimden ondalık (decimal) gösterime çeviren bir program yazın.
   
6. 
   Verilen bir N tamsayısı için 1’den N’e kadar olan sayıları rasgele sırada yazdıran bir program yazın.
   
7. 
   Verilen iki sayının en büyük ortak bölenini (OBEB) ve en küçük ortak katını (OKEK) bulan bir program yazın. LCM(a, b) = |a*b| / GCD(a, b) formülünü kullanabilirsiniz.
   
8. 
   * Verilen belirli bir n sayısı için spiral şeklinde matris çıktısı veren bir program yazın.
   

1	2	3	4
12	13	14	5
11	16	15	6
10	9	8	7

n=4 için örnek:

Bölüm 7.Diziler

7.1 Bölümün İçindekileri
Bu bölümde aynı veri türünden bir seri eleman ile çalışmanın bir yolu olarak dizileri öğreneceksiniz. Dizilerin ne olduğunu, nasıl bildirildiklerini, oluşturulduklarını, örneklerinin nasıl yaratıldıklarını ve kullanıldıklarını açıklayacağız. Tek boyutlu ve çok boyutlu dizileri inceleyeceğiz. Diziler üzerinden döngülü yinelemeler yapmaya, standart girdiden okumaya ve standart çıktıya yazmaya yarayan farklı yollar öğreneceksiniz. Dizileri kullanarak çözülebilecek birçok örnek alıştırma vereceğiz ve gerçekten ne kadar yararlı olduklarını göstereceğiz.

7.2 "Dizi" Nedir?
Diziler çoğu programlama dilleri için hayati önem taşımaktadır. Eleman olarak adlandırılan bir değişken topluluğudur:

C# dilinde bir dizinin elemanları 0, 1, 2, ... N–1 ile numaralandırılır. Bu sayılara endeks denir. Belirli bir dizideki toplam eleman sayısına dizinin uzunluğu diyoruz.
Belirli bir dizinin tüm elemanları temel yada referans türü olsun olmasın aynı türdendir. Bir grup benzer elemanı sıralı bir dizilim olarak temsil eder, ve bir bütün olarak onlarla çalışmayı mümkün kılar.
Diziler farklı boyutlarda olabilir, ancak en çok kullanılanları tek-boyutlu ve iki-boyutlu dizilerdir. Tek-boyutlu dizilere vektör denir ve iki-boyutlu olanlar da matris olarak bilinir.