[Fork] Maxcode Internship 2021 | C# Online Compiler

[Fork] Maxcode Internship 2021 by Bujor Bogdan

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>

	private (int, int) Position(int[,] sandPile)
	{
		int i=0,j=0;
		for (i=0;i<sandPile.GetLength(0);i++)
		{
			for (j=0;j<sandPile.GetLength(1);j++)
				if(sandPile[i,j]>3)
					return (i,j);
		}
		return (-1,-1);
	}
	
	private bool ExistMoreThan3Grains(int[,] sandPile)
	{
		for (int i=0;i<sandPile.GetLength(0);i++)
		{
			for (int j=0;j<sandPile.GetLength(1);j++)
				if(sandPile[i,j]>3)
					return true;
		}
		return false;
	}

    public int Count(int[,] sandPile)
    {
		int count = 0;
		while(ExistMoreThan3Grains(sandPile))
		{
			(int i,int j) position = Position(sandPile);
			if(position.i==0 && position.j==0)
			{
				count = count + 2;
				sandPile[0,1]++;
				sandPile[1,0]++;
				sandPile[position.i,position.j] -= 4;
			}
			else if(position.i==0 && position.j==sandPile.GetLength(1)-1)
			{
				count = count + 2;
				sandPile[0,sandPile.GetLength(1)-2]++;
				sandPile[1,sandPile.GetLength(1)-1]++;
				sandPile[position.i,position.j] -= 4;
			}
			else if(position.i==0)
			{
				count++;
				sandPile[0,position.j-1]++;
				sandPile[0,position.j+1]++;
				sandPile[1,position.j]++;
				sandPile[position.i,position.j] -= 4;
			}
			else if(position.i==sandPile.GetLength(0)-1 && position.j==0)
			{
				count = count + 2;
				sandPile[sandPile.GetLength(0)-2,0]++;
				sandPile[sandPile.GetLength(0)-1,1]++;
				sandPile[position.i,position.j] -= 4;
			}
			else if(position.i== sandPile.GetLength(0)-1 && position.j==sandPile.GetLength(1)-1)
			{
				count = count + 2;
				sandPile[sandPile.GetLength(0)-2,sandPile.GetLength(1)-1]++;
				sandPile[sandPile.GetLength(0)-1,sandPile.GetLength(1)-2]++;
				sandPile[position.i,position.j] -= 4;
			}
			else if(position.i== sandPile.GetLength(0)-1)
			{
				count ++;
				sandPile[position.i,position.j-1]++;
				sandPile[position.i,position.j+1]++;
				sandPile[position.i-1,position.j]++;
				sandPile[position.i,position.j] -= 4;
			}
			else if(position.j==0)
			{
				count ++;
				sandPile[position.i-1,0]++;
				sandPile[position.i+1,0]++;
				sandPile[position.i,1]++;
				sandPile[position.i,position.j] -= 4;
			}
			else if(position.j==sandPile.GetLength(1)-1)
			{
				count ++;
				sandPile[position.i-1,position.j]++;
				sandPile[position.i+1,position.j]++;
				sandPile[position.i,position.j-1]++;
				sandPile[position.i,position.j] -= 4;
			}
			else
			{
				sandPile[position.i,position.j-1]++;
				sandPile[position.i,position.j+1]++;
				sandPile[position.i-1,position.j]++;
				sandPile[position.i+1,position.j]++;
				sandPile[position.i,position.j] -= 4;
			}
		}
		return count;
    }
}
/// <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)
    {
        throw new NotImplementedException();
    }
}


/// <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>
​
    private (int, int) Position(int[,] sandPile)
    {
        int i=0,j=0;
        for (i=0;i<sandPile.GetLength(0);i++)
        {
            for (j=0;j<sandPile.GetLength(1);j++)
                if(sandPile[i,j]>3)
                    return (i,j);
        }
        return (-1,-1);
    }
    
    private bool ExistMoreThan3Grains(int[,] sandPile)
    {
        for (int i=0;i<sandPile.GetLength(0);i++)
        {
            for (int j=0;j<sandPile.GetLength(1);j++)
                if(sandPile[i,j]>3)
                    return true;
        }
        return false;
    }
​
    public int Count(int[,] sandPile)
    {
        int count = 0;
        while(ExistMoreThan3Grains(sandPile))
        {
            (int i,int j) position = Position(sandPile);
            if(position.i==0 && position.j==0)
            {
                count = count + 2;
                sandPile[0,1]++;
                sandPile[1,0]++;
                sandPile[position.i,position.j] -= 4;
            }
            else if(position.i==0 && position.j==sandPile.GetLength(1)-1)
            {
                count = count + 2;
                sandPile[0,sandPile.GetLength(1)-2]++;
                sandPile[1,sandPile.GetLength(1)-1]++;
                sandPile[position.i,position.j] -= 4;
            }
            else if(position.i==0)
            {
                count++;
                sandPile[0,position.j-1]++;
                sandPile[0,position.j+1]++;
                sandPile[1,position.j]++;
                sandPile[position.i,position.j] -= 4;
            }
            else if(position.i==sandPile.GetLength(0)-1 && position.j==0)
            {
                count = count + 2;
                sandPile[sandPile.GetLength(0)-2,0]++;
                sandPile[sandPile.GetLength(0)-1,1]++;
                sandPile[position.i,position.j] -= 4;
            }
            else if(position.i== sandPile.GetLength(0)-1 && position.j==sandPile.GetLength(1)-1)
            {
                count = count + 2;
                sandPile[sandPile.GetLength(0)-2,sandPile.GetLength(1)-1]++;
                sandPile[sandPile.GetLength(0)-1,sandPile.GetLength(1)-2]++;
                sandPile[position.i,position.j] -= 4;
            }
            else if(position.i== sandPile.GetLength(0)-1)
            {
                count ++;
                sandPile[position.i,position.j-1]++;
                sandPile[position.i,position.j+1]++;
                sandPile[position.i-1,position.j]++;
                sandPile[position.i,position.j] -= 4;
            }
            else if(position.j==0)
            {
                count ++;
                sandPile[position.i-1,0]++;
                sandPile[position.i+1,0]++;
                sandPile[position.i,1]++;
                sandPile[position.i,position.j] -= 4;
            }
            else if(position.j==sandPile.GetLength(1)-1)
            {
                count ++;
                sandPile[position.i-1,position.j]++;
                sandPile[position.i+1,position.j]++;
                sandPile[position.i,position.j-1]++;
                sandPile[position.i,position.j] -= 4;
            }
            else
            {
                sandPile[position.i,position.j-1]++;
                sandPile[position.i,position.j+1]++;
                sandPile[position.i-1,position.j]++;
                sandPile[position.i+1,position.j]++;
                sandPile[position.i,position.j] -= 4;
            }
        }
        return count;
    }
}
/// <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)
    {
        throw new NotImplementedException();
    }
}
​
​
/// <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();
    }
}
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​

====================================================
WastedSandCounter should
====================================================
not count sand that falls on the table
    Passed

count sand that falls off the table
    Passed

fully collapse tall piles of the sand
    Passed

====================================================
Marketplace should
====================================================
not do transactions that are invalid
    Failed
    The method or operation is not implemented.

do transactions that are invalid
    Failed
    The method or operation is not implemented.

Cached Result
Last Run:	4:23:06 am
Compile:	0.028s
Execute:	0.06s
Memory:	4.72Mb
CPU:	0.088s

View IL Code