exception UJEMNY_ANGUMENT

//f1
let rec silnia(n:int) : int =
    if n < 0 then raise UJEMNY_ANGUMENT
    elif n < 2 then 1
    else n * silnia(n-1)

let rec silnia2 n =
    match n with
    | 0 -> 1
    | 1 -> 1
    | _ -> n * silnia( n-1)

//f2
let rec potega(a:int, b:int) : int =
    if b < 0 then raise UJEMNY_ANGUMENT
    elif b = 0 then 1
    else a * potega(a, b-1)

let rec potega2 ( a, b ) =
    match b with
    | 0 -> 1
    | _ -> a * potega2(a, b-1)

//f3
let rec fib(n:int) : int =
    if n < 0 then raise UJEMNY_ANGUMENT
    elif n = 0 then 0
    elif n = 1 then 1
    else fib(n-1) + fib(n-2)

let rec fib2 n =
    match n with
    | 0 -> 1
    | 1 -> 1
    | _ -> fib2( n-1) + fib2 (n-2)

//f4
let rec mnozenie(m:int, n: int) : int =
    if m < 0 || n < 0 then raise UJEMNY_ANGUMENT
    elif n = 0 then 0
    elif n = 1 then m
    else m + mnozenie(m, n-1)

let rec mnozenie2 ( m, n) =
    match n with
    | 0 -> m*0
    | 1 -> m*1
    | _ -> m + mnozenie2 (m,n-1)

//f5
let niepodzielny(d:int, n: int) : bool =
    d % n <> 0

let niepodzielny2 (d,n) =
    let nn = d % n
    match nn with
    | 0 -> true
    | _ -> false

//f6
let liczwyst(lan:string, zn:char) : int =
    let ilosc = ref(0)
    for i = 0 to lan.Length - 1 do
        if lan.[i] = zn then incr(ilosc)
    ilosc.Value

let liczwyst2 (str: string , znak: char ) =
    let dl = String.length str
    let ilosc = ref 0
    for i = 0 to  dl - 1 do
        if str.[i] = znak then incr(ilosc)
    ilosc.Value

//f7
let liczwystod(lan:string, od:int, zn:char) : int =
    let ilosc = ref(0)
    for i = od to lan.Length - 1 do
        if lan.[i] = zn then incr(ilosc)
    ilosc.Value

let liczWystOd2 (str: string ,ktory:int, znak: char ) =
    let dl = String.length str
    let ilosc = ref 0
    for i = ktory to  dl - 1 do
        if str.[i] = znak then incr(ilosc)
    ilosc.Value

//f8
let pow(lan:string, il:int) : string =
    String.replicate il lan

let pow2 (str: string, n: int) =
    match n with
    | 0 -> "error"
    | 1 -> str
    | _ -> String.replicate(n) str

///////////////////////////////////////////////
exception DzieleniePrzezZero

//k1
let rec NWD (m:int, n:int) : int =
    if n = 0 then abs(m)
    else NWD(n, m%n)

let rec NWD2 (m,n) =
    match n with
    | 0 -> abs(m)
    | _ -> NWD2(n, m%n)

//k2
let (++) (a,b) (c,d) =
    if b*d = 0 then raise DzieleniePrzezZero
    else a*d + b*c , b*d

let ( -- ) (a,b)(c,d)=
    if b*d = 0 then raise DzieleniePrzezZero
    else  a*d - b*c, b*d

let ( ** ) (a,b)(c,d)=
    if b*d = 0 then raise DzieleniePrzezZero
    else  a*c b*d

let ( /./ ) (a,b)(c,d)=
    if b*d = 0 then raise DzieleniePrzezZero
    else  a*d,b*c

//k3
let skróc (a:int ,b: int) =
    let znak = if a*b < 0 then -1 else  1
    let ll = abs a
    let mm = abs b
    let dzielnik = NWD(ll, mm)
    let licznik = ll / dzielnik
    let mianownik = mm / dzielnik
    znak * licznik , mianownik

//k4 !!!
let naString(a , b) =
    let znak = if a*b < 0 then "-" else  ""
    let licz, mian = skróc(abs(a),abs(b))
    let calk = licz / mian
    let licznik = licz - calk*mian
    let calkowita = if calk > 0 then calk.ToString() else ""
    let ulamek = if licznik > 0 then " " + licznik.ToString() + "/" + mian.ToString() else ""
    znak + calkowita + ulamek

//k5
let (+++) (a,b)(c,d) =
    let znak = if (b+d) < 0 then " - " else " + "
    (a+c).ToString() + znak + abs(b+d).ToString() + "i"

let (---) (a,b)(c,d) =
    let znak = if (b-d) < 0 then " - " else " + "
    (a-c).ToString() + znak + abs(b-d).ToString() + "i"

let ( *** ) (a,b)(c,d) =
    let znak = if (a*d + b*c) < 0 then " - " else " + "
    (a*d - b*c).ToString() + znak + abs(a*d + b*c).ToString() + "i"

let ( /././ ) (a,b)(c,d) =
    if c*c - d*d = 0 then raise DzieleniePrzezZero
    let znak = if (a*d + b*c) < 0 && c*c - d*d > 0 || (a*d + b*c) > 0 && c*c - d*d < 0 then " - " else " + "
    znak + (a,b) *** (c, -d) + "/" + (c*c + d*d).ToString()

//k6
let rec pierwsza' (n , k) =
    let xx = n % k
    match k with
    | 1 -> true
    | _ -> match xx with
            | 0 -> false
            | _ -> pierwsza'(n,k-1)

let pierwsza n =
    pierwsza'(n,n-1)

//k7
let mnul (liczba : int, licz : int, mian: int) =
    liczba * licz , mian

let dzielul (liczba : int, licz : int, mian: int) =
    licz, mian * liczba

let pierul (licz : float, mian: float) =
    sqrt(licz),sqrt (mian)

let odrul (licz : int, mian: int) =
    mian, licz

//k8
type Student = {imie: string; nazwisko: string; indeks: int}

let studenci = [{imie = "Jan"; nazwisko = "Kowalski"; indeks = 123123};
                {imie = "Marcin"; nazwisko = "Kowalski"; indeks = 123555}]

let SprawdzStudenty (stud1:Student list) =
    let dl1 = stud1.Length
    let ilosc = ref(0)

    for i = 0 to dl1 - 1 do
        for k = 0 to dl1 - 1 do
            if stud1.[i].nazwisko = stud1.[k].nazwisko then incr(ilosc)

    if ilosc.Value > dl1 then true else false

/////////////////////////////////////////////////

//l1 - zwraca int a nie int option !!!
let listamin (lst: int list) : int =
    let dl = lst.Length
    let mutable min = lst.[0]
    for i=1 to dl-1 do
        if lst.[i] < min then min <- lst.[i]
    min

//l2
(*let listalen (lst: int list) =
    let len = ref(0)
    try
        while true do
            lst.[len.Value]
            incr(len)
    with
        | :? System.ArgumentException -> len.Value
*)
let dllist lista =
    List.length lista

//l3
let krotnosc (x:int , lista: int list) =
    let ilosc = ref(0)
    List.iter(fun a -> if a = x then incr(ilosc)) lista
    ilosc.Value

//l4
let ntyel (kt, lista) =
    let dl = List.length lista
    if kt < dl then
        lista.[kt]
    else
        0

//l5
let czyujemne lista =
    let ileuj = ref(0)
    List.iter(fun x -> if x < 0 then incr(ileuj)) lista
    if ileuj.Value > 0 then true else false

//l6
let minmax lista =
    List.min lista , List.max lista

//l7
let sumalisty(lst: int list) =
    List.sum(List.map(fun x->x) lst)

//l8
let sumList2 lst =
    List.fold (fun acc elem -> acc + elem) 0 lst

//l9
let mullist lst =
    List.fold (fun mul elem -> mul * elem) 1 lst

//l10
let mullist2 lst =
    List.fold (fun mul elem -> mul * elem) 1 lst
    |> float

//l11
let wystlan (lst : string list, lan: string) =
    let ind = ref 0
    try
        while (lst.[ind.Value] <> lan && ind.Value < lst.Length) do
            incr ind
        Some ind.Value
    with
        | :? System.ArgumentException -> printfn "Poza indeksem, brak wystapien" ; None


//l12
let wystlanLiczy (lst : string list, lan: string) =
    let wyst = ref 0
    for i = 0 to lst.Length - 1 do
        if lst.[i] = lan then
            incr wyst
    wyst.Value

//l13
let inttostr (lst : int list) =
    List.map(fun x -> x.ToString()) lst


[<EntryPoint>]
let main argv =
    //let w = silnia 3
    //let w = potega(2, 4)
    //let w = fib(10)
    //let w = mnozenie(4,5)
    //let w = niepodzielny(4,2)
    //let w = liczwyst("abca0", 'b')
    //let w = liczwystod("abca0", 1, 'a')
    //let w = pow("abca0", 5)
    //let w = System.Convert.ToInt32(wystlan(ls, "dd"))
    let ll = [1;2;3;-1;5]
    let ls = ["aa"; "bb";"bb"]
    //let w = wystlanLiczy(ls, "cc")
    let w = inttostr(ll)
    printfn "%A " w
    System.Console.ReadKey()
    0 // return an integer exit code