using System;

using System.Collections.Generic;

using System.Linq;

​

​

// Do not modify this code

Console.WriteLine(

$@"

Adder Tests:

Linq            : {Assert.Equal(new LinqAdder(new[] { 10, 20, 40, 12, 82, 9, 5 }).Sum(), 178)}

Loop            : {Assert.Equal(new LoopAdder(new[] { 10, 20, 40, 12, 82, 9, 5 }).Sum(), 178)}

Recursive       : {Assert.Equal(new RecursiveAdder(new[] { 10, 20, 40, 12, 82, 9, 5 }).Sum(), 178)}

Recursive (1L)  : {Assert.Equal(new RecursiveOneLinerAdder(10, 20, 40, 12, 82, 9, 5).Sum(), 178)}

​

Booleans:

E(T, F, F)      : {Assert.Equal(Booleans.Expression1(true, false, false), Booleans.Expression2(true, false, false))}

E(F, T, F)      : {Assert.Equal(Booleans.Expression1(false, true, false), Booleans.Expression2(false, true, false))}

E(F, F, T)      : {Assert.Equal(Booleans.Expression1(false, false, true), Booleans.Expression2(false, false, true))}

X(T, T)         : {Assert.Equal(Booleans.xor(true, true), false)}

X(T, F)         : {Assert.Equal(Booleans.xor(true, false), true)}

​

​

FizzBuzz:

FizzBuzz(2)     : {Assert.Equal(FizzBuzz.Evaluate(2), "2")}

FizzBuzz(3)     : {Assert.Equal(FizzBuzz.Evaluate(3), "fizz")}

FizzBuzz(5)     : {Assert.Equal(FizzBuzz.Evaluate(5), "buzz")}

FizzBuzz(6)     : {Assert.Equal(FizzBuzz.Evaluate(6), "fizz")}

FizzBuzz(11)    : {Assert.Equal(FizzBuzz.Evaluate(11), "11")}

FizzBuzz(15)    : {Assert.Equal(FizzBuzz.Evaluate(15), "fizzbuzz")}

FizzBuzz(30)    : {Assert.Equal(FizzBuzz.Evaluate(30), "fizzbuzz")}

FizzBuzz(31)    : {Assert.Equal(FizzBuzz.Evaluate(31), "31")}

FizzBuzz(35)    : {Assert.Equal(FizzBuzz.Evaluate(35), "buzz")}

​

");

​

#if FUNCTIONAL_TESTS

Console.WriteLine($@"

Functional: 

add2(4)         : {Assert.Equal(FunctionalExtensions.Examples.add2(4), 6)}

add2(-1)        : {Assert.Equal(FunctionalExtensions.Examples.add2(-1), 1)}

mul3(3)         : {Assert.Equal(FunctionalExtensions.Examples.mul3(3), 9)}

tripletwo(4)    : {Assert.Equal(FunctionalExtensions.Examples.tripletwo(4), 18)}

curryadd(4)(3)  : {Assert.Equal(FunctionalExtensions.Examples.curryadd(4)(3), 7)}

");

#endif

static class Assert

{

    public static string Equal<T>(T a, T b) => $"{a} == {b} => " + (a.Equals(b) ? "PASS" : "TEST FAILED");

}

namespace FunctionalExtensions

{

    public static class Examples 

    {

        public static readonly Func<int, int, int> add = (int a, int b) => a + b;

        public static readonly Func<int, int, int, int> tot = (int a, int b, int c) => a + b + c;

        public static readonly Func<int, int, int> mul = (int a, int b) => a * b;

​

        public static readonly Func<int, int> add2 = add.PartialApply(2);

        public static readonly Func<int, int> mul3 = mul.PartialApply(3);

        public static readonly Func<int, int> tripletwo = add2.Compose(mul3);

        public static readonly Func<int, Func<int, int>> curryadd = add.Curry();

        public static void RunTest() {

        }

    }

}

​

// you can make any modifications you like to the code below

​

abstract class Adder 

{

    protected readonly IEnumerable<int> Values;

​

    public Adder(int[] values)

    {

        this.Values = values;

    }

​

    public abstract int Sum();

}

​

​

class LinqAdder: Adder

{

    public LinqAdder(int[] values):  base(values) { }

    public override int Sum() => Values.Sum();//throw new NotImplementedException();

}

​

class LoopAdder: Adder

{

    public LoopAdder(int[] values) : base(values) { }

    public override int Sum()

    {

        int sum = 0;

        foreach(int value in Values)

        {

            sum += value;

        }

        //throw new NotImplementedException();

        return sum;

    }

}

​

class RecursiveAdder: Adder

{

    public RecursiveAdder(int[] values) : base(values) { }

    protected virtual int RecursiveSum(IEnumerable<int> values)

    {

        //throw new NotImplementedException();

        if(values.Count() == 1)

        {

            return values.First();

        }

        return values.First() + RecursiveSum(values.Skip(1));

    }

​

    public override int Sum() => RecursiveSum(Values);

}

​

class RecursiveOneLinerAdder : RecursiveAdder

{

    public RecursiveOneLinerAdder(int[] values) : base(values) { }

    protected override int RecursiveSum(IEnumerable<int> values) => (values.Count() == 1) ? values.First() : values.First() + RecursiveSum(values.Skip(1));

}

​

​

static class Booleans

{

    static bool Expression1(bool A, bool B, bool C) => A && (!B || C);

    /// You must implement the same function as Expression1 without using the '||' operator

    static bool Expression2(bool A, bool B, bool C) => A && B && !C;

    /// You must implement a logical xor with only the '&&', '||", and '!' operators

    static bool xor(bool a, bool b) => !(a && b) &&  (a || b) ;

}

​

static class FizzBuzz

{

    /// <summary>

    /// returns the 'fizzbuzz' of a number:

    /// if the number is divisible by 3, the answer is 'fizz'

    /// if the number is divisible by 5, the answer is 'buzz'

    /// if the number is divisible by both 5 and 3, the answer is 'fizzbuzz'

    /// in all other cases the answer is the supplied number

    /// </summary>

    public static Func<object> Evaluate(object param)

    {

        object result = (string)param;

        if((int)param % 3 == 0)

            result = "fizz";

        if((int)param % 5 == 0)

            result = "buzz";

        if((int)param % 3 == 0 && (int)param % 5 == 0)

            result = "fizzbuzz";

        return (System.Func<object>)result;

    }

}

namespace FunctionalExtensions {

    public static class FunctionOperators

    {

        // partial application (assume partial application of the first argument)

        public static Func<P2, R> PartialApply<P1, P2, R>(Func<P1, P2, R> fn, P2 x) => throw new NotImplementedException();

        // curry: curry(f(x, y, z)) = f'(x)(y)(z)

        public static void Curry<P1, P2, R>(Func<P1, P2, R> fn) => throw new NotImplementedException();

        // compose: compose(f,g)(x) = f(g(x))

        public static void Compose<P1, P2, R>(this Func<P1, P2> fn1, Func<P2, R> fn2) => throw new NotImplementedException();

    }

}

​