[Fork] [Fork] Maxcode internship Sprint 2020 | C# Online Compiler

[Fork] [Fork] Maxcode internship Sprint 2020 by gafgabriel

using System;
using Shouldly;
using System.Collections.Generic;

/// <summary>
/// This test has two exercises.
/// The requirements are described in the relevant summary section of each class.
/// You will need to write the implementation inside the class of each exercise.
///
/// Before starting this test, press the "Fork" button in the toolbar above and then press save.
/// Press Run once and make sure the console output has no build errors.
/// If you've made no changes and there are build errors, send us an email.
///
/// This program is set up as a Console Application.
///    If you want to work on the test in another IDE, you will have to install the Shouldly nuget package for the tests
/// 
/// The Program.Main method checks the output of each exercise by comparing the result against the expected output.
/// You can use this to test your code.
/// Running the code will make the test fail if the check does not pass.
///
/// Example: check false.ShouldBe(true) - will always fail
///
/// You can also use it to add your own tests if you want to.
/// 
/// Before you are done please make sure the following are true:
/// - Your code is compilable (i.e. it builds successfully)
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
/// 
/// We will evaluate both the correctitude as well as the quality of your solution    
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>
public class WastedSandCounter
{
	/// <summary>
	///   Given a matrix representing the number of grains of sand at a certain position
	///   on a table at a fixed point of time, return how much sand falls off the edge of the
	///   table when time is unfrozen.
	///   Behaviour of the sand:
	///   Sand is coarse, rough, irritating and it gets everywhere.
	///   The way it does that is the following:
	///       - if there are more than 3 grains of sand at a position, it collapses 
	///         and one grain of sand falls on each of it's neighbouring positions
	///         Ex:
	///           0 0 0      0 1 0     
	///           0[6]0  ->  1 2 1
	///           0 0 0      0 1 0
	///
	///       - if the sand falls outside the matrix, then it is lost to the wind
	///         Ex:
	///          [4]0 0      0 1 0
	///           0 0 0  ->  1 0 0
	///           0 0 0      0 0 0
	/// 
	///   Longer example:
	///
	///  [5]3 0 (1)  1[4]0 (2)  2 0 1 (3)  3 0 1 (4)  3 1 1 (5)  3 1 1
	///   4 2 0  ->  5 2 0  -> [5]3 0  ->  1[4]0  ->  2 0 1  ->  3 0 1
	///   3 1 2      3 1 2      3 1 2      4 1 2     [4]2 2      0 3 2
	///
	///   - in step (1), there were two grains of sand lost (fallen off the top and left side)
	///   - in step (2), there was one grain of sand lost (fallen off the top side)
	///   - in step (3), there was one grain of sand lost (fallen off the left side)
	///   - in step (4), there were no grains of sand lost
	///   - in step (5), there were two grains of sand lost (fallen off the left and bottom side)
	///   in total there were 2 + 1 + 1 + 0 + 2 = 6 grains of sand lost
	///   
	/// </summary>
	/// <param name = "sandPile">Matrix representing the sand piles on a table. It can have various sizes (not necessarily 3 x 3)</param>
	/// <returns>Integer representing the number of grains of sand fallen of the edges.</returns>
	public int onTheEdge(int i, int j, int n, int m)
	{
		if (i == 0 && j == 0 || i == n - 1 && j == 0 || i == 0 && j == m - 1 || i == n - 1 && j == m - 1)
			return 2;
		else if (i == 0 || j == 0 || i == n - 1 || j == m - 1)
			return 1;
		else
			return 0;
	}

	public int Count(int[, ] sandPile)
	{
		int totalCount = 0;
		int currentCount;
		int n = sandPile.GetLength(0);
		int m = sandPile.GetLength(1);
		bool changesMade;
		do
		{
			changesMade = false;
			currentCount = 0;
			for (int i = 0; i < n; i++)
			{
				for (int j = 0; j < m; j++)
				{
					try
					{
						if (sandPile[i, j] >= 4)
						{
							changesMade = true;
							sandPile[i, j] -= 4;
							if (onTheEdge(i, j, n, m) == 0)
							{
								sandPile[i - 1, j]++;
								sandPile[i, j - 1]++;
								sandPile[i + 1, j]++;
								sandPile[i, j + 1]++;
							}
							else if (onTheEdge(i, j, n, m) == 1)
							{
								currentCount++;
								if (i == 0)
								{
									sandPile[i + 1, j]++;
									sandPile[i, j + 1]++;
									sandPile[i, j - 1]++;
								}

								if (i == n - 1)
								{
									sandPile[i - 1, j]++;
									sandPile[i, j - 1]++;
									sandPile[i, j + 1]++;
								}

								if (j == 0)
								{
									sandPile[i, j + 1]++;
									sandPile[i + 1, j]++;
									sandPile[i - 1, j]++;
								}

								if (j == m - 1)
								{
									sandPile[i, j - 1]++;
									sandPile[i + 1, j]++;
									sandPile[i - 1, j]++;
								}
							}
							else if (onTheEdge(i, j, n, m) == 2)
							{
								currentCount += 2;
								if (i == 0 && j == 0)
								{
									sandPile[i + 1, j]++;
									sandPile[i, j + 1]++;
								}

								if (i == n - 1 && j == 0)
								{
									sandPile[i - 1, j]++;
									sandPile[i, j + 1]++;
								}

								if (i == n - 1 && j == m - 1)
								{
									sandPile[i - 1, j]++;
									sandPile[i, j - 1]++;
								}

								if (i == 0 && j == m - 1)
								{
									sandPile[i, j - 1]++;
									sandPile[i + 1, j]++;
								}
							}
						}
					}
					catch (Exception e)
					{
						Console.WriteLine(e.Message);
					}
				}
			}

			totalCount += currentCount;
		}
		while (changesMade == true);
		return totalCount;
	}
}

/// <summary>
/// A marketplace is a spot where [people], have an [initial inventory] of different [product types] they can trade with each other.
/// 
/// Ex: people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 3
///     This means that:
///         - Mary has 3 apples and 3 grapes
///         - John has 3 apples and 3 grapes.
///     (These values will be processed as constructor parameters)
///
/// Given a list of all the transactions done in the marketplace, a person and a product type,
/// return how many products of that type the person has left after doing the transactions.
///
/// Transactions are strings and can be of two types:
///     Mary sold 2 apples to John
///     Mary bought 1 grapes from John
/// For simplicity, products will have the name given in the product types list, regardless of plurality (1 apples, 2 apples).
/// Transactions will always contain product types and people that are in the people and product types lists.
/// 
/// If a transaction cannot happen, that means it is invalid, and so it is ignored.
/// Subsequent calls to the CheckInventory method should return the same result for the same parameters (state is not kept)
///
/// Example:
///     people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 2
///
///     person: John
///     product type: grapes
///     transactions:
///         "Mary sold 3 apples to John" -- cannot happen, Mary has 2 apples
///         "John bought 1 grapes from Mary" -- John has 3 grapes now, Mary has one grape
///         "John sold 1 apples to Mary" -- John has 1 apple, Mary has 3 apples
///
///     After doing all the transactions, if we check the inventory for John's grapes: John has 3 grapes, so the returned value is 3.
/// </summary>
public class Marketplace
{
	private readonly string[] _people;
	private readonly string[] _productTypes;
	private readonly int _initialInventory;
	public Marketplace(string[] people, string[] productTypes, int initialInventory)
	{
		_people = people;
		_productTypes = productTypes;
		_initialInventory = initialInventory;
	}

	/// <summary>
	/// Integer representing how much of a "productType" the "person" has in it's inventory after all
	/// the valid transactions are finished.
	/// </summary>
	/// <param name = "transactions">List of transactions</param>
	/// <param name = "person">Name of the person</param>
	/// <param name = "productType">Name of the product type</param>
	/// <returns>Integer representing how much of a "productType" the "person" has.</returns>
	public int CheckInventory(IEnumerable<string> transactions, string person, string productType)
	{
		int[, ] currentInventory = new int[_people.Length, _productTypes.Length];
		for (int i = 0; i < currentInventory.GetLength(0); i++)
			for (int j = 0; j < currentInventory.GetLength(1); j++)
				currentInventory[i, j] = _initialInventory;
		foreach (string s in transactions)
		{
			try
			{
				string[] words = s.Split(' ');
				string persOne = words[0];
				string persTwo = words[words.Length - 1];
				string choiceOne = "bought";
				string choiceTwo = "sold";
				int indexOfPersOne = 0, indexOfPersTwo = 0, indexOfProduct = 0;
				bool[] valid = new bool[]{false, false, false, false, true};
				for (int i = 0; i < _people.Length; i++)
				{
					if (String.Equals(_people[i], persOne))
					{
						valid[0] = true;
						indexOfPersOne = i;
					}

					if (String.Equals(_people[i], persTwo))
					{
						valid[1] = true;
						indexOfPersTwo = i;
					}
				}

				if (String.Equals(words[1], choiceOne) || String.Equals(words[1], choiceTwo))
				{
					valid[2] = true;
				}

				for (int i = 0; i < _productTypes.Length; i++)
				{
					if (String.Equals(_productTypes[i], words[3]))
					{
						valid[3] = true;
						indexOfProduct = i;
					}
				}

				for (int i = 0; i < valid.Length - 1; i++)
					if (valid[i] == false)
						valid[valid.Length - 1] = false;
				if (valid[valid.Length - 1] == true)
				{
					int amountExchanged = Convert.ToInt32(words[2]);
					if (String.Equals(words[1], choiceOne))
					{
						if (currentInventory[indexOfPersTwo, indexOfProduct] >= amountExchanged)
						{
							currentInventory[indexOfPersTwo, indexOfProduct] -= amountExchanged;
							currentInventory[indexOfPersOne, indexOfProduct] += amountExchanged;
						}
					}

					if (String.Equals(words[1], choiceTwo))
					{
						if (currentInventory[indexOfPersOne, indexOfProduct] >= amountExchanged)
						{
							currentInventory[indexOfPersOne, indexOfProduct] -= amountExchanged;
							currentInventory[indexOfPersTwo, indexOfProduct] += amountExchanged;
						}
					}
				}
			}
			catch (NullReferenceException e)
			{
				Console.WriteLine(e.Message);
			}
		}

		int indexOfPers = 0, indexOfProd = 0;
		for (int i = 0; i < _people.Length; i++)
			if (String.Equals(person, _people[i]))
				indexOfPers = i;
		for (int i = 0; i < _productTypes.Length; i++)
			if (String.Equals(productType, _productTypes[i]))
				indexOfProd = i;
		return currentInventory[indexOfPers, indexOfProd];
	}
}

/// <summary>
/// This part of the code calls the unit tests.
/// It does not contain exercises for this test, but feel free to look around if you want
/// </summary>
public class Program
{
	public static void Main()
	{
		Run();
	}

	private static void Run()
	{
		new WastedSandCounterTests().Start();
		new MarketplaceTests().Start();
	}
}

/// <summary>
/// This class contains the unit tests for the WastedSandCounter exercise
/// </summary>
public class WastedSandCounterTests
{
	public void Start()
	{
		Tests.Run("WastedSandCounter should", (it) =>
		{
			it.Should(NotCountSandFallingOnTheTable, "not count sand that falls on the table");
			it.Should(CountAllSandFallingOffTheTable, "count sand that falls off the table");
			it.Should(FullyCollapseTallSandPiles, "fully collapse tall piles of the sand");
		}

		);
	}

	public void NotCountSandFallingOnTheTable()
	{
		var counter = new WastedSandCounter();
		var table = new[, ]{{0, 0, 0}, {0, 4, 0}, {0, 0, 0}};
		counter.Count(table).ShouldBe(0);
	}

	public void CountAllSandFallingOffTheTable()
	{
		var counter = new WastedSandCounter();
		var table = new[, ]{{2, 4, 2}, {4, 0, 4}, {2, 4, 2}};
		counter.Count(table).ShouldBe(12);
	}

	public void FullyCollapseTallSandPiles()
	{
		var counter = new WastedSandCounter();
		var table = new[, ]{{12, 0, 0}, {0, 0, 0}, {0, 0, 0}};
		counter.Count(table).ShouldBe(6);
	}
}

/// <summary>
/// This class contains the unit tests for the Marketplace exercise
/// </summary>
public class MarketplaceTests
{
	public void Start()
	{
		Tests.Run("Marketplace should", (it) =>
		{
			it.Should(() => NotDoInvalidTransactions(), "not do transactions that are invalid");
			it.Should(() => DoValidTransactions(), "do transactions that are invalid");
		}

		);
	}

	public void NotDoInvalidTransactions()
	{
		var marketplace = new Marketplace(new[]{"Ana", "Ion"}, new[]{"apples"}, 3);
		marketplace.CheckInventory(new[]{"Ana sold 4 apples to Ion"}, "Ana", "apples").ShouldBe(3);
		marketplace.CheckInventory(new[]{"Ion bought 4 apples from Ana"}, "Ana", "apples").ShouldBe(3);
	}

	public void DoValidTransactions()
	{
		var marketplace = new Marketplace(new[]{"Ana", "Ion"}, new[]{"apples"}, 4);
		marketplace.CheckInventory(new[]{"Ana sold 4 apples to Ion", "Ion sold 2 apples to Ana"}, "Ana", "apples").ShouldBe(2);
	}
}

/// <summary>
/// This class runs the tests and formats the results
/// </summary>
public class Tests
{
	private Tests()
	{
	}

	public static void Run(string testGroup, Action<Tests> tests)
	{
		StartTests(testGroup);
		tests(new Tests());
		EndTests();
	}

	public static void StartTests(string testGroup)
	{
		Console.WriteLine("====================================================");
		Console.WriteLine(testGroup);
		Console.WriteLine("====================================================");
	}

	public void Should(Action test, string testName)
	{
		try
		{
			Console.WriteLine(testName);
			test();
			Console.WriteLine("    Passed");
		}
		catch (Exception e)
		{
			Console.WriteLine("    Failed");
			Console.WriteLine("    " + e.Message);
		}
		finally
		{
			Console.WriteLine();
		}
	}

	public static void EndTests()
	{
		Console.WriteLine();
	}
}

​x
 
using System;
using Shouldly;
using System.Collections.Generic;
​
/// <summary>
/// This test has two exercises.
/// The requirements are described in the relevant summary section of each class.
/// You will need to write the implementation inside the class of each exercise.
///
/// Before starting this test, press the "Fork" button in the toolbar above and then press save.
/// Press Run once and make sure the console output has no build errors.
/// If you've made no changes and there are build errors, send us an email.
///
/// This program is set up as a Console Application.
///    If you want to work on the test in another IDE, you will have to install the Shouldly nuget package for the tests
/// 
/// The Program.Main method checks the output of each exercise by comparing the result against the expected output.
/// You can use this to test your code.
/// Running the code will make the test fail if the check does not pass.
///
/// Example: check false.ShouldBe(true) - will always fail
///
/// You can also use it to add your own tests if you want to.
/// 
/// Before you are done please make sure the following are true:
/// - Your code is compilable (i.e. it builds successfully)
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
/// 
/// We will evaluate both the correctitude as well as the quality of your solution    
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>
public class WastedSandCounter
{
    /// <summary>
    ///   Given a matrix representing the number of grains of sand at a certain position
    ///   on a table at a fixed point of time, return how much sand falls off the edge of the
    ///   table when time is unfrozen.
    ///   Behaviour of the sand:
    ///   Sand is coarse, rough, irritating and it gets everywhere.
    ///   The way it does that is the following:
    ///       - if there are more than 3 grains of sand at a position, it collapses 
    ///         and one grain of sand falls on each of it's neighbouring positions
    ///         Ex:
    ///           0 0 0      0 1 0     
    ///           0[6]0  ->  1 2 1
    ///           0 0 0      0 1 0
    ///
    ///       - if the sand falls outside the matrix, then it is lost to the wind
    ///         Ex:
    ///          [4]0 0      0 1 0
    ///           0 0 0  ->  1 0 0
    ///           0 0 0      0 0 0
    /// 
    ///   Longer example:
    ///
    ///  [5]3 0 (1)  1[4]0 (2)  2 0 1 (3)  3 0 1 (4)  3 1 1 (5)  3 1 1
    ///   4 2 0  ->  5 2 0  -> [5]3 0  ->  1[4]0  ->  2 0 1  ->  3 0 1
    ///   3 1 2      3 1 2      3 1 2      4 1 2     [4]2 2      0 3 2
    ///
    ///   - in step (1), there were two grains of sand lost (fallen off the top and left side)
    ///   - in step (2), there was one grain of sand lost (fallen off the top side)
    ///   - in step (3), there was one grain of sand lost (fallen off the left side)
    ///   - in step (4), there were no grains of sand lost
    ///   - in step (5), there were two grains of sand lost (fallen off the left and bottom side)
    ///   in total there were 2 + 1 + 1 + 0 + 2 = 6 grains of sand lost
    ///   
    /// </summary>
    /// <param name = "sandPile">Matrix representing the sand piles on a table. It can have various sizes (not necessarily 3 x 3)</param>
    /// <returns>Integer representing the number of grains of sand fallen of the edges.</returns>
    public int onTheEdge(int i, int j, int n, int m)
    {
        if (i == 0 && j == 0 || i == n - 1 && j == 0 || i == 0 && j == m - 1 || i == n - 1 && j == m - 1)
            return 2;
        else if (i == 0 || j == 0 || i == n - 1 || j == m - 1)
            return 1;
        else
            return 0;
    }
​
    public int Count(int[, ] sandPile)
    {
        int totalCount = 0;
        int currentCount;
        int n = sandPile.GetLength(0);
        int m = sandPile.GetLength(1);
        bool changesMade;
        do
        {
            changesMade = false;
            currentCount = 0;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    try
                    {
                        if (sandPile[i, j] >= 4)
                        {
                            changesMade = true;
                            sandPile[i, j] -= 4;
                            if (onTheEdge(i, j, n, m) == 0)
                            {
                                sandPile[i - 1, j]++;
                                sandPile[i, j - 1]++;
                                sandPile[i + 1, j]++;
                                sandPile[i, j + 1]++;
                            }
                            else if (onTheEdge(i, j, n, m) == 1)
                            {
                                currentCount++;
                                if (i == 0)
                                {
                                    sandPile[i + 1, j]++;
                                    sandPile[i, j + 1]++;
                                    sandPile[i, j - 1]++;
                                }
​
                                if (i == n - 1)
                                {
                                    sandPile[i - 1, j]++;
                                    sandPile[i, j - 1]++;
                                    sandPile[i, j + 1]++;
                                }
​
                                if (j == 0)
                                {
                                    sandPile[i, j + 1]++;
                                    sandPile[i + 1, j]++;
                                    sandPile[i - 1, j]++;
                                }
​
                                if (j == m - 1)
                                {
                                    sandPile[i, j - 1]++;
                                    sandPile[i + 1, j]++;
                                    sandPile[i - 1, j]++;
                                }
                            }
                            else if (onTheEdge(i, j, n, m) == 2)
                            {
                                currentCount += 2;
                                if (i == 0 && j == 0)
                                {
                                    sandPile[i + 1, j]++;
                                    sandPile[i, j + 1]++;
                                }
​
                                if (i == n - 1 && j == 0)
                                {
                                    sandPile[i - 1, j]++;
                                    sandPile[i, j + 1]++;
                                }
​
                                if (i == n - 1 && j == m - 1)
                                {
                                    sandPile[i - 1, j]++;
                                    sandPile[i, j - 1]++;
                                }
​
                                if (i == 0 && j == m - 1)
                                {
                                    sandPile[i, j - 1]++;
                                    sandPile[i + 1, j]++;
                                }
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                }
            }
​
            totalCount += currentCount;
        }
        while (changesMade == true);
        return totalCount;
    }
}
​
/// <summary>
/// A marketplace is a spot where [people], have an [initial inventory] of different [product types] they can trade with each other.
/// 
/// Ex: people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 3
///     This means that:
///         - Mary has 3 apples and 3 grapes
///         - John has 3 apples and 3 grapes.
///     (These values will be processed as constructor parameters)
///
/// Given a list of all the transactions done in the marketplace, a person and a product type,
/// return how many products of that type the person has left after doing the transactions.
///
/// Transactions are strings and can be of two types:
///     Mary sold 2 apples to John
///     Mary bought 1 grapes from John
/// For simplicity, products will have the name given in the product types list, regardless of plurality (1 apples, 2 apples).
/// Transactions will always contain product types and people that are in the people and product types lists.
/// 
/// If a transaction cannot happen, that means it is invalid, and so it is ignored.
/// Subsequent calls to the CheckInventory method should return the same result for the same parameters (state is not kept)
///
/// Example:
///     people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 2
///
///     person: John
///     product type: grapes
///     transactions:
///         "Mary sold 3 apples to John" -- cannot happen, Mary has 2 apples
///         "John bought 1 grapes from Mary" -- John has 3 grapes now, Mary has one grape
///         "John sold 1 apples to Mary" -- John has 1 apple, Mary has 3 apples
///
///     After doing all the transactions, if we check the inventory for John's grapes: John has 3 grapes, so the returned value is 3.
/// </summary>
public class Marketplace
{
    private readonly string[] _people;
    private readonly string[] _productTypes;
    private readonly int _initialInventory;
    public Marketplace(string[] people, string[] productTypes, int initialInventory)
    {
        _people = people;
        _productTypes = productTypes;
        _initialInventory = initialInventory;
    }
​
    /// <summary>
    /// Integer representing how much of a "productType" the "person" has in it's inventory after all
    /// the valid transactions are finished.
    /// </summary>
    /// <param name = "transactions">List of transactions</param>
    /// <param name = "person">Name of the person</param>
    /// <param name = "productType">Name of the product type</param>
    /// <returns>Integer representing how much of a "productType" the "person" has.</returns>
    public int CheckInventory(IEnumerable<string> transactions, string person, string productType)
    {
        int[, ] currentInventory = new int[_people.Length, _productTypes.Length];
        for (int i = 0; i < currentInventory.GetLength(0); i++)
            for (int j = 0; j < currentInventory.GetLength(1); j++)
                currentInventory[i, j] = _initialInventory;
        foreach (string s in transactions)
        {
            try
            {
                string[] words = s.Split(' ');
                string persOne = words[0];
                string persTwo = words[words.Length - 1];
                string choiceOne = "bought";
                string choiceTwo = "sold";
                int indexOfPersOne = 0, indexOfPersTwo = 0, indexOfProduct = 0;
                bool[] valid = new bool[]{false, false, false, false, true};
                for (int i = 0; i < _people.Length; i++)
                {
                    if (String.Equals(_people[i], persOne))
                    {
                        valid[0] = true;
                        indexOfPersOne = i;
                    }
​
                    if (String.Equals(_people[i], persTwo))
                    {
                        valid[1] = true;
                        indexOfPersTwo = i;
                    }
                }
​
                if (String.Equals(words[1], choiceOne) || String.Equals(words[1], choiceTwo))
                {
                    valid[2] = true;
                }
​
                for (int i = 0; i < _productTypes.Length; i++)
                {
                    if (String.Equals(_productTypes[i], words[3]))
                    {
                        valid[3] = true;
                        indexOfProduct = i;
                    }
                }
​
                for (int i = 0; i < valid.Length - 1; i++)
                    if (valid[i] == false)
                        valid[valid.Length - 1] = false;
                if (valid[valid.Length - 1] == true)
                {
                    int amountExchanged = Convert.ToInt32(words[2]);
                    if (String.Equals(words[1], choiceOne))
                    {
                        if (currentInventory[indexOfPersTwo, indexOfProduct] >= amountExchanged)
                        {
                            currentInventory[indexOfPersTwo, indexOfProduct] -= amountExchanged;
                            currentInventory[indexOfPersOne, indexOfProduct] += amountExchanged;
                        }
                    }
​
                    if (String.Equals(words[1], choiceTwo))
                    {
                        if (currentInventory[indexOfPersOne, indexOfProduct] >= amountExchanged)
                        {
                            currentInventory[indexOfPersOne, indexOfProduct] -= amountExchanged;
                            currentInventory[indexOfPersTwo, indexOfProduct] += amountExchanged;
                        }
                    }
                }
            }
            catch (NullReferenceException e)
            {
                Console.WriteLine(e.Message);
            }
        }
​
        int indexOfPers = 0, indexOfProd = 0;
        for (int i = 0; i < _people.Length; i++)
            if (String.Equals(person, _people[i]))
                indexOfPers = i;
        for (int i = 0; i < _productTypes.Length; i++)
            if (String.Equals(productType, _productTypes[i]))
                indexOfProd = i;
        return currentInventory[indexOfPers, indexOfProd];
    }
}
​
/// <summary>
/// This part of the code calls the unit tests.
/// It does not contain exercises for this test, but feel free to look around if you want
/// </summary>
public class Program
{
    public static void Main()
    {
        Run();
    }
​
    private static void Run()
    {
        new WastedSandCounterTests().Start();
        new MarketplaceTests().Start();
    }
}
​
/// <summary>
/// This class contains the unit tests for the WastedSandCounter exercise
/// </summary>
public class WastedSandCounterTests
{
    public void Start()
    {
        Tests.Run("WastedSandCounter should", (it) =>
        {
            it.Should(NotCountSandFallingOnTheTable, "not count sand that falls on the table");
            it.Should(CountAllSandFallingOffTheTable, "count sand that falls off the table");
            it.Should(FullyCollapseTallSandPiles, "fully collapse tall piles of the sand");
        }
​
        );
    }
​
    public void NotCountSandFallingOnTheTable()
    {
        var counter = new WastedSandCounter();
        var table = new[, ]{{0, 0, 0}, {0, 4, 0}, {0, 0, 0}};
        counter.Count(table).ShouldBe(0);
    }
​
    public void CountAllSandFallingOffTheTable()
    {
        var counter = new WastedSandCounter();
        var table = new[, ]{{2, 4, 2}, {4, 0, 4}, {2, 4, 2}};
        counter.Count(table).ShouldBe(12);
    }
​
    public void FullyCollapseTallSandPiles()
    {
        var counter = new WastedSandCounter();
        var table = new[, ]{{12, 0, 0}, {0, 0, 0}, {0, 0, 0}};
        counter.Count(table).ShouldBe(6);
    }
}
​
/// <summary>
/// This class contains the unit tests for the Marketplace exercise
/// </summary>
public class MarketplaceTests
{
    public void Start()
    {
        Tests.Run("Marketplace should", (it) =>
        {
            it.Should(() => NotDoInvalidTransactions(), "not do transactions that are invalid");
            it.Should(() => DoValidTransactions(), "do transactions that are invalid");
        }
​
        );
    }
​
    public void NotDoInvalidTransactions()
    {
        var marketplace = new Marketplace(new[]{"Ana", "Ion"}, new[]{"apples"}, 3);
        marketplace.CheckInventory(new[]{"Ana sold 4 apples to Ion"}, "Ana", "apples").ShouldBe(3);
        marketplace.CheckInventory(new[]{"Ion bought 4 apples from Ana"}, "Ana", "apples").ShouldBe(3);
    }
​
    public void DoValidTransactions()
    {
        var marketplace = new Marketplace(new[]{"Ana", "Ion"}, new[]{"apples"}, 4);
        marketplace.CheckInventory(new[]{"Ana sold 4 apples to Ion", "Ion sold 2 apples to Ana"}, "Ana", "apples").ShouldBe(2);
    }
}
​
/// <summary>
/// This class runs the tests and formats the results
/// </summary>
public class Tests
{
    private Tests()
    {
    }
​
    public static void Run(string testGroup, Action<Tests> tests)
    {
        StartTests(testGroup);
        tests(new Tests());
        EndTests();
    }
​
    public static void StartTests(string testGroup)
    {
        Console.WriteLine("====================================================");
        Console.WriteLine(testGroup);
        Console.WriteLine("====================================================");
    }
​
    public void Should(Action test, string testName)
    {
        try
        {
            Console.WriteLine(testName);
            test();
            Console.WriteLine("    Passed");
        }
        catch (Exception e)
        {
            Console.WriteLine("    Failed");
            Console.WriteLine("    " + e.Message);
        }
        finally
        {
            Console.WriteLine();
        }
    }
​
    public static void EndTests()
    {
        Console.WriteLine();
    }
}

View IL Code