diff options
Diffstat (limited to 'tr-tr')
| -rw-r--r-- | tr-tr/c-tr.html.markdown | 2 | ||||
| -rw-r--r-- | tr-tr/dynamic-programming-tr.html.markdown | 5 | ||||
| -rw-r--r-- | tr-tr/kotlin-tr.html.markdown | 474 |
3 files changed, 480 insertions, 1 deletions
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown index 33544765..6042a609 100644 --- a/tr-tr/c-tr.html.markdown +++ b/tr-tr/c-tr.html.markdown @@ -481,7 +481,7 @@ Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.or It's very important to use proper spacing, indentation and to be consistent with your coding style in general. Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the -[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle). +[Linux kernel coding style](https://www.kernel.org/doc/Documentation/CodingStyle). Diğer taraftan google sizin için bir arkadaş olabilir. diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown index 1900ee93..606ecf04 100644 --- a/tr-tr/dynamic-programming-tr.html.markdown +++ b/tr-tr/dynamic-programming-tr.html.markdown @@ -1,5 +1,6 @@ --- language: Dynamic Programming +filename: dynamic-tr.txt contributors: - ["Akashdeep Goel", "https://github.com/akashdeepgoel"] translators: @@ -27,6 +28,8 @@ En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini En uzun artan alt dizinin uzunluğunu bulmak için sözde kod: Bu algoritmaların karmaşıklığı dizi yerine daha iyi veri yapısı kullanılarak azaltılabilir. Büyük dizin ve dizin gibi selefi dizi ve değişkeni saklama çok zaman kazandıracaktır. Yönlendirilmiş asiklik grafiğinde en uzun yolu bulmak için benzer bir kavram uygulanabilir. + +```python for i=0 to n-1 LS[i]=1 for j=0 to i-1 @@ -35,6 +38,8 @@ for i=0 to n-1 for i=0 to n-1 if (largest < LS[i]) +``` + Bazı Ünlü Dinamik Programlama Problemleri -Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs—floyd-warshall-algorithm-with-c-program-source-code -Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—the-integer-knapsack-problem diff --git a/tr-tr/kotlin-tr.html.markdown b/tr-tr/kotlin-tr.html.markdown new file mode 100644 index 00000000..4d2dd291 --- /dev/null +++ b/tr-tr/kotlin-tr.html.markdown @@ -0,0 +1,474 @@ +--- +language: kotlin +filename: kotlin-tr.kt +contributors: + - ["Baha Can Aydın", "https://github.com/bahacan19"] +lang: tr-tr +--- +Kotlin, JVM, Android ve tarayıcı için statik olarak yazılmış bir programlama dilidir. +Java %100 birlikte çalışabilir. +[Daha:](https://kotlinlang.org/) + +```kotlin + +// Tek satır yoruma almak için : // +/* + Birkaç satırı yoruma almak için +*/ + +// "package" anahtar kelimesi tıpkı Java'da olduğu gibidir. +package com.learnxinyminutes.kotlin + +/* +Bir Kotlin programının başlama noktası (Java'da olduğu gibi) "com.learnxinyminutes.kotlin.main" metodudur. +Bu metoda komut satırından bir 'Array' gönderilebilir. +*/ +fun main(args: Array<String>) { + /* + Bir değer tanımlamak için "var" ya da "val" anahtar kelimeleri kullanılıyor. + "val" tanımlananlar tekrar atanamazken "var" tanımlananlar atanabilir. + */ + val fooVal = 10 // fooVal değerini daha sonra tekrar atayamıyoruz + var fooVar = 10 + fooVar = 20 // fooVar tekrar atanabilir. + + /* + Çoğu zaman, Kotlin bir değişkenin tipini anlayabilir, + bu yüzden her zaman belirtmeye gerek yoktur. + Bir değişkenin tipini şöyle belirtebiliriz: + */ + val foo: Int = 7 + + /* + String değerler Java'da olduğu gibi tanımlanır. + */ + val fooString = "İşte String bu!" + val barString = "Yeni satıra geçiyorum...?\nGeçtim!" + val bazString = "Tab mı istedin?\tAl bakalım!" + println(fooString) + println(barString) + println(bazString) + + /* + Raw string, üçlü çift-tırnak sınırlandırılan String bloklarıdır. + Tıpkı bir text editör gibi String tanımlamaya izin verir. + */ + val fooRawString = """ +fun helloWorld(val name : String) { + println("Merhaba, dünya!") +} +""" + println(fooRawString) + + /* + String değerler, ($) işareti ile birtakım deyimler ve değerler içererbilir + */ + val fooTemplateString = "$fooString değerinin ${fooString.length} adet karakteri vardır." + println(fooTemplateString) + + /* + Null atanabilen bir değişken nullable olarak tanımlanmalıdır. + Bu, deişken tipinin sonuna ? eklenerek yapılabilir. + Erişim ise '?.' operatörü ile yapılır. + Bir değişken null ise, yerine kullaılacak alternatif bir değer belirtmek için + '?:' operatörünü kullanırız. + */ + var fooNullable: String? = "abc" + println(fooNullable?.length) // => 3 + println(fooNullable?.length ?: -1) // => 3 + fooNullable = null + println(fooNullable?.length) // => null + println(fooNullable?.length ?: -1) // => -1 + + /* + Metodlar "fun" anahtar kelimesi ile tanımlanır. + Metod argümanları, Metod adından sonra parantez içinde belirtilir. + Metod argümanlarının opsiyonel olarak default (varsayılan) değerleri olabilir. + Metodun dönüş tipi, gerekirse, metod parentezinden sonra ':' operatörü ile belirtilir. + */ + fun hello(name: String = "dünya"): String { + return "Merhaba, $name!" + } + println(hello("foo")) // => Merhaba, foo! + println(hello(name = "bar")) // => Merhaba, bar! + println(hello()) // => Merhaba, dünya! + + /* + Bir metoda çokca argüman göndermek için 'vararg' anahtar kelimesi + kullanılır. + */ + fun varargExample(vararg names: Int) { + println("${names.size} adet arguman paslanmıştır") + } + varargExample() // => 0 adet arguman paslanmıştır + varargExample(1) // => 1 adet arguman paslanmıştır + varargExample(1, 2, 3) // => 3 adet arguman paslanmıştır + + /* + Bir metod tek bir ifadeden oluşuyorsa + süslü parantezler yerine '=' kullanılabilir. + */ + fun odd(x: Int): Boolean = x % 2 == 1 + println(odd(6)) // => false + println(odd(7)) // => true + + // Eğer dönüş tipi anlaşılabiliyorsa ayrıca belirtmemize gerek yoktur. + fun even(x: Int) = x % 2 == 0 + println(even(6)) // => true + println(even(7)) // => false + + // Metodlar, metodları arguman ve dönüş tipi olarak alabilir + fun not(f: (Int) -> Boolean): (Int) -> Boolean { + return {n -> !f.invoke(n)} // bu satırdaki !f.invoke(n) metodu !f(n) şeklinde sadeleştirilebilir. + } + + + // Bir metodu sadece '::' ön eki ile de arguman olarak çağırabiliriz + println(not(::odd)(4)) // ==> true + + // Metodlar değişken gibi atanabilir. + val notOdd = not(::odd) + val notEven = not(::even) + + // Lambda ifadeleri arguman olarak paslanabilir. + val notZero = not {n -> n == 0} + /* + Eğer bir lambda fonksiyonu sadece bir arguman alıyorsa, + '->' ifadesi atlanabilir, 'it' ifadesi ile belirtilebilir. + */ + val notPositive = not { it > 0} // not(n -> n > 0) ifadesi ile aynı + + for (i in 0..4) { + println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}") + } + + /* + * Diğer for döngüleri + * */ + val myInt = 3 + for (i in 1..100) { } // kapalı aralık. 100 dahil. + for (i in 1 until 100) { } // 100 dahil değil + for (x in 2..10 step 2) { } // ikişer adımlı + for (x in 10 downTo 1) { } // Ondan geriye doğru. 1 dahil. + if (myInt in 1..10) { } + + + + /* + Bir sınıf tanımlamak için 'class' anahtar kelimesi kullanılır. + Kotlin'de bütün sınıflar varsayılan olarak 'final' tanımlanırlar. + * */ + class ExampleClass(val x: Int) { + + fun memberFunction(y: Int): Int { + return x + y + } + + infix fun yTimes(y: Int): Int { + return x * y + } + } + /* + * Bir sınıfı türetilebilir yapmak için 'open' anahtar kelimesi kullanılır. + * */ + open class A + + class B : A() + + + /* + Yeni bir instance oluşturmak için doğrudan constructor çağırılır. + Kotlinde 'new' anahtar kelimesi yoktur. + */ + val fooExampleClass = ExampleClass(7) + // Bir sınıfa üye metodları . (nokta) ile çağırabiliriz. + println(fooExampleClass.memberFunction(4)) // => 11 + /* + 'infix' ön eki ile tanımlanan metodlar + alışılan metod çağrısını daha kolay bir söz dizimine dönüştürür. + */ + println(fooExampleClass yTimes 4) // => 28 + + /* + Data class lar sadece veri tutan sınıflar için uygun bir çözümdür. + Bu şekilde tanımlanan sınıfların "hashCode"/"equals" ve "toString" metodları + otomatik olarak oluşur. + */ + data class DataClassExample (val x: Int, val y: Int, val z: Int) + val fooData = DataClassExample(1, 2, 4) + println(fooData) // => DataClassExample(x=1, y=2, z=4) + + // Data class ların copy metodları olur. + val fooCopy = fooData.copy(y = 100) + println(fooCopy) // => DataClassExample(x=1, y=100, z=4) + + // Destructuring Declarations, bir objeyi çoklu değişkenler ile ifade etme yöntemidir. + val (a, b, c) = fooCopy + println("$a $b $c") // => 1 100 4 + + // bir 'for' döngüsü içinde 'Destructuring' : + for ((a, b, c) in listOf(fooData)) { + println("$a $b $c") // => 1 100 4 + } + + val mapData = mapOf("a" to 1, "b" to 2) + // Map.Entry de destructurable gösterilebilir. + for ((key, value) in mapData) { + println("$key -> $value") + } + + // 'with' metodu ile bir objeye bir lamda metodu uygulayabiliriz. + data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) + val fooMutableData = MutableDataClassExample(7, 4, 9) + with (fooMutableData) { + x -= 2 + y += 2 + z-- + } + + println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8) + + /* + 'listOf' metodu ile bir liste oluşturulabilir. + Oluşan liste immutable olacaktır, yani elaman eklenemez ve çıkarılamaz. + */ + val fooList = listOf("a", "b", "c") + println(fooList.size) // => 3 + println(fooList.first()) // => a + println(fooList.last()) // => c + // Elemanlara indexleri ile erişilebilir. + println(fooList[1]) // => b + + // Mutable bir liste ise 'mutableListOf' metodu ile oluşturabilir. + val fooMutableList = mutableListOf("a", "b", "c") + fooMutableList.add("d") + println(fooMutableList.last()) // => d + println(fooMutableList.size) // => 4 + + // Bir 'set' oluşturmak için 'setOf' metodunu kullanabiliriz. + val fooSet = setOf("a", "b", "c") + println(fooSet.contains("a")) // => true + println(fooSet.contains("z")) // => false + + // 'mapOf' metodu ile 'map' oluşturabiliriz. + val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9) + // Map değerlerine ulaşmak için : + println(fooMap["a"]) // => 8 + + /* + Sequence, Kotlin dilinde lazy-hesaplanan collection ları temsil eder. + Bunun için 'generateSequence' metodunu kullanabiliriz. Bu metod bir önceki değerden + bir sonraki değeri hesaplamak için gerekli bir lamda metodunu arguman olarak alır. + */ + val fooSequence = generateSequence(1, { it + 1 }) + + val x = fooSequence.take(10).toList() + println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + + // Örneğin fibonacci serisi oluşturabilen bir 'Sequence' oluşturmak için: + fun fibonacciSequence(): Sequence<Long> { + var a = 0L + var b = 1L + + fun next(): Long { + val result = a + b + a = b + b = result + return a + } + + return generateSequence(::next) + } + val y = fibonacciSequence().take(10).toList() + println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] + + + // Kotlin Collection lar ile çalışmak için higher-order metodlar sağlar. + val z = (1..9) + .map {it * 3} // her bir elamanı 3 ile çarp + .filter {it < 20} // 20 den küçük değerleri ele + .groupBy {it % 2 == 0} // ikiye tam bölünen ve bölünmeyen şeklinde grupla (Map) + .mapKeys {if (it.key) "even" else "odd"} // oluşan map in boolen 'key' lerini String bir değere dönüştür. + println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]} + + // Bir 'for' döngüsü 'itearator' sağlayan her objeye uygulanabilir. + for (c in "merhaba") { + println(c) + } + + // 'while' döngüsü diğer dillere benzer şekilde çalışır. + var ctr = 0 + while (ctr < 5) { + println(ctr) + ctr++ + } + do { + println(ctr) + ctr++ + } while (ctr < 10) + + /* + 'if' bir dönüş değeri olan deyim gibi de kullanılabilir. + Bu sebepten Kotlin, Java'da bulunan '?:' ifadesi içermez. + */ + val num = 5 + val message = if (num % 2 == 0) "even" else "odd" + println("$num is $message") // => 5 is odd + + // 'if-else if' yapıları için 'when' kullanılabilir. + val i = 10 + when { + i < 7 -> println("first block") + fooString.startsWith("hello") -> println("second block") + else -> println("else block") + } + + // 'when' bir parametre ile de kullanılabilir. + when (i) { + 0, 21 -> println("0 or 21") + in 1..20 -> println("in the range 1 to 20") + else -> println("none of the above") + } + + // 'when' dönüş değeri olan bir metod gibi de davranabilir. + var result = when (i) { + 0, 21 -> "0 or 21" + in 1..20 -> "in the range 1 to 20" + else -> "none of the above" + } + println(result) + + + /* + Bir objenin tipini 'is' operatörü ile tayin edebiliriz. + Eğer obje tip kontrolünü geçerse, cast etmeden doğrudan + o tipteymiş gibi kullanılabilir. + */ + fun smartCastExample(x: Any) : Boolean { + if (x is Boolean) { + // x otomatik olarak Boolean'a cast edilir. + return x + } else if (x is Int) { + // x otomatik olarak Int tipine cast edilir. + return x > 0 + } else if (x is String) { + // x otomatik olarak String tipine cast edilir. + return x.isNotEmpty() + } else { + return false + } + } + println(smartCastExample("Merhaba, dünya!")) // => true + println(smartCastExample("")) // => false + println(smartCastExample(5)) // => true + println(smartCastExample(0)) // => false + println(smartCastExample(true)) // => true + + // Smartcast 'when' bloğu ile de çalışır. + fun smartCastWhenExample(x: Any) = when (x) { + is Boolean -> x + is Int -> x > 0 + is String -> x.isNotEmpty() + else -> false + } + + /* + Extension lar, bir sınıfa fonksinolalite eklemenin bir yoludur. + */ + fun String.remove(c: Char): String { + return this.filter {it != c} + } + println("Merhaba, dünya!".remove('a')) // => Merhb, düny! + + + + //Biraz detaylı Kotlin + + + /* + * Delegated Properties, bir değişken tanımlarken kullanılan birkaç standart yöntemler içerir. + * https://kotlinlang.org/docs/reference/delegated-properties.html + * En bilinen delegate property metodları: lazy(), observable() + * */ + + /* + * Lazy, bir değişkeni ilk erişimde çalıştırılacak olan bir lambda ile tanımlama metodudur. + * Sonraki erişimlerde değişkene atanan değer hatırlanır. + * Lazy, synchronized bir delegation yöntemidir; değer sadece bir thread içinde hesaplanır, + * tüm thread ler aynı değere erişir. Eğer senkronizasyon gerekli değilse, lazy metodu içine + * LazyThreadSafetyMode.PUBLICATION paslanabilir. + * */ + + val lazyValue: String by lazy( { + println("bi sn... hesaplıyorum....") + "Selam!" + }) + + println(lazyValue)// bi sn... hesaplıyorum.... Selam! + println(lazyValue) // Selam! + /* + * Observable, bir değişkende olabilecek yeniden atama değişikliklerini dinleme yöntemidir. + * İki arguman alır; değişkenin ilk değeri, değiştiğinde çağrılan bir handler metodu. Handler + * metodu değişken her değiştiğinde çağırılır. + * */ + var myObservableName: String by Delegates.observable("<isim yok>") { + prop, old, new -> + println("$old -> $new") + } + myObservableName = "Baha" //<isim yok> -> Baha + myObservableName = "Can" //Baha -> Can + + + /* + * Eğer değişkenin yeniden atanmasını denetlemek isterek vetoable() + * metodunu kullanabiliriz. + * */ + + var myVetoableName : String by Delegates.vetoable("<isim yok>"){ + property, oldValue, newValue -> + if (newValue.length < 2) { + println("Tek harfli isim kabul etmiyoruz!") + false + } else { + println("$oldValue -> $newValue") + true + } + } + + myVetoableName = "Baha" //<isim yok> -> Baha + myVetoableName = "C" //Tek harfli isim kabul etmiyoruz! + println(myVetoableName) //Baha + + + //singleton değişkene ulaşmak: + println(ObjectExample.hello()) // => Merhaba +} + +// Enum class lar Java'daki enum lara benzerdir. +enum class EnumExample { + A, B, C +} + +/* +'object' anahtar kelimesi ile singleton nesneler oluşturulabilir. +Bu şekilde tanımlanan sınıflardan yeni nesneler oluşturulamaz, sadece adı ile refere edilebilir. +*/ +object ObjectExample { + fun hello(): String { + return "Merhaba" + } +} + +fun useObject() { + ObjectExample.hello() + val someRef: Any = ObjectExample +} + +``` + +### İlerisi için: + +* [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/) +* [Try Kotlin in your browser](http://try.kotlinlang.org/) +* [A list of Kotlin resources](http://kotlin.link/) +* [Kotlin Koans in your IDE](https://kotlinlang.org/docs/tutorials/koans.html/) |