f_hw_1

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

open System
open System.Collections.Generic
// 1)
let IsEven a =
    a%2=0



// 2)
let FindEvenNumbers a =
    let evenOnlyList = List.filter(IsEven) a
    evenOnlyList


// 3)
let first100EvenNumberSum =
    let nums = FindEvenNumbers [1..200]
    List.sum nums

// 4)
let IsOdd a =
    a%2=1

let FindOddNumbers a =
    let oddOnlyList = List.filter(IsOdd) a
    oddOnlyList

let differenceOfSquares a =
    let odds = FindOddNumbers a
    let evens = FindEvenNumbers a
    let oddSqure = List.map(fun x -> x*x) odds
    let evenSquare = List.map(fun x -> x*x) evens
    let diff = List.sum(oddSqure) - List.sum(evenSquare)
    printfn "%d" diff

 // 5)
let everyOtherChar a:List<char>=
    let list = Seq.toList a
    let ret = new List<char>()
    for i in [0..2..list.Length] do
        ret.Add(list.[i])
    ret


// 6)
let delItem (a : List<int>) (b:int) =
    a.Remove(b)
    ()

let FindAllPrimesUpTo n=
    let nums = [2..n]
    let numbers = new List<int>()
    List.iter ( fun x -> numbers.Add(x)) nums
    let primes = new List<int>()
    while numbers.Count > 0 do
        let prime = numbers.[0]
        primes.Add prime
        numbers.Remove(prime)
        let nums = [prime..prime..n]
        List.iter(fun x-> delItem numbers x) nums
    List.ofSeq(primes);


// 7)
let SumPrimeDifferencesUpTo n =
    let primes = FindAllPrimesUpTo 1000
    let h = primes.[..primes.Length-2]
    let t = primes.Tail
    let pairs = List.zip h t
    let ret = List.sumBy(fun x -> snd x - fst x) pairs
    ret

// 8)
let FindNthPrime n=
    let max = 10000
    let nums = [2..max]
    let numbers = new List<int>()
    List.iter ( fun x -> numbers.Add(x)) nums
    let mutable prime = 0;
    for i in [1..n] do
        let p = numbers.[0]
        let _ = numbers.Remove(p)
        let nums = [p..p..max]
        List.iter(fun x-> delItem numbers x) nums
        prime <- p
    prime

// 9)
type Gender =
    | Male
    | Female
type Person =
    {
        FirstName: string
        LastName: string
        Age: int
        Gender: Gender
    }

let p1 = {FirstName="Fname1";LastName = "Lastname1"; Age = 10; Gender=Male}
let p2 = {FirstName="Fname2";LastName = "Lastname2"; Age = 20; Gender=Female}
let p3 = {FirstName="Fname3";LastName = "Lastname3"; Age = 30; Gender=Male}
let p4 = {FirstName="Fname4";LastName = "Lastname4"; Age = 50; Gender=Male}
let p5 = {FirstName="Fname5";LastName = "Lastname5"; Age = 40; Gender=Male}
let p6 = {FirstName="Fname6";LastName = "Lastname6"; Age = 30; Gender=Male}

let people = [p1;p2;p3;p4;p5;p6]


let SumOfAllPeoplesAge p=
    List.sumBy(fun x -> x.Age) p

// 10)
let FindPeopleAbove p n=
    List.filter(fun x -> x.Age > n) p

// 11)
let FindAverageAge p =
    List.averageBy(fun x->float x.Age) people

// 12)
let NameInterchange p =
    List.map  (fun x -> {x with
        LastName = x.FirstName
        FirstName = x.LastName}) p;;

// 13)
let ChangeName(p,oldName, newName)=
    match oldName with
    | last when last=p.LastName -> {p with LastName = newName}
    | _ -> p

let nl = [("Lastname1", "Lastname1mod"); ("Lastname3", "Lmod3")]
let rec ApplyMarrige(namelist:(string * string) list ,people:Person list) =
    if namelist.Length = 0 then
        people
    else
        let n = List.head namelist
        let f = fun p -> (ChangeName(p, fst(n), snd(n)))
        let p = List.map(f) people
        ApplyMarrige(List.tail(namelist), p)

// 14)
let ChangeNameFemaleOnly(p,oldName, newName)=
    match oldName with
    | last when last=p.LastName && p.Gender = Female-> {p with LastName = newName}
    | _ -> p

let rec ApplyMarrigeFemaleOnly(namelist:(string * string) list ,people:Person list) =
    if namelist.Length = 0 then
        people
    else
        let n = List.head namelist
        let f = fun p -> (ChangeNameFemaleOnly(p, fst(n), snd(n)))
        let p = List.map(f) people
        ApplyMarrige(List.tail(namelist), p)

// 15)

type Employee =
    | Developer of Person
    | TeamLeader of Person * Person list
    | Manager of Person * Person list list

let emp1 = Developer(p1);
let emp2 = Developer(p2);
let tl1 = TeamLeader(p3, [p1; p2])
let tl2 = TeamLeader(p6, [p5;p4;p3])
let man1 = Manager(p1, [[p1];[p2;p3;p4]])

let empList = [emp1; emp2; tl1;tl2; man1]

let FindPersonWithLargestTeam  (empList: Employee list)=
    let f = function
        |TeamLeader (t, l)  -> Some (t, l.Length)
        |_ -> None
    let teamLeaderswithCount = List.choose(f) empList
    let tmax = List.maxBy(fun x-> snd(x)) teamLeaderswithCount
    fst(tmax)

// 16)
let FindLeadersWithOlderTeamMembers (empList: Employee list)=
    let oldest (p: Person list)=
        let max = List.maxBy(fun x-> x.Age) p
        max.Age
    let f = function
        |TeamLeader (t, l)  -> Some (t, l)
        |_ -> None
    let teamLeaders = List.choose(f) empList
    let ret = List.filter(fun x -> (fst(x).Age < oldest(snd(x)))) teamLeaders
    ret

// 17)
let FindLeadersWithOlderTeamMembersThan (age:int) (empList: Employee list)=
    let oldest (p: Person list)=
        let max = List.maxBy(fun x-> x.Age) p
        max.Age
    let f = function
        |TeamLeader (t, l)  -> Some (t, l)
        |_ -> None
    let teamLeaders = List.choose(f) empList
    let ret = List.filter(fun x -> (age < oldest(snd(x)))) teamLeaders
    ret

// 18)


 // 19)
 //Non tail recursion can cause stack overflow.
 //Tail recursion is easily optimized by the complier.


//extra credit 1)

type Expr =
    | Var of string
    | Number of float
    | Sum of Expr * Expr
    | Diff of Expr * Expr
    | Mult of Expr * Expr
    | Div of Expr * Expr

let x = Var("x")
let y = Var("y")
let n = Number(2.1)
let d1 = Diff(n, x)
let d2 = Diff(d1, y)
let m3 = Mult(d2, n)

// 1.1)
let rec Eval2 (env:Map<string, float>, e:Expr) =
    match e with
    | Sum (Number x, Number y) -> Number(x+y)
    | Div (Number x, Number y) -> Number(x/y)
    | Diff (Number x, Number y) -> Number(x-y)
    | Mult (Number x, Number y) -> Number(x*y)
    | Sum (x, Number y) -> Sum(Eval2(env, x), Number y)
    | Div (x, Number y) -> Div(Eval2(env, x), Number y)
    | Diff (x, Number y) -> Diff(Eval2(env, x), Number y)
    | Mult (x, Number y) -> Mult(Eval2(env, x), Number y)
    | Sum (x, y) -> Sum(Eval2(env, x), Eval2(env, y))
    | Div (x, y) -> Div(Eval2(env, x), Eval2(env, y))
    | Diff (x, y) -> Diff(Eval2(env, x), Eval2(env, y))
    | Mult (x, y) -> Mult(Eval2(env, x), Eval2(env, y))
    | Var x -> Number(env.[x])
    | _ -> e

let rec Eval (env:Map<string, float>, e:Expr) =
    let d = Eval2(env, e)
    match e with
    | Number x -> x
    | _ -> Eval(env, e)

// 1.2)
let rec Subst (s:(string * float) list, e:Expr) =
    let m = Map.ofList(s);
    match e with
    | Var x -> Number(m.[x])
    | Sum(x, y) -> Sum(Subst(s, x), Subst(s, y))
    | Diff(x, y) -> Diff(Subst(s, x), Subst(s, y))
    | Mult(x, y) -> Mult(Subst(s, x), Subst(s, y))
    | Div(x, y) -> Div(Subst(s, x), Subst(s, y))
    | _ -> e
// 1.3)
let rec PrettyPrint e =
    match e with
    | Number x -> x.ToString()
    | Var x -> x
    | Sum(x, y) -> PrettyPrint(x)+"+"+PrettyPrint(y)
    | Diff(x, y) -> PrettyPrint(x)+"-"+PrettyPrint(y)
    | Mult(x, Number y) -> "("+PrettyPrint(x)+")"+"*"+ y.ToString()
    | Mult(x, Var y) -> "("+PrettyPrint(x)+")"+"*"+ y
    | Mult(Number x, y) -> x.ToString()+"*("+PrettyPrint(y)+")"
    | Mult(Var x, y) -> x+"*("+PrettyPrint(y)+")"
    | Mult(x, y) -> "("+PrettyPrint(x)+")"+"*"+"("+PrettyPrint(y)+")"
    | Div(x, Number y) -> "("+PrettyPrint(x)+")"+"/"+y.ToString();
    | Div(x, Var y) -> "("+PrettyPrint(x)+")"+"/"+y;
    | Div(Number x, y) -> x.ToString()+"/("+PrettyPrint(y)+")"
    | Div(Var x, y) -> x+"/("+PrettyPrint(y)+")"
    | Div(x, y) -> "("+PrettyPrint(x)+")"+"/"+"("+PrettyPrint(y)+")"
    | _-> ""

let env =
   [ "x", 1.2;
      "y", 3.6; ]
   |> Map.ofList;;

// extra credit 2)


[<EntryPoint>]
let main argv =

    0 // return an integer exit code