a1

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 oddsSqure = List.map(fun x -> x*x) odds
   let evenSquare = List.map(fun x -> x*x) evens
   let diff = List.sum(oddsSqure) - 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)

//deletes an iten from System.Collections.Generic.List and
//returns unit, so it can be used inside an List.iter
let delItem (a : List<int>) (b:int) =
   a.Remove(b)
   ()

let FindAllPrimesUpTo n=
   let nums = [2..n]
   let numbers = new List<int>() //conatins the numbers of the sieve
   List.iter ( fun x -> numbers.Add(x)) nums
   let primes = new List<int>()
   while numbers.Count > 0 do
       let prime = numbers.[0] //the first number of the sieve always will be a prime
       primes.Add prime
       numbers.Remove(prime) //removes the first number of the list
       let multiples = [prime..prime..n] //generates multiples of the last found prime number
       List.iter(fun x-> delItem numbers x) multiples //removes the multiples from the sieve list
   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 //generates a list of tuples neighboring primes
   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 //same alforthm as in task 6, the only difference is cycle
       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)

//changes the lastname of the person if oldname equal with person's latsname
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 //stops the recursion when no more namechange to apply, returns with people list
        people
    else
        let n = List.head namelist //get the first of the namlist
        let f = fun p -> (ChangeName(p, fst(n), snd(n)))
        let p = List.map(f) people //apply marrige to the list only with the first name
        ApplyMarrige(List.tail(namelist), p) //recursively call this function with to new people list and the reduced namelist

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

//same alogrithm as in task 13, the only difference is in ChangeName
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
    //makes a list with teamleaders only
    //the list contains a tuple of person and the count of people they manage
    let teamLeaderswithCount = List.choose(f) empList
    let tmax = List.maxBy(fun x-> snd(x)) teamLeaderswithCount //Find the biggest count by the secound element of tuple
    fst(tmax)

// 16)
let FindLeadersWithOlderTeamMembers (empList: Employee list)=
    //find oldest person in a person lint
    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)
        |Manager (t, l) -> Some (t, List.concat l)
        |_ -> None
    let teamLeadersAndManagers = List.choose(f) empList //select teamleaders and mangeers from  emplist
    let ret = List.filter(fun x -> (fst(x).Age < oldest(snd(x)))) teamLeadersAndManagers //selects those who have older team members
    ret

// 17)
//same alogrithm as in task 16, the only difference is in the filter condition
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)
        |Manager (t, l) -> Some (t, List.concat 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

//cal Eval2 until its returns with a single Number
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); //varibles converted to a map so that the corresponding value can be easily found
    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)


//stack and queue is represented by a list in my implementation
//the difference in the two types:
//   -in the case of a stack, the new item is placed at the start of the list
//   -in the case of a queue, the new item is placed at the end of the list
type Stack2<'a>=
    val mutable s: 'a list

    new () as self =
        self.s <- List.empty
        Stack2()

    member self.Clear =
        self.s <- List.Empty
        ()

    member self.Peek =
        List.head self.s

    member self.Pop =
        let ret = List.head self.s
        self.s <- List.tail self.s
        ret

    member self.Push  o=
        self.s <- o :: self.s
        ()

    member self.ToArray =
        List.toArray self.s

type Queue2<'a>=
    val mutable q: 'a list

    new() as self=
        self.q <- List.empty
        Queue2()

    member self.Clear =
        self.q <- List.Empty
        ()

    member self.Enqueue o=
        self.q <-  List.append  self.q o

    member self.Dequeue =
        let ret = List.head self.q
        self.q <- List.tail self.q
        ret

    member self.Peek =
        List.head self.q

    member self.ToArray =
        List.toArray self.q

    member self.Count =
        List.length