C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Linq;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;

//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.
	
	// In order to make "GreenTea" testable, I had to change it's signature. 
	// Now, it returns a sequence of strings corresponding to the expected result instead of printing it.
	// It is on the caller method to print the sequence. 
	public static IEnumerable<string> GreenTea(int n)
	{
		for (int i = 1; i <= n; i++)
		{
			if (i % 3 == 0 && i % 5 == 0)
				yield return "GreenTea";
			else if (i % 3 == 0)
				yield return "Green";
			else if (i % 5 == 0)
				yield return "Tea";
			else
				yield return i.ToString();
		}
	}
	
	/// 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)
	{
		int halfSize = tt.Count() / 2;
		
		return tt.Take(halfSize);
	}

}
					
public class Program
{
	public static void Main()
	{
		//Deleted some of the original tests because the expected sequence would be too long.
		AssertGreenTeaIsCorrect(10, new string[]{"1", "2", "Green", "4", "Tea", "Green", "7", "8", "Green", "Tea"});
		AssertGreenTeaIsCorrect(16, new string[]{"1", "2", "Green", "4", "Tea", "Green", "7", "8", "Green", "Tea", "11", "Green", "13", "14", "GreenTea", "16"});
		AssertGreenTeaIsCorrect(0, new string[]{ });
		
		AssertFirstHalfIsCorrect(new string [] { "North", "South", "East", "West" }, new string [] { "North", "South" });
		AssertFirstHalfIsCorrect(new string [] { "red", "green", "blue" }, new string [] { "red" });
		AssertFirstHalfIsCorrect(new string [] { }, new string [] { });

		Console.WriteLine("All tests succeeded.");
	}
	
	public static void AssertGreenTeaIsCorrect(int n, IEnumerable<string> expected)
	{
		// Act
		var result = Implementations.GreenTea(n);
		
		// Assert
		Assert.IsTrue(expected.SequenceEqual(result));
	}
	
	public static void AssertFirstHalfIsCorrect(IEnumerable<string> tt, IEnumerable<string> expected)
	{
		// Act
		var result = tt.FirstHalf();
		
		// Assert
		Assert.IsTrue(expected.SequenceEqual(result));
	}
}

​x
 
using System;
using System.Linq;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
​
//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.
    
    // In order to make "GreenTea" testable, I had to change it's signature. 
    // Now, it returns a sequence of strings corresponding to the expected result instead of printing it.
    // It is on the caller method to print the sequence. 
    public static IEnumerable<string> GreenTea(int n)
    {
        for (int i = 1; i <= n; i++)
        {
            if (i % 3 == 0 && i % 5 == 0)
                yield return "GreenTea";
            else if (i % 3 == 0)
                yield return "Green";
            else if (i % 5 == 0)
                yield return "Tea";
            else
                yield return i.ToString();
        }
    }
    
    /// 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)
    {
        int halfSize = tt.Count() / 2;
        
        return tt.Take(halfSize);
    }
​
}
                    
public class Program
{
    public static void Main()
    {
        //Deleted some of the original tests because the expected sequence would be too long.
        AssertGreenTeaIsCorrect(10, new string[]{"1", "2", "Green", "4", "Tea", "Green", "7", "8", "Green", "Tea"});
        AssertGreenTeaIsCorrect(16, new string[]{"1", "2", "Green", "4", "Tea", "Green", "7", "8", "Green", "Tea", "11", "Green", "13", "14", "GreenTea", "16"});
        AssertGreenTeaIsCorrect(0, new string[]{ });
        
        AssertFirstHalfIsCorrect(new string [] { "North", "South", "East", "West" }, new string [] { "North", "South" });
        AssertFirstHalfIsCorrect(new string [] { "red", "green", "blue" }, new string [] { "red" });
        AssertFirstHalfIsCorrect(new string [] { }, new string [] { });
​
        Console.WriteLine("All tests succeeded.");
    }
    
    public static void AssertGreenTeaIsCorrect(int n, IEnumerable<string> expected)
    {
        // Act
        var result = Implementations.GreenTea(n);
        
        // Assert
        Assert.IsTrue(expected.SequenceEqual(result));
    }
    
    public static void AssertFirstHalfIsCorrect(IEnumerable<string> tt, IEnumerable<string> expected)
    {
        // Act
        var result = tt.FirstHalf();
        
        // Assert
        Assert.IsTrue(expected.SequenceEqual(result));
    }
}
​
​

Sum1 = 9
Sum2 = -43
RG1 = 8
RG2 = 13
CNTsqrt = -1
CNTres = 0

x     Sum2               Sum2 overflow    Sum1           CNTsqrt          CNTsqrt overflow    CNTres
1     -43 + 18 = -25                      9 + 8 = 17
2     -25 + 34 = 9       1                17 + 8 = 25    -1 + 1 = 0       1                   1
                                                         0 + -2 = -2
      9 + -26 = -17
3     -17 + 50 = 33      1                25 + 8 = 33    -2 + 1 = -1
      33 + -26 = 7       1                               -1 + 1 = 0       1                   2
                                                         0 + -4 = -4
      7 + -26 = -19
4     -19 + 66 = 47      1                33 + 8 = 41    -4 + 1 = -3
      47 + -26 = 21      1                               -3 + 1 = -2
      21 + -26 = -5
5     -5 + 82 = 77       1                41 + 8 = 49    -2 + 1 = -1
      77 + -26 = 51      1                               -1 + 1 = 0       1                   3
                                                         0 + -6 = -6
      51 + -26 = 25      1                               -6 + 1 = -5
      25 + -26 = -1
6     -1 + 98 = 97       1                49 + 8 = 57    -5 + 1 = -4
      97 + -26 = 71      1                               -4 + 1 = -3
      71 + -26 = 45      1                               -3 + 1 = -2
      45 + -26 = 19      1                               -2 + 1 = -1
      19 + -26 = -7
7     -7 + 114 = 107     1                57 + 8 = 65    -1 + 1 = 0       1                   4
                                                         0 + -8 = -8
      107 + -26 = 81     1                               -8 + 1 = -7
      81 + -26 = 55      1                               -7 + 1 = -6
      55 + -26 = 29      1                               -6 + 1 = -5
      29 + -26 = 3       1                               -5 + 1 = -4
      3 + -26 = -23
8     -23 + 130 = 107    1                65 + 8 = 73    -4 + 1 = -3
      107 + -26 = 81     1                               -3 + 1 = -2
      81 + -26 = 55      1                               -2 + 1 = -1
      55 + -26 = 29      1                               -1 + 1 = 0       1                   5
                                                         0 + -10 = -10
      29 + -26 = 3       1                               -10 + 1 = -9
      3 + -26 = -23
9     -23 + 146 = 123    1                73 + 8 = 81    -9 + 1 = -8
      123 + -26 = 97     1                               -8 + 1 = -7
      97 + -26 = 71      1                               -7 + 1 = -6
      71 + -26 = 45      1                               -6 + 1 = -5
      45 + -26 = 19      1                               -5 + 1 = -4
      19 + -26 = -7
10    -7 + 162 = 155     1                81 + 8 = 89    -4 + 1 = -3
      155 + -26 = 129    1                               -3 + 1 = -2
      129 + -26 = 103    1                               -2 + 1 = -1
      103 + -26 = 77     1                               -1 + 1 = 0       1                   6
                                                         0 + -12 = -12
      77 + -26 = 51      1                               -12 + 1 = -11
      51 + -26 = 25      1                               -11 + 1 = -10
      25 + -26 = -1

Cached Result
Last Run:	4:01:35 am
Compile:	0.127s
Execute:	0s
Memory:	152.05kb
CPU:	0s

View IL Code