using System;

using System.Linq;

using System.Collections.Generic;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System.Text;

​

//1.  Implement the Implementations.GreenTea() method, according to it's description.

//2.  Implement the Implementations.FirstHalf() method, according to it's description.

//3.  Can you refactor the Program.AssertFirstHalfIsCorrect() method to handle more cases without hardcoding expected results?

//4.  Can you refactor the Implementations.GreenTea() method so that it can be tested, with or without hardcoding expected results?

//5.  When you have finished the test, please hit "Share" or "Fork" and then share the link back to us.

​

//Please treat this as if it were production quality code and tests you have to write, so highlight any potential pitfalls of the 

//approaches you take, maybe add some comments on additional tests you might right if you don't have time to write them now.    

public static class Implementations

{

    /// Prints out the numbers from 1 to n, 

    /// but if the number is divisible by 3 prints "Green" instead of the number,

    /// if the number is divisible by 5 it prints "Tea" instead of the number,

    /// and if the number is divisible by both 3 and 5 it prints "GreenTea" instead of the number.

    public static void GreenTea(int n)

    {

        var divisibleBy3 = (n % 3) == 0;

        var divisibleBy5 = (n % 5) == 0;

        var prints = divisibleBy3 || divisibleBy5;

        if(divisibleBy3){

            Console.Write("Green");

        }

        if(divisibleBy5){

            Console.Write("Tea");

        }

        if(prints){

            Console.Write('\n');

        }

    }

    /// Returns the first half of the given sequence.  For example:

    ///   new[] { "North", "South", "East", "West" }.FirstHalf()

    /// returns "North","South".  An example with an odd number of items:

    ///   new[] { "red", "green", "blue" }.FirstHalf()

    /// returns "red".

    public static IEnumerable<T> FirstHalf<T>(this IEnumerable<T> tt)

    {

        if (tt is ICollection<T>){

            var size = Math.Floor(tt.Count() / 2.0);

            var cursor=tt.GetEnumerator();

            while ((size-- != 0) && cursor.MoveNext()){

                yield return cursor.Current;

            }

        } else {

            // if this executes a query behind the scenes, it might be heavy, but there is no other way to get the count unless you execute it

            foreach(var item in tt.ToList().FirstHalf()){

                yield return item;  

            }

        }

    }

​

}

public class Program

{

    public static void Main()

    {

        AssertGreenTeaIsCorrect(1020);

        AssertGreenTeaIsCorrect(102);

        AssertGreenTeaIsCorrect(10);

        AssertGreenTeaIsCorrect(4);

        AssertFirstHalfIsCorrect(new string [] { "North", "South", "East", "West" });

        AssertFirstHalfIsCorrect(new string [] { "red", "green", "blue" });     

        AssertFirstHalfIsCorrect((new string [] { "North", "South", "East", "West" }).Select(i=>i));

        AssertFirstHalfIsCorrect((new string [] { "red", "green", "blue" }).Select(i=>i));

​

        Console.WriteLine("All tests succeeded.");

    }

    public static void AssertGreenTeaIsCorrect(int n)

    {

        Implementations.GreenTea(n);

    }

    public static void AssertFirstHalfIsCorrect(IEnumerable<string> tt)

    {

        var result = tt.FirstHalf();

        if (tt.SequenceEqual(new string [] { "North", "South", "East", "West" }))

            Assert.IsTrue(result.SequenceEqual(new string [] { "North", "South" }));

        else if (tt.SequenceEqual(new string [] { "red", "green", "blue" }))

            Assert.IsTrue(result.SequenceEqual(new string [] { "red" }));

        else

            Assert.Fail("No benchmark for sequence {0}.", string.Join(", ", tt));

    }

}

​

​