<jupyter_start><jupyter_text>Kotlin - Fundamenty 1.1 Struktura koduTa część opisuje podstawową składnię języka Kotlin.<jupyter_code>fun main ( args : Array<String>) {
    println( " Hello , world ! " )
}<jupyter_output><empty_output><jupyter_text>Słowo kluczowe ``fun`` służy do zadeklarowania funkcji, ``main()`` jest miejscem wejściowym aplikacji. Aplikacja musi posiadać co najmniej jedno miejsce wejściowe. Tutaj należy również zauważyć, że funkcje można deklarować na najwyższym poziomie kodu, czyli nie jest konieczne umieszczanie ich w klasach lub pakietach tak jak w Javie. Metoda ``println()`` jest opakowaną funkcją Java, tutaj oznacza to że możemy użyć bardziej zwięzłej nazwy (zamiast ``System.out.println()``). Kolejną istotną zmianą w stosunku do Javy jest **brak średnika** na końcu wiersza. Tablice w Kotlinie są klasą, w odróżnieniu od Javy, nie ma specjalnej składni deklarowania tablic. W Kotlinie jest trzeci typ komentarzy (poza znanymi: jednoliniowym ``//`` oraz wieloliniowym ``/* */``) Javadoc. Jest on pomocny podczas przygotowywania dokumentacji projektu. Rozpoczyna się od ``/**`` i kończy ``*/``<jupyter_code>/**
* Application entry point
*
* @param args aray of command - line arguments
* passed to this method
*/
fun main ( args : Array<String>) {
    // TODO code application logic here
}<jupyter_output><empty_output><jupyter_text>W tym przykładzie widzimy przykład komentarza Javadoc opisującego metodę ``main()``. ``@param`` jest adnotacją (tutaj tagiem Javadoc). Kilka przykładów adnotacji:- ``@param`` – identyfikuje parametr metody- ``@author`` – identyfikuje autora kodu- ``@deprecated`` – identyfikuje byt w kodzie źródłowym, który nie powinien być już używany- ``@throws`` – dokumentuje wyjątek rzucany przez metodę  1.2 val vs var<jupyter_code>val s = "string"
s = "inyy"
val i = 44
val j: Int = 44
val d = 7.56e4<jupyter_output>Line_11.jupyter-kts (2:1 - 2) Val cannot be reassigned<jupyter_text>Gdy identyfikator przechowuje dane, musisz zdecydować, czy można je ponownie przypisać.- `var` - *variable* oznacza że moża ponownie przypisać jej wartość- `val` - *value* może zostać tylko zainicjowana, nie można ponownie przypisać jej innej wartośćiW trzeciej linii typ wpisany jest jawnie. Podobnie jak w argumentach funkcji i typie zwracanej wartości funkcji, typ zmiennej jest określany po następującym po nazwie dwukropku. Jeżeli tego nie zrobimy, kompilator przeanalizuje wyrażenie inicjujące zmienną i za typ zmiennej przyjmie typ wyrażenia. Jeżeli zainicjujemy zmienną wartością zmiennoprzecinkową, za typ zostanie przyjęty `Double`. Jeżeli nie inicjuje się zmiennej, jej typ należy określić jawnie. `val` jest *niemutowalny*, natomiast `var` oznacza zmienną *mutowalną*. Więc zmienna `val` może zostać zainicjowana tylko raz w bloku kodu w którym się znajduje.<jupyter_code>val napis: String = "napis"
napis = "inny napis"

println(napis)<jupyter_output>Line_27.jupyter-kts (2:1 - 6) Val cannot be reassigned<jupyter_text>Poniższy kod wygeneruje błąd.<jupyter_code>val a: Int
if(true) {
    a = 5
}
else {
    a = 6
}<jupyter_output>Line_26.jupyter-kts (3:5 - 6) Captured member values initialization is forbidden due to possible reassignment<jupyter_text>Zmienna ``val`` jest niemutowalna, jednak obiekt na który ona wskazuje może być mutowalny, przykładowo<jupyter_code>val lectures = arrayListOf("PUM")
lectures.add("Programming")
lectures[0] = "WpumKJ"
println(lectures)

val second = arrayListOf("lista")
println(second)

// second = first

var third = arrayListOf("trzeci")
println(third)
third = lectures
println(third)<jupyter_output>[WpumKJ, Programming]
[lista]
[trzeci]
[WpumKJ, Programming]<jupyter_text>W powyższym przykładzie stała ``lectures`` jest niemutowalna, jednak obiekt na który wskazuje jest mutowalny, więc możemy wykonać operację dodania elementu. Słowo kluczowe ``var`` oznacza zmienną mutowalną, jednak nie oznacza to że można zmienić typ zmiennej, przykładowo<jupyter_code>var liczba = 33
liczba = 11 // ok
liczba = "napis" // error<jupyter_output>Line_31.jupyter-kts (3:10 - 17) Type mismatch: inferred type is String but Int was expected<jupyter_text>Powyższy przykład wygeneruje błąd, ponieważ domniemanie typu odbywa się tylko podczas jej inicjowania  1.3 Typy danychKotlin jest językiem o silnej typizacji, czyli każda zmienna, wyrażenie itp. posiada typ znany kompilatorowi. To sprawia że kompilator jest w stanie wykryć błędy związane z typami na poziomie kompilacji. W Kotlinie każdy typ jest klasą (przykładowo ``Int``) - zauważmy że nazwy typów zaczynają się od wielkiej litery.<jupyter_code>val myMinIntValue = Integer.MIN_VALUE;
val myMaxIntValue = Integer.MAX_VALUE;
println("Integer Minimum Value = " + myMinIntValue);
println("Integer Maximum Value = " + myMaxIntValue);

val myMinByteValue = Byte.MIN_VALUE;
val myMaxByteValue = Byte.MAX_VALUE;
println("Byte Minimum Value = " + myMinByteValue);
println("Byte Maximum Value = " + myMaxByteValue);

val myMinShortValue = Short.MIN_VALUE;
val myMaxShortValue = Short.MAX_VALUE;
println("Short Minimum Value = " + myMinShortValue);
println("Short Maximum Value = " + myMaxShortValue);
        
val myMinLongValue = Long.MIN_VALUE;
val myMaxLongValue = Long.MAX_VALUE;
println("Long Minimum Value = " + myMinLongValue);
println("Long Maximum Value = " + myMaxLongValue);

val myMinFloatValue = Float.MIN_VALUE;
val myMaxFloatValue = Float.MAX_VALUE;
println("Float minimum value = " + myMinFloatValue);
println("Float maximum value = " + myMaxFloatValue);

val myMinDoubleValue = Double.MIN_VALUE;
val myMaxDoubleValue = Double.MAX_VALUE;
println("Double minimum value = " + myMinDoubleValue);
println("Double maximum value = " + myMaxDoubleValue);

val myChar = 'D';
val myUnicodeChar = '\u0044';
println(myChar);
println(myUnicodeChar);

val myCopyrightChar = '\u00A9';
println(myCopyrightChar);

val myTrueBooleanValue = true;
val myFalseBooleanValue = false;<jupyter_output>Integer Minimum Value = -2147483648
Integer Maximum Value = 2147483647
Byte Minimum Value = -128
Byte Maximum Value = 127
Short Minimum Value = -32768
Short Maximum Value = 32767
Long Minimum Value = -9223372036854775808
Long Maximum Value = 9223372036854775807
Float minimum value = 1.4E-45
Float maximum value = 3.4028235E38
Double minimum value = 4.9E-324
Double maximum value = 1.7976931348623157E308
D
D
©<jupyter_text>Rzutowanie w Kotlinie wykonujemy wywołując w tym celu odpowiednią metodę<jupyter_code>val num = 100
var secondNum : Byte = 0
secondNum = ((num / 2 ).toByte())
println(secondNum)<jupyter_output>50<jupyter_text>1.4 Instrukcje warunkowe i pętle Instrukcja warunkowa ``if``W Javie struktury sterujące są instrukcjami, oznacza to że są elementami kodu i nie posiadają wartości. Istotną różnicą między Kotlinem a Javą jest operator przypisania - w Javie jest on wyrażeniem, w Kotlinie - instrukcją.<jupyter_code>var num: Int = 0
val someCondition = 20 < 22
if (someCondition) {
    num = 50
}
else {
    num = 592
}

val num2 = if (someCondition) 50 else 592
println(num2)

println("The result of the if expression is ${num2}")<jupyter_output>50
The result of the if expression is 50<jupyter_text>Wyrażenie ``when``W Kotlinie instrukcję ``switch`` zastąpiło wyrażenie ``when``<jupyter_code>fun element(i: Int) = when {
    i == 0 -> "element 0"
    i == 3 -> "element 3"
    i == 5 -> "element 5"
    else -> "$i "
}

val x = 0
when (x) {
    0, 1 -> println("x == 0 or x == 1")
    else -> println("otherwise")
}

println(element(0))<jupyter_output>x == 0 or x == 1
element 0<jupyter_text>Pętla ``for`` i zakresy<jupyter_code>fun isLetter(c: Char) = c in 'a'..'z' || c in 'A'..'Z'
fun isNonDigit(c: Char) = c !in '0'..'9'

fun recognize(c: Char) = when (c){
    in '0'..'9' -> "Digit"
    in 'a'..'z', in 'A'..'Z' -> "Letter"
    else -> "Different"
}

println(recognize('3'))
println(recognize('A'))
println(isLetter('c'))
println(isNonDigit('4'))
for (i in 1..3) {
    println(i)
}
for (i in 6 downTo 0 step 2) {
    println(i)
}<jupyter_output>1
2
3
6
4
2
0<jupyter_text>Pętla ``for`` iteruje przez wszystkie kolekcje posiadające ``iterator``. Pętla ``or`` przechodziąca przez wszystkie elementy tablicy lub uporządkowanej kolekcji posiadającej ``index`` można to wykonać na dwa sposoby<jupyter_code>val array = arrayOf("a", "b", "c")
for (i in array.indices) {
    println(array[i])
}

for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}

for (i in array){
    println(i)
}<jupyter_output>a
b
c
the element at 0 is a
the element at 1 is b
the element at 2 is c
a
b
c<jupyter_text>Pętla ``while`` i ``do while``<jupyter_code>var x = 10

while (x > 0) {
    println(x)
    x--
}

do {
    println(x)
    x++
} while (x < 11)<jupyter_output>10
9
8
7
6
5
4
3
2
1
0
1
2
3
4
5
6
7
8
9
10<jupyter_text>1.5 Tablice - podstawy Tablica jest typem zmiennej obiektowe służącej jako kontener dla danych zgrupowanych pod wspólną nazwą. poniżej kilka właściwości/cech tablic w ``Kotlinie``:- tablice są alokowane dynamicznie- tablice są typami obiektowymi- indeksy w tablicy rozpoczynają się od zera- rozmiar tablicy musi być określony przez ``int``- dziedziczy po klasie ``Any``Deklarując tablicę zostaje ona wypełniona wartościami domyślnymi (``0`` dla tablicy typu ``Int``)<jupyter_code>val arr = IntArray(5)
for(i in arr)
    println(i)<jupyter_output>0
0
0
0
0<jupyter_text>Wartość domyślną można zdefiniować przy deklaracji tablicy<jupyter_code>val arr = IntArray(5){11}
for(i in arr)
    println(i)<jupyter_output>11
11
11
11
11<jupyter_text>1.6 Metody i funkcjePodstawowa składnia metod w Kotlinie wygląda następująco`fun name (parameter_list): return_type {// statements to execute}`czyli zaczynamy od słowa kluczowego `fun` następnie podajemy nazwę metody, w nawiasie listę argumentów, na końcu po dwukropku podajemy typ zwracany przez funkcję<jupyter_code>fun double(x: Int): Int {
    return 2 * x
}

val result = double(2)
println(result)<jupyter_output>4<jupyter_text>W Kotlinie funkcje mogą posiadać ciało blokowe lub ciało wyrażeniowe, rozpocznijmy od napisania funkcjji `max`, zwracającej większą z dwóch liczb, posiadającą ciało blokowe<jupyter_code>fun max(a: Int, b: Int): Int{
    return if(a > b) a else b
}

max(2, 4)<jupyter_output><empty_output><jupyter_text>Tuutaj warto zwrócić uwagę na zastosowanie wyrażenia `if else`, które jest podobne do operatora elvisa znaneego z Javy.Napiszmy teraz tą samą funkcję z ciałem wyrażeniowym<jupyter_code>fun max2(a: Int, b: Int): Int = if (a > b) a else b
max2(2, 4)<jupyter_output><empty_output><jupyter_text>Funkcję tą można uprościć poprzez pominięcie typu zwracanego (tylko w funkcji z ciałem wyrażeniowym), można tak zrobić, ponieważ kompilator jako tyyp wyniku przyjmie typ wyrażenia<jupyter_code>fun max3(a: Int, b: Int) = if (a > b) a else b
max2(2, 4)<jupyter_output><empty_output><jupyter_text>Lista 1 Zad 1 - **2 pkt**Wypisz wszystkie liczby od 1 do 100, jednak jeżeli liczba jest podzielna przez:- 3 - wypisz "trzy"- 5 - wypisz "piec"- 3 i 5 - wypisz "trzypiec"`12trzy4piectrzy78trzypiec11trzy1314trzypiec`  Zad 2 - **2 pkt**Rozszerz Zad 1 o liczbę 7.Jeżeli liczba jest podzielna przez:- 7 - wypisz "siedem"- 3 i 7 - wypisz "trzysiedem"- 5 i 7 - wypisz "piecsiedem"- 3, 5 i 7 - wypisz "trzypiecsiedem"  Zad 3 - **2 pkt**Rozszerz Zad 2 o liczby 11 i 13.Jeżeli liczba jest podzielna przez:- 11 - wypisz "jedenascie"- 3 i 11 - wypisz "trzyjedenascie"- 3, 5, 7 i 11 - wypisz "trzypiecsiedemjedenascie"- itd...  Zad 4 - **4 pkt**Napisz funkcję `missingNumber`, która jako argument przyjmuje tablicę `N` liczb naturalnych. W tablicy wszystkie elementy są unikalne. Tablica ma długość `N`. W tablicy brakuje jednego elementu z zakresu. Funkcja missingNumber powinna zwrócić brakujący element:<jupyter_code>val tab: intArray = intArrayOf(2, 4, 5, 3, 0, 6) // N = 6
println(missingNumber(tab))<jupyter_output><empty_output><jupyter_text>``1``<jupyter_code>val tab: intArray = intArrayOf(0, 1, 2, 3) // N = 4
println(missingNumber(tab))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10185030838473079, 'fraction_numerical': 0.030088348058009667, 'mean_word_length': 5.22677737415672, 'pattern_counts': {'":': 0, '<': 78, '<?xml version=': 0, '>': 89, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '22', 'dir': 'jupyter-structured-clean-dedup', 'id': '225424', 'license': 'MIT', 'n_tokens_mistral': 5051, 'n_tokens_neox': 4954, 'n_words': 1386, 'path': '2021-2022/Laboratorium/Lab 1 - Kotlin - Fundamenty.ipynb', 'repo_name': 'RafLew84/WpumKJ', 'size': '11998'}