// Learn more about F# at http://fsharp.org

open System

type osoba = {name:string;wiek:int}

type drzewo<'a> =
    |Lisc of 'a
    |Wezel of ('a * (drzewo<'a> list)) //wezel może mieć wiele potomków, dlatego list

type pociag (id_:int64, relacja_:string) =
    inherit Object()
    let mutable id:int64 = id_
    let mutable relacja:string = relacja_

    member this.Id
        with get () = id
    member this.Relacja
        with get () = relacja
        and set (value:string) = relacja <- value

type ekspres (id:int64, relacja:string,akcRower:bool) =
    inherit pociag(id,relacja)
    let mutable akcRower: bool = akcRower

// typ dyskryminacyjny o nazwie rbdrzewo do reprezentacji pełnego drzewa binarnego przenoszącego dane typu int.
//Pełne drzewo binarne //uwaga! nie jest uwzględnione, że korzeń ma wartość
type rbdrzewo<'a> =
    |Lisc of 'a
    |Korzen of (rbdrzewo<'a>  * rbdrzewo<'a>) // tutaj jest ok, nie ma list, ponieważ korzeń może mieć 2 potomków
//Napisz funkcję wyszukującą wartość maksymalną w drzewie powyżej
let rec max (drzewo:rbdrzewo<'a>) =
    match drzewo with
    | Lisc i -> i
    | Korzen (i,j) -> max(j)
// Napisz funkcję wyznaczającą łączaną sumę wszystkich węzłów
//interpretacja - ilość wszystkich węzłów
let rec lacznaSumaWezlow (drzewo) : int =
    match drzewo with
    | Lisc i -> 1
    | Korzen (i,j) -> 1 + (lacznaSumaWezlow i) + (lacznaSumaWezlow j)

//Inna wersja powyższego
type rbdrzewo_poprawione<'a> =
    |Lisc of 'a
    |Korzen of ('a * rbdrzewo_poprawione<'a> * rbdrzewo_poprawione<'a>)
//teraz tak bedzie wygladac
let rec max2 (drzewo:rbdrzewo_poprawione<'a>) =
    match drzewo with
    |Lisc i -> i
    |Korzen (i,tree1,tree2) -> max2(tree2)
// Napisz funkcję wyznaczającą łączaną sumę wszystkich węzłów
//interpretacja - suma wartości wszystkich węzłów
//ponieważ jest <'a>, dlatego konwersja do Inta
let rec lacznaSumaWezlow2 (drzewo:rbdrzewo_poprawione<'a>) : int =
    match drzewo with
    | Lisc i -> System.Convert.ToInt32(i)
    | Korzen (i,t1,t2) -> System.Convert.ToInt32(i) + (lacznaSumaWezlow2 t1) + (lacznaSumaWezlow2 t2)

//Napisz funkcję wykorzystującą wyrażenie lambda, wybierającą te elementy z listy liczb rzeczywistych (float list),
//które są całkowite parzyste (wynik typu int list).
let wybierzParzyste (tab:float list) =
    let parzyste = List.filter (fun x -> int(x) % 2 = 0) tab
    List.map (fun x -> int(x)) parzyste

//sekwencja x / (i + 1 ), x jest argumentem sekwencji
let seq1 x = Seq.initInfinite (fun i -> float(x/i+1)) //złe - nie może być Infinite, jest od i do x (i = 1  początkowo)

let seqq1 x = seq {
               let mutable i = 1;
               while i <= x do
                    yield float(x/(i+1))
                    i <- i + 1 // tak się przypisuje wartość do zmiennej mutable
            }

let seqq1_ref x = seq{
              let i = ref 1
              while !i <= x do
                    yield float(x/(!i+1))
                    i := !i  + 1 // tak się przypisuje wartość do zmiennej ref
            }

//kwerenda zawężająca wyniki do tych, które są większe od 1e-9
let kwerenda1 = query {
                for x in (seqq1 2) do
                where (x > 1e-9)
                select x
    }

//Napisac funkcje która znajdzie osoby z przedziału wieku <20, 30> i
//zaczynające się na slowo “Ko” type osoba = {wiek : int, nazwisko : string}
let znajdzOsoby (listaOsob:osoba list) =
    List.filter (fun osoba -> osoba.name.StartsWith("Ko") && osoba.wiek > 20 && osoba.wiek < 30 ) listaOsob

//Zaproponuj typ dyskryminacyjny o nazwie rbdrzewo repeprezentujace drzewo czarnoczerwone.
//Poszczególne dane sa typu int. Drzewo ma wierzchołki typu 1)czarne liscie 2)czerwnoe liscie 3)czarny korzen.
//Korzenie sa zawsze z dwoma potomkami lewym i prawym, ktore mogą byc typu 1 2  3
type rbdrzewo2 =
    |ListCzarny of int
    |ListCzerwony of int
    |Korzen of (rbdrzewo2 * rbdrzewo2 )
//pytanie czy korzeń może przechowywać wartość, jeżeli tak, to:
//  |Korzen of (int * rbdrzewo2 * rbdrzewo2 )

let rec wyszukajWszystkieLiscieCzerwony (drzewo:rbdrzewo2) =
    match drzewo with
        |ListCzarny i -> []
        |ListCzerwony i -> [ListCzerwony i]
        |Korzen (i,j) -> (wyszukajWszystkieLiscieCzerwony i)@(wyszukajWszystkieLiscieCzerwony j)

//wyszukiwanie wszystkich czarnych liści w drzewie
let rec wyszukajWszystkieCzarne (drzewo:rbdrzewo2) =
    match drzewo with
    |ListCzerwony i -> []
    |ListCzarny  i->  [ListCzarny  i]
    |Korzen (i,j)-> (wyszukajWszystkieCzarne i)@(wyszukajWszystkieCzarne j)

//typ drzewo o czarnym lisciu, czerwonym korzeniu i czarnym korzeniu, przenoszą dowolne typy
type KolejneDrzewo<'a> =
    |LiscCzarny of 'a
    |LiscCzerwony of 'a
    |CzarnyKorzen of ('a * KolejneDrzewo<'a> * KolejneDrzewo<'a> )

//wyszukaj wszystkie Czarne węzły
let rec znajdzWszystkieCzarneWezly (d:KolejneDrzewo<'a>) =
    match d with
    |LiscCzarny i -> [LiscCzarny i]
    |LiscCzerwony i -> []
    |CzarnyKorzen (i,t1,t2) -> [CzarnyKorzen (i,t1,t2)]@(znajdzWszystkieCzarneWezly t1)@(znajdzWszystkieCzarneWezly t2)

let rec wyznaczNajwiekszaWysokosc (d:KolejneDrzewo<'a>) : int =
    match d with
        |LiscCzarny i | LiscCzerwony i -> 1
        |CzarnyKorzen (i,t1,t2) -> System.Math.Max((wyznaczNajwiekszaWysokosc t1),(wyznaczNajwiekszaWysokosc t2))

 // Dane jest drzewo powyższe. Napisz funkcje wyznaczajaca w drzeiw liczbę węzłów czarnych
let rec zliczCzarrneLiscie (drzewo:rbdrzewo2) :int =
    match drzewo with
    | ListCzerwony i -> 0
    | ListCzarny i -> 1
    | Korzen (i,j) -> (zliczCzarrneLiscie i)+(zliczCzarrneLiscie j)
//modyfikacja powyższego, uwzględnia czarny korzeń
let rec zliczCzarrneWezly (drzewo:rbdrzewo2) : int =
    match drzewo with
    | ListCzerwony i -> 0
    | ListCzarny i -> 1
    | Korzen (i,j) -> 1 + (zliczCzarrneWezly i) + (zliczCzarrneWezly j) //korzeń jest czarny, dlatego należy go uwzględnić

//Inny przykład
//próba opisujący drzewo czarno-czerwone przenoszący DOWOLNE wartości - chyba tak będzie:
type rbdrzewo3Dowolne<'a> =
    |KorzenCzarny of 'a * rbdrzewo3Dowolne<'a>  * rbdrzewo3Dowolne<'a>
    |KorzenCzerwony of 'a * rbdrzewo3Dowolne<'a>  * rbdrzewo3Dowolne<'a>
    |Lisc of 'a
//funkcja zwracająca drzewo gdzie wszystkie czerwone węzły są zamienione na czarne
let rec zamienDowolne d:rbdrzewo3Dowolne<'a> =
   match d with
   | Lisc i -> Lisc i
   | KorzenCzarny (i,j,k) -> KorzenCzarny (i, zamienDowolne j, zamienDowolne k)
   | KorzenCzerwony (i,j,k) -> KorzenCzarny (i,zamienDowolne j, zamienDowolne k)

////typ dyskryminacyjny opisujący drzewo czarno-czerwone przenoszący dowolne wartości
type rbdrzewo3<'a> =
    |KorzenCzarny of 'a * rbdrzewo3<'a> * rbdrzewo3<'a>
    |KorzenCzerwony of 'a * rbdrzewo3<'a> * rbdrzewo3<'a>
    |Lisc of 'a
 //funkcja zwracająca drzewo gdzie wszystkie czerwone węzły są zamienione na czarne
let rec zamien (d:rbdrzewo3<'a>) =
    match d with
    | Lisc i -> Lisc i
    | KorzenCzarny (i,j,k) -> KorzenCzarny (i, zamien j, zamien k)
    | KorzenCzerwony (i,j,k) -> KorzenCzarny (i,zamien j, zamien k)

//Zaproponuj typ dyskryminacyjny o nazwie objętość do reprezentacji różnych jednostek objętości
//(np: 2.5 litry, 3 galony, 4 korce, 2 konwie).
type objetosc =
    | Litr of float
    | Galon of float
    | Korc of float
    | Konwa of float

//Napisz funkcję przekształającą objętość zapisaną w postaci Konew na Litr. Jedna konew to 13.75 litrów.
//Pozostałe objętości pozostają bez zmian
let przeksztalcZKonwyNaLitr (d:objetosc) : objetosc =
    match d with
    | Konwa i -> Litr (i * 13.75)
    | other -> other

// Dana jest lista elementów typ objetosc list). Napisz funkcję wyznaczającą łączne sumy z podziałem na
//pojemności podanego typu (litry dodajemy do litrów, galony do galonów itd.).
let sumujObjetosci (obj:objetosc list) =
    let rec sumuj (par:objetosc list) (litry:float) (galony:float) (korce:float) (konwy:float) =
        match par with
             | [] -> [Litr litry]@[Galon galony]@[Korc korce]@[Konwa konwy]
             | (Litr i)::t -> sumuj t (litry+i) galony korce konwy
             | (Galon i)::t -> sumuj t litry (galony+i) korce konwy
             | (Korc i)::t -> sumuj t litry galony (korce+i) konwy
             | (Konwa i)::t -> sumuj t litry galony korce (konwy+i)
    sumuj obj 0.0 0.0 0.0 0.0

//czy dla podanych danych wejściowych znajdź te liczby, które są sześcianem pewnej liczby
let rec czyJestSzescianem (i:float) (liczba:float) : bool =
    if (i*i*i = liczba) then true
                        else if i < liczba then czyJestSzescianem (i+1.0) liczba
                                            else false

let znajdźWszystkieSzesciany (liczby:float list) : float list =
    List.filter (fun x -> czyJestSzescianem 1.0 x) liczby

//deklaracja klasy gruszka, która dziedziczy z owocu
type Owoc (_smak:string,_waga:float) =
    inherit Object()
    let mutable smak = _smak
    let mutable waga = _waga

    member this.Smak
        with get () = smak
        and set (value:string) = smak <- value
    member this.Waga
        with get () = waga

type Gruszka (_smak:string,_waga:float,_odmiana:string) =
    inherit Owoc(_smak,_waga)

    let mutable odmiana = _odmiana

//sekwencja a_i = (i!) / sqrt(i+1)
let rec silnia n =
    match n with
    |0 -> 1
    |1 -> 1
    |_ -> n * silnia (n-1)

let pierwiastek n = System.Math.Pow(n,0.5)

//raczej niewłaściwe, nie może być Infinite
let sekwencja = Seq.initInfinite(fun i -> System.Convert.ToDouble(silnia i) / (pierwiastek (System.Convert.ToDouble(i)+1.0)))
//II sposób
let sekwencja2 x = seq{
            let i = ref 1.0
            let silnia = ref 1.0
            let mianownik = ref 0.0
            while !i <= x do
                silnia := !silnia * !i
                mianownik := System.Math.Sqrt(!i + 1.0)
                yield (!silnia / !mianownik)
                i := !i + 1.0
    }
let sekwencja2_noRef x = seq{
           let mutable i = 1.0
           let mutable silnia = 1.0
           while i <= float(x) do
                yield silnia / System.Math.Sqrt(i+1.0)
                i <- i + 1.0
                silnia <- silnia * i
        }

//Utwórz kwerendę, która zawęzi elementy sekwencji z poprzedniego zadania do tych wartości, które są mniejsze od
let sekwencjaQuery = query {
                for p in sekwencja do
                where (p < 1e-10)
                select p
}

//II sposób - do sekwencja2
let sekwencjaQuery2 = query {
    for p in sekwencja2 10.0 do
    where (p < 1e-10)
    select p
}

//zdefiniuj typ ksiazka (autor, tytul, rok wydania) i napisz funkcje, ktora zwrooci te ksiazki wydane miedzy rokiem
//1970 a 1980
type ksiazka = {
    autor:string;
    tytul:string;
    rokWydania:int}

let znajdzKsiazki (ksiazki:ksiazka list) : ksiazka list =
    List.filter (fun k -> k.rokWydania > 1970 && k.rokWydania < 1980) ksiazki

//4. Zaproponuj typ dyskryminacyjny o nazwie dlugosc do reprezentacji różnych
//jednostek długości (np: 1.5 metra, 3 piędze, 4 łokcie, 2 ćwierci).
type Dlugosc =
    |Metr of float
    |Piedz of int
    |Lokiec of int
    |Cwierc of int

//Napisz funkcję przekształającą długość z zadania 4 zapisaną w postaci Ćwierć na Metr. Jedna ćwierć to 0.1489 metra.
//Pozostałe długości pozostają bez zmian.
let zamienCwierNaMetr (obj:Dlugosc) =
    match obj with
    | Cwierc i -> Metr (0.1489 * System.Convert.ToDouble(i))
    | other -> other

// Napisz funkcję wyznaczającą łączne sumy z podziałem na długości podanego typu
//(metry dodajemy do metrów, piedź do piedzi itd.).
let dodajDlugosci (lista:Dlugosc list) =
    let rec sumujWszystko(lst:Dlugosc list,metry:float,piedzi:int,lokcie:int,cwierci:int ) =
        match lst with
        | [] -> [Metr metry]@[Piedz piedzi]@[Lokiec lokcie]@[Cwierc cwierci]
        | (Metr i)::teil -> sumujWszystko(teil,metry+i,piedzi,lokcie,cwierci)
        | (Piedz i)::teil -> sumujWszystko(teil,metry,piedzi+i,lokcie,cwierci)
        | (Lokiec i)::teil -> sumujWszystko(teil,metry,piedzi,lokcie+i,cwierci)
        | (Cwierc i)::teil -> sumujWszystko(teil,metry,piedzi,lokcie,cwierci+i)
    sumujWszystko(lista,0.0,0,0,0)

//sekwencja dla wyrażenia i! / sqrt(i + 1)
let sekwencjaS x = seq{
                let mutable i = 1
                let mutable licznik = 1
                while i <= x do
                    licznik <- licznik * i
                    yield (float(licznik)/ System.Math.Sqrt(float(i)+1.0))
                    i <- i+1
            }

let sekwencjaS_ref x = seq{
            let i = ref 1.0
            let licznik = ref 1.0
            while !i <= x do
                licznik := !licznik * !i
                yield (!licznik / System.Math.Sqrt(!i+1.0))
                i := !i + 1.0
            }

type mojTypD =
    | Lisc of int
    | Korzen of int * mojTypD

let sprawdz (s:mojTypD option) =
    match s with
    | Some (Lisc i) -> i
    | None -> failwith("Błąd ")


//funkcja sprawdzająca, czy liczba jest 5 potęgą pewnej liczby
let sprawdzCzyJest5Potega (liczba:int) : bool =
    let rec sprawdz i liczba =
        if i * i * i * i * i = liczba then true
        else if i>liczba then false
             else sprawdz (i+1) liczba
    sprawdz 1 liczba

let sprawdzTabliceCzyDo5 (lista:int list) : int list =
    List.filter (fun x -> (sprawdzCzyJest5Potega x)) lista


//sekwencja e do potęgi x
let sekwencjaE (x:int) (k:int) = seq{
        let mutable i = 0.0
        let mutable licznik = 1.0
        let mutable mianownik = 1.0
        let mutable aktualnaSuma = 0.0
        while i <= float(k) do
            aktualnaSuma <- (licznik / mianownik) + aktualnaSuma
            yield aktualnaSuma
            licznik <- licznik * float(x)
            i <- i + 1.0
            mianownik <- mianownik * i
}

//_________________________nowe

//sekwencja sqrt( sin( (x*y)/(p+1) )  ) - 2  // x i y podane
let sekwencjaTrudna x y = seq{
    let mutable i = 1
    while i <= x do
        yield System.Math.Sqrt( System.Math.Sin((float(x)*float(y))/(float(i)+1.0))) - 2.0
        i <- i + 1
}
//kwerenda, która zawezi kwerendę z x = 3 i y = -6 do wartości mniejszych lub równych niż eps
let querySekwencjiTrudnej =
    query{ for p in (sekwencjaTrudna 3 -6) do
           where (p < 1e-10)
           select p
    }
//drzewo binarne zawierające dowolny typ danych. Węzły drzewa mogą być koloru czarnego lub czerwonego.
//Liście tylko czarnego. Zapisz typ dyskryminacyjny dla węzła takiego drzewa
type inneDrzewo<'a> =
    | WezelCzarny1 of ('a * inneDrzewo<'a>)
    | WezelCzerwony1 of ('a * inneDrzewo<'a>)
    | WezelCzarny2 of ('a * inneDrzewo<'a> * inneDrzewo<'a>)
    | WezelCzerwony2 of ('a * inneDrzewo<'a> * inneDrzewo<'a>)
    | LiscCzarny of 'a

//Funkcja przyjmuje drzewo i zwraca to samo drzewo, ale z wszystkimi węzłami koloru czarnego
let rec zamienWszystkoNaCzarno (drzewo:inneDrzewo<'a>) =
    match drzewo with
        |LiscCzarny a -> LiscCzarny a
        |WezelCzarny1 (a,t1) -> WezelCzarny1 (a, zamienWszystkoNaCzarno t1)
        |WezelCzerwony1 (a,t1) -> WezelCzarny1 (a, zamienWszystkoNaCzarno t1)
        |WezelCzarny2 (a,t1,t2) -> WezelCzarny2 (a, zamienWszystkoNaCzarno t1, zamienWszystkoNaCzarno t2)
        |WezelCzerwony2 (a,t1,t2) -> WezelCzarny2 (a, zamienWszystkoNaCzarno t1, zamienWszystkoNaCzarno t2)

[<EntryPoint>]
let main argv =

    //______________________________________________________________________________zagadnienia na egzamin z kia
    //zad 1.1
    let w = 10
    let y = w * 10 ; w + 20 ; w / 3 //pierwsze dwie części są ignorowane, wynik jest typu int (wynika z kontekstu)
    printfn "Wynik zadania nr 1 = %A" y

    //zad 1.2
    let z = printf "ABC " ; List.iter (fun x -> printf "%d, " x) [1 .. 5] //Najpierw wypisze \\\ 'ABC ', a potem iteracyjnie
    printfn ""                                                            // '%i, ', gdzie i idzie od 1 do 5

    //zad 1.3
    let r = 10 |> sprintf "%d"      //tworzy 10 jako łańcuch - "10"
    printfn "Zadanie nr 3, wartość r = %A" r
    let w = Array.create 10 r //Funkcja tworzy tablicę o zadanej długości (10) i inicjalizuje te wszystkie elementy zadaną wartością ("10")
    printfn "Zadanie nr 3, wartość w = %A" w
    let ss = for x in w do (ignore x)  // ignoruje wszystkie wartości w tablicy w
    printfn "Wynik ss = %A" ss


    //zad 2.1
    let listSzukaj (czN:string) (dane:osoba list) : osoba list =
        List.filter (fun x -> x.name.Contains(czN)) dane //pierwszy argument - funkcja anonimowa, drugi - tablica

    let rec listSzukaj2 (czN:string) (dane:osoba list) : osoba list =
        match dane with
           |[] -> []
           |h::t -> if h.name.EndsWith(czN) then h::(listSzukaj2 czN t)
                                           else (listSzukaj2 czN t)

    //zad 2.2
    let sortujPoNazwisku (dane:osoba list) : osoba list =
        List.sortBy (fun x -> x.name) dane //pierwszy argument - funkcja anonimowa, po czym ma być sortowane, drugi atguemnt - dane

    //zad 3.1
    //Zaproponuj typ dyskryminacyjny opisujący drzewo
    //przed main'em

    //zad 4.1
    let wedata = [1 ; 3; 5; 9; 12; 16; 20; 25; 30; 36; 48]
    let wy = List.filter (
            let rec isKw i v = if i / 2 <= v then (i*i = v || isKw (i+1) v)
                               else false
            fun x -> isKw 0 x
        )

    printfn "Wynik zadania 4.1 = %A" (wy wedata)

    //zad 5.1 zadanie z klasami
    //nad main'tem klasy pociąg i ekspres

    //zad 6.1
    let mdata (dw:System.DayOfWeek) (start:System.DateTime) =
        seq {
            let mutable chkdate = start
            while true do
                if chkdate.DayOfWeek = dw
                    then yield chkdate
                         chkdate <- new System.DateTime(chkdate.Year + 1, start.Month, start.Day)
            }

    //zad 7.1
    let pondz = mdata System.DayOfWeek.Monday (new System.DateTime(2020,2,2))
    let leapp = query { for p in pondz do
                        where ((p.Year % 4 = 0) && (p.Year % 100 <> 0 || p.Year % 400 = 0))
                        select p
                }
    //______________________________________________________________________________dodatkowe z powtórkowego wykładu
    //różniczkowanie listy float
    let rec aplikujRozniczke st l =
        match l with
        | [] -> []
        | h::t -> (st*h)::(aplikujRozniczke (st+1.0) t)

    let rozniczkuj (w:float list) =
        match w with
        | [] -> []
        | [h] -> []
        | h::t -> aplikujRozniczke 1.0 t

    printfn "Wynik różniczki: %A" <| rozniczkuj [-5.0;4.0;1.0]

    //yield - yield przenosi kontrolę programu pomiędzy metodą wywołującą a kolekcją
    printfn "%A" <| [for i in 1..10 do yield i*i]


    //_____________________________________________________________________________________zadania z pliku
    //zad ile wyniesie wartość zmiennej
    let c = (fun a b -> let d = a 10 in d - 4 * b ) (fun c -> c + c) 5
    let x = 5; c - 6
    printfn "Wartość zmiennej c oraz x = %i %i" c x

    let a = (fun b c -> let d = b 4 in d - 2 * c) (fun a -> a * a ) 5
    //pod b nie jest przekazywana wartość, tylko funkcja anonimowa a*a, dlatego d = (a*a) 4 -- d = 4*4 = 16
    printfn "Wartość zmiennej a = %i" a

    //zad co wypisze program
    let z = 1
    List.iter(fun x -> z = z * x; () ) [1..5]
    printf "Program wypisze: %d \n" z //z jest nie jest typu mutable i nie można zmienić wartości

    //znajdz w liście osoby, których wiek <20,30> i name kończy się na ski
    let szukajOsob (lista:osoba list):osoba list =
        List.filter (fun x -> x.wiek > 20 && x.wiek < 30 && x.name.EndsWith("ski")) lista

    //ile wyniesie wartość zmiennej
    let c = (fun a b -> let d = a * b in d - 4 * a ) 5 1
    let x = c - 6
              - 5
    printf "Program wypisze: %d oraz %d \n" c x

    let z = ref 0 //z jest wskaźnikiem
    Seq.iter( fun x -> z := !z + x) [1..5] //! weź wartość spod adresu
    printfn "Porgram to wykonaniu sekwencji: %A \n" !z

    let cb = (fun a b -> let d = a * b in d - 4 * a ) 1 5
    let xb = cb - 6
                 + 5
    printf "Program wypisze: %d dla cb oraz %d dla xb\n" cb xb


    printf "Sekwencja: %A\n" (seqq1_ref 5)
    printf "Sekwencja: %A\n" (seqq1 5)

    printf "sekwencjaS: %A\n" (sekwencjaS 3)
    printf "sekwencjaS_ref: %A\n" (sekwencjaS_ref 3.0)

    printfn "Sprawdz czy jest do 5 potęgi %A" (sprawdzTabliceCzyDo5 [1; 5; 32; 64 ; 243])

    printfn "SekwencjaE dla x = %i,   %A" 1 (sekwencjaE 1 100)

    //kończę na stronie 12

    //_______________________________________________________________________inne (fold)
    let daneWe =   [3;  4; 6; 8; 10; 2; 1; 5; 9; 7; 8; 7];
    let zlicz lista = List.fold (fun stan el -> stan + 1) 0 lista
    printfn "Fold zliczająca elementy: %d" (zlicz daneWe)


    //__________________________________________________________________nowe
    let y = 5
    let b = (fun c -> c <| 8) (fun d e -> if e then d/2 else -d*2)
    let x = if (let y =3 in y = y + 1) then b (y = y / 4) else b (y = y + 2)
    printfn"Wyniki dla powyższego: y = %A, x = %x\n" y x

    //co wypisze program
    printfn "Program wypisze: "
    List.iter (fun r -> if r = r*3 then printfn "%d" r) [9..-1..-8]
    let a p = (0,p)
    let y = List.map (fun x -> printfn "%A" (a x); a) [2]
    printfn "Zacznij\n"

    let yy = (fun a b -> let d = b -4 in d  - (b +3) * a) 5 (fun c -> c + c / 2)
    let x = if ( let yy = 0 in yy = yy * +3) then (yy = yy / 2)  else  not (yy = yy + 2)
    printfn"yy = %A  ,  x = %A" yy x

    let y = (fun a b -> let d = a +2 in (a -3)*b + 2) (fun c -> c / 3 + c) 7
    let x = if (let y = 0 in y = y / -1) then not (y = y *2) else y = y - 4

    printfn"y = %A  ,  x = %A\n" y x


    let zzz = 1
    let mmm = Seq.map (fun x -> printfn "%d" <| x + 1; zzz = zzz * x; () ) {2 .. 4}
    printfn "%A" (zzz,mmm)

    let proba = (fun c -> c <| 8) ((fun w -> w <| 2) (fun a b d -> 100 * a + 10 *  b +  d) 5)

    printfn "%A" (proba)

    let x = 5
            -6
    0 // return an integer exit code