Euler serisinin yedinci yazısında, Project Euler’in 7. sorusunu çözeceğiz;

Orjinal Soru; By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10.001st prime number?

Türkçesi; İlk altı asal sayı: 2, 3, 5, 7, 11, ve 13, altıncı asal asal sayının 13 olduğunu görürüz.

10.001nci asal sayı kaçtır?

Önce siz çözmeyi deneyin, çözemezseniz Devamını oku…

Listeler (IEnumerable<T> interface’ini implemente eden) üzerinde filtreleme yapmak için .Net 3.0’dan beri LINQ sorgularını kullanabiliyoruz.

LINQ ile gelen farklı operatör grupları sayesinde, listeler üzerinde sadece filtreleme yapmanın ötesinde bir kontrolümüz oluyor (daha detaylı bilgi için MSDN’de yeralan The .Net Standard Query Operators makalesini okuyabilirsiniz);

• Filtreleme Operatörleri : Where
• Gruplama Operatörleri : GroupBy
• Sıralama Operatörleri : OrderBy, ThenBy, OrderByDescending, ThenByDescending
• Bölümleme Operatörleri : Take, Skip, TakeWhile, SkipWhile
• Seçme Operatörleri : Select
• Küme Operatörleri : Distinct, Union, Intersect, Except
• Dönüştürme Operatörleri : ToArray, ToList, ToDictionary, OfType
• Eleman Operatörleri : First, FirstOrDefault, Single, SingleOrDefault, ElementAt
• Üretim Operatörleri : Range, Repeat
• Gruplama Fonksiyonu Operatörleri : Count, Sum, Min, Max, Average
• Sayım Operatörleri : Any, All
• Diğer Operatörler : Concat, EqualAll

Bu yazımda, bir liste uzerinde LINQ sorgusu gerçekleştirmenin 3 farklı yolunu inceleyeceğiz;

• Predicate
• Anonymous Method
• Lambda Sorgusu

Öncelikle üzerinde çalışacağımız bir listeye ihtiyacımız olacak, Enumerable sınıfının static Range method’u ile iki değer aralığındaki tam sayılardan oluşan listeyi kullanabiliriz;

Enumerable.Range(50, 100);

Predicate

private static bool CiftSayiKontrol(int Rakam)
{
	if (Rakam % 2 == 0)
		return true;
	else
		return false;
}

public static void Main(string[] args)
{
	var SonucListe = Enumerable.Range(1, 20).Where(CiftSayiKontrol);
	foreach (var Rakam in SonucListe)
	{
		Console.WriteLine(Rakam);
	}

	Console.ReadLine();
}

Sonuç;

Anonymous Method

public static void Main(string[] args)
{
	var SonucListe = Enumerable.Range(1, 20).Where(delegate(int number) {
		if (number % 2 == 0)
			return true;
		else
			return false;
	});

	foreach (var Rakam in SonucListe)
	{
		Console.WriteLine(Rakam);
	}

	Console.ReadLine();
}

Lambda Sorgusu

public static void Main(string[] args)
{
	var SonucListe = Enumerable.Range(1, 20).Where(Rakam => Rakam % 2 == 0);
	foreach (var Rakam in SonucListe)
	{
		Console.WriteLine(Rakam);
	}

	Console.ReadLine();
}

Aşağıdaki kod parçasına, programlama üzerine yazılmış bir makaleyi okurken rastladım;

public void IsNullOrEmpty<T>(IEnumerable<T> koleksiyon)
{
	if (koleksiyon == null || koleksiyon.Count() == 0)
	{
		/// Koleksiyon'da hiç eleman yok
		/// Koleksiyon boş
	}
}

Yukarıdaki method IEnumerable generic tipinde parametre alıyor, null veya boş olup/olmadığını kontrol ediyor.

Karşılaştırmada kullanılan,

Liste.Count() == 0

kod parçası dikkatimi çekti.

Eğer IsNullOrEmpty fonksiyonuna parametre olarak ICollection<T> interface‘ini implemente etmeyen tipten bir değer gönderecek olursak (mesela LINQ sorgusu sonucu olarak IQueryable) Count method’u tüm liste üzerinde satır-satır ilerleyerek listedeki eleman adedini hesaplayacaktır.

Eğer fonksiyona parametre olarak IEnumerable interface‘ini implemente eden tipten bir değer gönderecek olursak, Count method’u, optimize edilmiş haliyle, sadece koleksiyonun Count özelliğini sorgulayacaktır.

Türkçe ifadesiyle; “Koleksiyonda eleman var mı?” sorusu yerine “Koleksiyon’da sıfır eleman mı var?” sorusunu sormuş oluyoruz.

Aslında çözüm basit, System.Linq namespace‘inde yeralan Any extension method‘unu kullanmamız gerekiyor;

public void Test<T>(IEnumerable<T> koleksiyon)
{
	if (koleksiyon == null || !koleksiyon.Any())
	{
		/// Koleksiyon'da hiç eleman yok
		/// Koleksiyon boş
	}
}

Bu yöntemin güzelliği, IEnumerable interface‘inin MoveNext methodunu sadece bir kere çağırması. Koleksiyonda bulunan eleman adedi ne olursa olsun, Any methodu sonucu çok hızlı birşekilde döndürecektir.

Hatta kendi extension method‘umuzu da Any methodunu kullanarak yazabiliriz;

public static bool IsNullOrEmpty<T>(this IEnumerable<T> koleksiyon)
{
	return koleksiyon == null || !koleksiyon.Any();
}

Artık extension method‘u da yazdığımıza göre, asıl method‘u iyileştirebiliriz;

public void Test<T>(IEnumerable<T> koleksiyon)
{
	if (koleksiyon.IsNullOrEmpty())
	{
		/// Koleksiyon'da hiç eleman yok
		/// Koleksiyon boş
	}
}

Bir dizinin tüm elemanları üzerinde bir aksiyon gerçekleştirmemiz gerektiğinde, sıklıkla şu üç yoldan birini kullanırız;

• For döngüsü
• ForEach Döngüsü
• List generic sınıfının ForEach extension method’u

Şimdi basit bir örnek ile bu üç yöntemi karşılaştıralım ^(*);

_{(* Not : Karşılaştırmalar; Windows7 64bit kurulu, Core2Duo 3.0 GHz ve 4 GB Ram’li bilgisayarımda yapılmıştır. Sadece fikir verme amaçlıdır, farklı durumlarda faklı sonuçlar ile karşılaşılabilir.)}

Öncelikle parametre olarak Generic List (List<T>) alan üç tane method yazalım;

private static long ToplamFor(List<int> Liste)
{
	long Sonuc = 0;
	int ListeAdet = Liste.Count;

	for (int iLoop = 0; iLoop < ListeAdet; iLoop++)
		Sonuc += Liste[iLoop];

	return Sonuc;
}

private static long ToplamForEach(List<int> Liste)
{
	long Sonuc = 0;

	foreach (int Rakam in Liste)
		Sonuc += Rakam;

	return Sonuc;
}

private static long ToplamForEachExtension(List<int> Liste)
{
	long Sonuc = 0;

	Liste.ForEach(Rakam => Sonuc += Rakam);

	return Sonuc;
}

Aynı testi 10 defa gerçekleştirip, ortalamasını alacak bir test fonksiyonu yazalım. Yazacağımız fonksiyonu test listesinde olacak eleman adedini parametre olarak alacak;

private static void Testler(int ListeElemanAdet)
{
	List<int> ForSureler = new List<int>();
	List<int> ForEachSureler = new List<int>();
	List<int> ForEachExtensionSureler = new List<int>();

	List<int> TestVerisi = Enumerable.Range(0, ListeElemanAdet).ToList();

	Stopwatch sw = new Stopwatch();

	for (int iLoop = 0; iLoop < 10; iLoop++)
	{
		sw.Restart();
		ToplamFor(TestVerisi);
		sw.Stop();
		ForSureler.Add(sw.ElapsedTicks);

		sw.Restart();
		ToplamForEach(TestVerisi);
		sw.Stop();
		ForEachSureler.Add(sw.ElapsedTicks);

		sw.Restart();
		ToplamForEachExtension(TestVerisi);
		sw.Stop();
		ForEachExtensionSureler.Add(sw.ElapsedTicks);
	}

	Console.WriteLine("For Döngüsü ({0} Eleman) : {1}", ListeElemanAdet, ForSureler.Average());

	Console.WriteLine("ForEach Döngüsü ({0} Eleman) : {1}", ListeElemanAdet, ForEachSureler.Average());

	Console.WriteLine("ForEach Extension ({0} Eleman) : {1}", ListeElemanAdet, ForEachExtensionSureler.Average());
}

Artık uygulamamızın test fonksiyonunu kullanacak son kod parçasını yazabiliriz;

public static void Main(string[] args)
{
	Console.WriteLine("Test Başladı");

	Testler(1000);
	Testler(5000);
	Testler(10000);
	Testler(50000);
	Testler(100000);
	Testler(500000);
	Testler(1000000);
	Testler(5000000);
	Testler(10000000);
	Testler(50000000);

	Console.WriteLine("Test Bitti");

	Console.ReadLine();
}

Bakalım yaptığımız testler nasıl sonuç vermiş;

Sonuçlardan aşağıdaki tabloyu çıkarttım;

İlk olarak 50.000 elemana kadar olan listeler için karşılaştırma yapalım;

Son olarak 50.000.000 elemana kadar olan listeler için karşılaştırma yapalım;

Euler serisinin altıncı yazısında, Project Euler’in 6. sorusunu çözeceğiz;

Orjinal Soru; The sum of the squares of the first ten natural numbers is,
1² + 2² + … + 10² = 385

The square of the sum of the first ten natural numbers is,
(1 + 2 + … + 10)² = 55² = 3025

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 – 385 = 2640.

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Türkçesi; İlk 10 sayının karelerinin toplamı,
1² + 2² + … + 10² = 385

İlk 10 sayının toplamlarının karesi,
(1 + 2 + … + 10)² = 55² = 3025

İlk 10 sayı için toplamların karesi ile karelerin toplamı arasındaki fark; 3025 – 385 = 2640′tır.

İlk 100 sayının toplamların karesi ile karelerin toplamı arasındaki farkı bulunuz.

Önce siz çözmeyi deneyin, çözemezseniz Devamını oku…

Euler serisinin beşinci yazısında, Project Euler’in 5. sorusunu çözeceğiz;

Orijinal soru; 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

Türkçesi; 1′den 10′a kadar olan sayılara kalansız bölünebilen en küçük sayı 2520′dir.

1′den 20′ye kadar olan rakamların tamamına kalansız bölünebilen en küçük sayı kaçtır?

Önce siz çözmeyi deneyin, çözemezseniz Devamını oku…

Euler serisinin dördüncü yazısında, Project Euler’in 4. sorusunu çözeceğiz;

Orijinal soru; A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 99.
Find the largest palindrome made from the product of two 3-digit numbers.

Türkçesi; Palindromik sayı, düz ve tersten aynı şekilde okunan sayıdır. 2 haneli rakamlar ile oluşturulabilecek en büyük palindromik sayı 9009′dur (91 ve 99 kullanılarak) 3 haneli rakamlar ile oluşturulabilecek en büyük palindromik sayıyı bulunuz.

Önce siz çözmeyi deneyin, çözemezseniz Devamını oku…

Euler serisinin ilk yazısında, Project Euler’in 1. sorusunu çözeceğiz;

Orijinal soru; If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

Türkçesi; 3′ün veya 5′in katı olan 10′dan küçük tüm doğal sayıları listelersek, 3, 5, 6, ve 9′u elde ederiz. Bu katların toplamı 23′tür. 3′ün veya 5′in 1000′den küçük tüm katlarının toplamını bulunuz.

Önce siz çözmeyi deneyin, çözemezseniz Devamını oku…