// autor: Pawel Schmidt

// Uruchom monodevelop (bez ustawiania zmiennych srodowiskowych)
// a nastepnie utworz nowy projekt F#
// Plik -> Nowe Roziazanie -> .NET -> Projekt konsolowy -> F#
// Wklej ponizssza liste zadan do nowoutworzonego pliku


// W jezyku F# definiujemy zmienne uzywajac polecenia let [nazwa] = [wartosc]
// Na przyklad

let x = 12
let y = x * x + 3
let napis = "Ala ma kota"
let pol = 0.5

let para = 2, 8
let para2 = (2, 8)
let studentka = "Ala", 123456

// Zaznacz powyzsze deklaracje zmeinnych i wcisnij ctrl + enter.
// Przeniesie to je do "trybu interaktywnego", gdzie natychmiast 
// zostana obliczone jej wartosci. Nie musimy kompilowac i uruchamiac
// W samym trybie interaktywnym mozna tez pisac dowolne wyrazenia, definiowac funkcje
// zeby sie o tym przekonac, wpisz w trybie interaktywnym
// 123 + 456;;

// Zwroc uwage, ze nie musisz podawac typu o ile jest on latwy 
// do wywnioskowania 
// Jesli z jakichs wzgledow zaznaczyc typ, mozemy to zrobic:

let z : int = x + y
let s : string = "Ala ma konta."

// funkcje definiujemy przy uzyciu tego samego slowa kluczowego
// argumenty mozemy zawrzec w nawiasach lub kolejno po spacjach
// W przeciwienstwie do C#, nie uzywamy tutaj slowa kluczowego return
// Z funkcji zwracana jest pierwsza wartosc, ktora nie jest zwiazana 
// przy pomocy let .. = ..

// funkcja oblicza iloczyn dwoch liczb
let mult x y = 
    x * y
// funkcja oblicza sume dwoch liczb
let sum x y = 
    x + y

//Jesli chcemy obliczyc wartosc funkcji, wystarczy przekazac 
//jej argumenty przy uzyciu tej samej konwencji, ktorej uzylismy 
//definiujac funkcje

let res = mult 2 3
let res2 = sum 5 223


// W F# nie uzywamy wasow do zaznaczenie ciala funkcji lub 
// instrukcji warunkowych
// Zasieg funkcji jest okreslany poprzez wciecia.


// funkcja oblicza wartosc bezwzgledna 
let abs x =
    if x < 0
        then -x
        else x

// funkcja oblicza znak liczby
let sgn x = 
    if x < 0 
        then -1
        else
            if x = 0 // pojedyncza rownosc!
                then 0
                else 1

// ZADANIE: sprawdz, ze funkcja zwraca poprawne wyniki uruchamiajac wpisujac w trybie interaktywnym natepujace polecenia
// sgn -7;;
// sgn 0;;
// sgn 123;;


// ZADANIE: 
// zdefiniuj funkcje, ktora przyjmie jako argumenty dwie liczby
// a nastepnie zwroci wieksza z nich
// uzyj tylko instrukcji warunkowych (if / then / else)


// ZADANIE:
// zdefiniuj funkcje, ktora przyjmie jako argumenty trzy liczby
// a nastepnie zwroci najwieksza z nich
// wykorzystaj funkcje z poprzedniego zadania


// ZADANIE: 
// napisz funkcje, ktora podniesie argument do kwadratu, 
// a nastepnie wywolaj ja na twoim numerze indeksu




// Z pewnych wzgledow w F# musimy wprost zaznaczyc sowem kluczowym rec
// ze funkcja jest rekurencyjna (wywoluje sama siebie)

// funkcja oblicza sume liczb od 0 do n
let rec sum2 n = 
    if n = 0 
        then 0
        else 
            n + sum2 (n - 1)

// ZADANIE: 
// zdefiniuj funkcje obliczajaca silnie 
let rec factorial n =
    failwith "Uzupelnij" 

// ZADANIE: 
// napisz funkcje, ktora dla argumentu n obliczy n-ta
// liczbe Fibonacciego
// Sprawdz na kilku przykladach, ze dziala poprawnie

let rec fib n = 
    failwith "Uzupelnij"




// Podstawowa kolekcja uzywana w tym swiecie jest lista (jednokierunkowa)
// Elementy listy musza byc tego samego typu, oddzielamy je srednikami

// Lista pusta
let lst = []

// Lista zlozona z trzech elementow: liczb 1, 2 oraz 3
let lst1 = [1; 2; 3]

// Lista zlozona z kilku napisow
let lst2 = [ "Bolek"; "i"; "Lolek" ]

// Oczywiscie elementy moga sie powtarzac
let lst3 = [1; 2; 3; 1; 5]

// Lista zlozona z liczb od 2 do 17
let lst4 = [2..17]

// Co to za lista?
let lst5 = [ 3..2..14]

//Jesli mamy liste, mozemy utworzyc nowa liste doklejajac element na 
//jej przedzie
let lst6 = 176 :: lst4
let lst7 = 774 :: 22 :: lst5

// Co jest wartoscia tego wyrazenia?
let testLst = 
    [1; 2] = 1 :: 2 :: []


//Listy ze wzgledu na swoja budowe (doklejamy elementy tylko do przodu)
//przetwarzamy rekurencyjnie

let rec length (lst: int list) =
    match lst with      // sprawdz do czego dopasowuje sie lista
    | [] -> 0           // jesli lista jest pusta, zwroc 0
    | h::t ->           // jesli lista sklada sie z elementu h doklejonego do listy t
        let tLen = length t  // oblicz dlugosc listy t
        1 + tLen             // dlugosc listy to 1 + dlugosc jej ogona

let testLength1 = 
    let res = length [1;2;3]
    res = 3


// ZADANIE:
// napisz funkcje, ktora policzy sume wszystkich elementow listy bedacej jej argumentem 
// Przetestuj ja rzetelnie!
let rec listSum lst = 
    failwith "tutaj wpisz rozwiazanie"


// ZADANIE:
// Napisz funkcje listMin, ktora znajdzie minimalny element listy
// Jesli lista jest pusta, zwroc blad
let rec listMin lst = 
    match lst with
    | [] -> failwith "lista pusta"
    | [a] -> 
        failwith "Uzupelnij"

//    listMin [2;5;3;-12;7;43] = -12
//    listMin [100000..-1..7] = 7
//    listMin [93..100000] = 93

// ZADANIE:
// Napisz funkcje, ktora usunie z listy _pierwsze_ wystapienie danego elementu

let rec delete lst el = 
    failwith "Tutaj wpisz rozwiazanie"


// ZADANIE: 
// Wykorzystujac funkcje listMin i delete, zaprogramuj
// funkcje realizujaca algorytm sortownaia przez wybor:
// 1. Znajdz minimum listy. Oznaczmy je przez M
// 2. Usun M z listy. Oznaczmy tak powstala liste jako L.
// 3. Posortuj L otrzymujac L'.
// 3. Wynikiem powinna byc lista, ktora sklada sie z M oraz L'.

let rec selSort lst = 
    failwith "tutaj wpisz rozwiazanie"

// selSort [ 4; -3; 1; 123; -4; -5]

// ZADANIE:
// Napisz funkcje insert, ktora przyjmie dwa argumenty:
// liczbe oraz posortowana liste liczb 
// (to zakladamy o liscie, ale nie sprawdzamy; bedziemy wywolywac te funkcje tylko dla posortowanych list) 
// a nastepnie wstawi liczbe do listy tak, by ta nadal pozostala posortowana
let rec insert e lst =
    failwith "uzupelnij"


// let testInsert = insert 4 [] = [4]
// let testInsert2 = insert 5 [0; 2; 7; 8] = [0; 2; 5; 7; 8]
// let testInsert3 = insert -3 [0; 2; 7; 8] = [-3; 0; 2; 7; 8]
// let testInsert4 = insert 9 [0; 2; 7; 8] = [0; 2; 7; 8; 9]


// ZADANIE:
// Wykorzystaj powyzsza funkcje do zaimplementowania algorytmu sortowania przez wstawianie:
// 1. Posortuj wszystkie elementy listy oprocz pierwszego.
// 2. Wstaw pierwszy element do listy z punktu 1.
let rec insertSort lst = 
    failwith "uzupelnij"

// let testSort = insertSort [5; 3; 7; 2] = [2; 3; 5; 7]