module some


let elem n = (List.exists (fun x -> x = n))


elem 66 [1..5]

[<EntryPoint>]
let main argv =
    printfn "%A" argv
    0 // return an integer exit code



let abs n = if n >= 0 then n else -n


let gcd a b =
    let a' = abs a
    let b' = abs b
    let rec gcd' = function
        |(a, b) when a = 0 -> b
        |(a, b) when b = 0 -> a
        |(a, b) when a < b -> gcd' (b, a)
        |(a, b) -> gcd'(a - b, b)
    gcd' (a', b')

gcd -15 12


let replicate n smth =
    let rec replicate' acc = function
        |0 -> acc
        |n -> replicate' (smth::acc) (n - 1)
    replicate' [] n

let zip x y =
    let xlen = List.length x
    let ylen = List.length y
    let n = min xlen ylen
    let rec zip' acc x' y' = function
        |n when n = 1 -> (List.head x', List.head y')::acc
        |n -> zip' (List.head x', List.head y')::acc (List.tail xs') (List.tail ys') (n - 1)
    if n < 1 then
        []
    else
        zip' [] x y n

let append x y =
    let rec append' = function
        |([], y) -> y
        |(x, []) -> x
        |(x::xs, y) -> append' (xs, x::y)


let rev<'a> =
    let rec rev' acc = function
        |[] -> acc
        |x::xs -> rev' (x::acc) xs
    rev' []
rev [1; 2; 3; 4; 5]

replicate 5 "ого"


let explode (s:string) = [for c in s -> c]

let rec implode = function
    |[] -> ""
    |(x::xs) -> x.ToString() + (implode xs)

let rec subs ch1 ch2 s =
    let rec delete' = function
        |[] -> []
        |(x::cs) -> if x = ch1 then ch2::(delete' cs) else x::(delete' cs)
    implode (delete' (explode s))


delete '1' ['1'; '2'; '3'; '1'; '2']

delete 'a' "bacabadaba"

subs 'a' 'b' "bacabadaba"

let balance str =
    let rec bal acc = function
        |[] -> (acc = 0)
        |'('::xs -> bal (acc + 1) xs
        |')'::xs when acc = 0 -> false
        |')'::xs -> bal (acc - 1) xs
        |x::xs -> bal acc xs
    bal 0 str

balance (explode ")(")


if x > 0 then 1 else 0

let reverse list =
    let rec reverse' curr = function
        |[] -> curr
        |x::xs -> (reverse' (x::curr) xs)
    reverse' [] list

let rec reverseAll acc = function
    |[] -> acc
    |x::xs -> reverseAll (reverse(x)::acc) xs

reverseAll [] [[1; 2]; [3; 4]; [5; 6; 7]]


let firstElem x<a'> =
    let rec fE acc = function
        |[] -> 1/0
        |y::xs -> if y = x then acc else (fE (acc + 1) xs)
    fE 0

let set list =
    let cute = List.sort list

    let rec del prev flag = function
        |[] -> []
        |x::xs -> if x = prev && flag != true then (del prev false xs) else x::(del x false xs)
    del 0 true cute

firstElem 5 [1; 2; 3; 4; 5; 6; 5; 7]