[Fork] MaxcodeInternship2022Summer_Update | C# Online Compiler

[Fork] MaxcodeInternship2022Summer_Update by Daniel Ciortescu

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

/// <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 made no changes and there are build errors, send an email to us.
///
/// 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 make sure the following is true:
/// - Your code is compilable
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>

/// <summary>
/// An ATM machine starts with an initial amount of money. 
/// The money available in the ATM is provided as a dictionary where 
/// every key is the denomination and the associated value represents the amount available for that denomination.
/// 
/// For example, given the input:
///     { ( 1, 3 ), ( 5, 2 ), ( 10, 4 ) }
/// The ATM machine will contain:
///     - 3 bills of 1 RON
///     - 2 bills of 5 RON
///     - 4 bills of 10 RON
///     
/// The ATM Machine allows people to withdraw money multiple times, by calling the <see cref="Withdraw(int)"/>
/// </summary>
public class AtmMachine
{
    private Dictionary<int, int> _amounts;

    public AtmMachine(Dictionary<int, int> amounts)
    {
        this._amounts = amounts;
    }

    /// <summary>
    /// By using the <see cref="Withdraw(int)"/> method, people can attempt to withdraw money.
    /// If the amount is not available in the ATM, the person must receive an empty `List<Tuple<int, int>>`
    /// If the amount is available in the ATM, the person will receive a `List<Tuple<int, int>>` representing all the denominations and units they receive.
    /// For instance:
    ///     Given the ATM has an initial balance of 
    ///         { { 1, 10 }, { 5, 10 }, { 10, 10 } }
    ///     When attempting to withdraw 
    ///         27 RON
    ///     Then the method could return(*)
    ///         { (10, 2), (5, 1), (1, 2) }
    ///     Which means
    ///         - 2 bills of 10 RON
    ///         - 1 bill of 5 RON
    ///         - 2 bills of 1 RON
    /// 
    /// (*)Note: other variations are also acceptable. 
    /// </summary>
    public List<Tuple<int, int>> Withdraw(int amount)
    {
        var tupleList = new List<Tuple<int, int>>();
        Dictionary<int, int> RestulDeBancnoteRamase = new Dictionary<int, int>();
        Dictionary<int, int> RestulDeBancnoteRamaseSortate = new Dictionary<int, int>();
        var tupleListNull = new List<Tuple<int, int>>();
        int AuxAmount = amount;

        int a = this._amounts.Count - 1;
        int Bancnota;
        int NrDeBancnote = 0;

        if (amount > 0)
        {

            while (a != -1)
            {
                KeyValuePair<int, int> myEl = this._amounts.ElementAt(a);
                Bancnota = myEl.Key;
                NrDeBancnote = 0;

                if (AuxAmount > 0)
                {
                    int NumarulDeBancnote = myEl.Value;
                    while (AuxAmount >= myEl.Key && NumarulDeBancnote != 0)
                    {
                        AuxAmount = AuxAmount - myEl.Key;
                        NumarulDeBancnote = NumarulDeBancnote - 1;
                        NrDeBancnote = NrDeBancnote + 1;
                    }
                }
                a = a - 1;
                tupleList.Add(new Tuple<int, int>(Bancnota, NrDeBancnote));
                RestulDeBancnoteRamase.Add(myEl.Key, myEl.Value - NrDeBancnote);
            }
            foreach (var item in RestulDeBancnoteRamase.OrderBy(x => x.Key))
            {
                RestulDeBancnoteRamaseSortate.Add(item.Key, item.Value);
            }

        }
        if (AuxAmount != 0)
        {
            tupleList = tupleListNull;
        }
        else
        {
            this._amounts = RestulDeBancnoteRamaseSortate;
        }
        return tupleList;
    }
}


/// <summary>
/// Version numbers consist of one or more revisions joined by a dot '.'
/// Each revision consists of digits and may contain leading zeros.
/// Every revision contains at least one character.
/// Revisions are 0-indexed from left to right. The leftmost revision is revision 0, the next - revision 1, and so on.
/// For example 3.44.2 and 0.1 are valid version numbers.
/// </summary>
public class VersionComparer
{
    /// <summary>
    /// Compare the provided version strings.
    /// To compare version numbers, compare their revisions in left-to-right order.
    /// Revisions are compared using their integer value, ignoring any leading zeros (revision 1 and 0001 are equal).
    /// If a version number doesn't specify a revision at an index, the revision should be treated as 0.
    /// For example, comparing 'version 1.0' and 'version 1.1' should return that `version 1.1` is greater than `version 1.0`
    /// </summary>
    /// <returns>
    ///  1 when `versionOne` > `versionTwo`
    ///  0 when `versionOne` == `versionTwo`
    /// -1 when `versionOne` < `versionTwo`
    /// </returns>
    public int Compare(string versionOne, string versionTwo)
    {
        string[] numbersOfVersionOne = versionOne.Split('.');
        string[] numbersOfVersionTwo = versionTwo.Split('.');

        for (int i = 0; i < numbersOfVersionOne.Length && i < numbersOfVersionTwo.Length; i++)
        {
            while (numbersOfVersionOne[i][0] == '0' && numbersOfVersionOne[i].Length > 1)
            {
                numbersOfVersionOne[i] = numbersOfVersionOne[i].Remove(0, 1);
            }

            while (numbersOfVersionTwo[i][0] == '0' && numbersOfVersionTwo[i].Length > 1)
            {
                numbersOfVersionTwo[i] = numbersOfVersionTwo[i].Remove(0, 1);
            }

            while (numbersOfVersionOne[i].Length != numbersOfVersionTwo[i].Length)
            {
                if (numbersOfVersionOne[i].Length < numbersOfVersionTwo[i].Length)
                {
                    numbersOfVersionOne[i] = numbersOfVersionOne[i].Insert(numbersOfVersionOne[i].Length, "0");
                }
                else if (numbersOfVersionOne[i].Length > numbersOfVersionTwo[i].Length)
                {
                    numbersOfVersionTwo[i] = numbersOfVersionTwo[i].Insert(numbersOfVersionTwo[i].Length, "0");
                }
            }
            if (Int32.Parse(numbersOfVersionOne[i]) > Int32.Parse(numbersOfVersionTwo[i]))
            {
                return 1;
            }
            else if (Int32.Parse(numbersOfVersionOne[i]) < Int32.Parse(numbersOfVersionTwo[i]))
            {
                return -1;
            }
        }
        return 0;
    }
}


/// <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 AtmMachineTests().Start();
        new VersionComparerTests().Start();
    }
}



public class AtmMachineTests
{
    public void Start()
    {
        Tests.Run($"{nameof(AtmMachine)} should", (it) =>
        {
            it.Should(() => NotProcessNegativeValues(), "Not process negative values");
            it.Should(() => ReturnMultipleDenominationAmounts(), "Return multiple denomination amounts");
            it.Should(() => NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount(), "Not process witdrawals greater than inventory");
            it.Should(() => ReturnAllAvailableMoney(), "Return all available money");
            it.Should(() => KeepStateBetweenWithdrawals(), "Keep state between withdrawals");
            it.Should(() => NotChangeStateIfWithdrawalIsntSuccessful(), "Not change state if withdrawal isn't successful");
        });
    }

    private int CountMoney(List<Tuple<int, int>> amounts) => amounts.Aggregate(0, (a, i) => a + i.Item1 * i.Item2);

    public void NotChangeStateIfWithdrawalIsntSuccessful()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 }, { 10, 5 } });

        var r1 = atm.Withdraw(50);
        CountMoney(r1).ShouldBe(50);

        var r2 = atm.Withdraw(50);
        CountMoney(r2).ShouldBe(0);

        var r3 = atm.Withdraw(20);
        CountMoney(r3).ShouldBe(20);
    }

    public void NotProcessNegativeValues()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 } });
        var result = atm.Withdraw(-5);
        CountMoney(result).ShouldBe(0);
    }

    public void KeepStateBetweenWithdrawals()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 } });
        var r1 = atm.Withdraw(5);
        CountMoney(r1).ShouldBe(5);
        var r2 = atm.Withdraw(26);
        CountMoney(r2).ShouldBe(0);
    }

    public void ReturnAllAvailableMoney()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8660);
        var sum = CountMoney(result);
        sum.ShouldBe(8660);
    }

    public void ReturnMultipleDenominationAmounts()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 } });
        var result = atm.Withdraw(87);
        CountMoney(result).ShouldBe(87);
    }

    public void NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8661);
        CountMoney(result).ShouldBe(0);
    }
}

/// <summary>
/// This class contains the unit tests for the MaxcodeLatinTranslator exercise
/// </summary>
public class VersionComparerTests
{
    public void Start()
    {
        Tests.Run("VersionComparer should", (it) =>
        {
            it.Should(() => CompareEqualVersions(), "Compare equal versions");
            it.Should(() => CompareDifferentVersions(), "Compare different versions");
        });
    }

    public void CompareEqualVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("0", "0.0.0").ShouldBe(0);
        comparer.Compare("0.01", "0.1").ShouldBe(0);
        comparer.Compare("1.001", "1.1").ShouldBe(0);
        comparer.Compare("7.015.84", "7.15.84").ShouldBe(0);
        comparer.Compare("7.1", "7.1.0.0").ShouldBe(0);
    }

    public void CompareDifferentVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("01.0.1", "1.1.0").ShouldBe(-1);
        comparer.Compare("33.1", "33.0.5").ShouldBe(1);
        comparer.Compare("7.0105.84", "7.15.84").ShouldBe(-1);
    }
}


/// <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;
using System.Linq;
​
/// <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 made no changes and there are build errors, send an email to us.
///
/// 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 make sure the following is true:
/// - Your code is compilable
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>
​
/// <summary>
/// An ATM machine starts with an initial amount of money. 
/// The money available in the ATM is provided as a dictionary where 
/// every key is the denomination and the associated value represents the amount available for that denomination.
/// 
/// For example, given the input:
///     { ( 1, 3 ), ( 5, 2 ), ( 10, 4 ) }
/// The ATM machine will contain:
///     - 3 bills of 1 RON
///     - 2 bills of 5 RON
///     - 4 bills of 10 RON
///     
/// The ATM Machine allows people to withdraw money multiple times, by calling the <see cref="Withdraw(int)"/>
/// </summary>
public class AtmMachine
{
    private Dictionary<int, int> _amounts;
​
    public AtmMachine(Dictionary<int, int> amounts)
    {
        this._amounts = amounts;
    }
​
    /// <summary>
    /// By using the <see cref="Withdraw(int)"/> method, people can attempt to withdraw money.
    /// If the amount is not available in the ATM, the person must receive an empty `List<Tuple<int, int>>`
    /// If the amount is available in the ATM, the person will receive a `List<Tuple<int, int>>` representing all the denominations and units they receive.
    /// For instance:
    ///     Given the ATM has an initial balance of 
    ///         { { 1, 10 }, { 5, 10 }, { 10, 10 } }
    ///     When attempting to withdraw 
    ///         27 RON
    ///     Then the method could return(*)
    ///         { (10, 2), (5, 1), (1, 2) }
    ///     Which means
    ///         - 2 bills of 10 RON
    ///         - 1 bill of 5 RON
    ///         - 2 bills of 1 RON
    /// 
    /// (*)Note: other variations are also acceptable. 
    /// </summary>
    public List<Tuple<int, int>> Withdraw(int amount)
    {
        var tupleList = new List<Tuple<int, int>>();
        Dictionary<int, int> RestulDeBancnoteRamase = new Dictionary<int, int>();
        Dictionary<int, int> RestulDeBancnoteRamaseSortate = new Dictionary<int, int>();
        var tupleListNull = new List<Tuple<int, int>>();
        int AuxAmount = amount;
​
        int a = this._amounts.Count - 1;
        int Bancnota;
        int NrDeBancnote = 0;
​
        if (amount > 0)
        {
​
            while (a != -1)
            {
                KeyValuePair<int, int> myEl = this._amounts.ElementAt(a);
                Bancnota = myEl.Key;
                NrDeBancnote = 0;
​
                if (AuxAmount > 0)
                {
                    int NumarulDeBancnote = myEl.Value;
                    while (AuxAmount >= myEl.Key && NumarulDeBancnote != 0)
                    {
                        AuxAmount = AuxAmount - myEl.Key;
                        NumarulDeBancnote = NumarulDeBancnote - 1;
                        NrDeBancnote = NrDeBancnote + 1;
                    }
                }
                a = a - 1;
                tupleList.Add(new Tuple<int, int>(Bancnota, NrDeBancnote));
                RestulDeBancnoteRamase.Add(myEl.Key, myEl.Value - NrDeBancnote);
            }
            foreach (var item in RestulDeBancnoteRamase.OrderBy(x => x.Key))
            {
                RestulDeBancnoteRamaseSortate.Add(item.Key, item.Value);
            }
​
        }
        if (AuxAmount != 0)
        {
            tupleList = tupleListNull;
        }
        else
        {
            this._amounts = RestulDeBancnoteRamaseSortate;
        }
        return tupleList;
    }
}
​
​
/// <summary>
/// Version numbers consist of one or more revisions joined by a dot '.'
/// Each revision consists of digits and may contain leading zeros.
/// Every revision contains at least one character.
/// Revisions are 0-indexed from left to right. The leftmost revision is revision 0, the next - revision 1, and so on.
/// For example 3.44.2 and 0.1 are valid version numbers.
/// </summary>
public class VersionComparer
{
    /// <summary>
    /// Compare the provided version strings.
    /// To compare version numbers, compare their revisions in left-to-right order.
    /// Revisions are compared using their integer value, ignoring any leading zeros (revision 1 and 0001 are equal).
    /// If a version number doesn't specify a revision at an index, the revision should be treated as 0.
    /// For example, comparing 'version 1.0' and 'version 1.1' should return that `version 1.1` is greater than `version 1.0`
    /// </summary>
    /// <returns>
    ///  1 when `versionOne` > `versionTwo`
    ///  0 when `versionOne` == `versionTwo`
    /// -1 when `versionOne` < `versionTwo`
    /// </returns>
    public int Compare(string versionOne, string versionTwo)
    {
        string[] numbersOfVersionOne = versionOne.Split('.');
        string[] numbersOfVersionTwo = versionTwo.Split('.');
​
        for (int i = 0; i < numbersOfVersionOne.Length && i < numbersOfVersionTwo.Length; i++)
        {
            while (numbersOfVersionOne[i][0] == '0' && numbersOfVersionOne[i].Length > 1)
            {
                numbersOfVersionOne[i] = numbersOfVersionOne[i].Remove(0, 1);
            }
​
            while (numbersOfVersionTwo[i][0] == '0' && numbersOfVersionTwo[i].Length > 1)
            {
                numbersOfVersionTwo[i] = numbersOfVersionTwo[i].Remove(0, 1);
            }
​
            while (numbersOfVersionOne[i].Length != numbersOfVersionTwo[i].Length)
            {
                if (numbersOfVersionOne[i].Length < numbersOfVersionTwo[i].Length)
                {
                    numbersOfVersionOne[i] = numbersOfVersionOne[i].Insert(numbersOfVersionOne[i].Length, "0");
                }
                else if (numbersOfVersionOne[i].Length > numbersOfVersionTwo[i].Length)
                {
                    numbersOfVersionTwo[i] = numbersOfVersionTwo[i].Insert(numbersOfVersionTwo[i].Length, "0");
                }
            }
            if (Int32.Parse(numbersOfVersionOne[i]) > Int32.Parse(numbersOfVersionTwo[i]))
            {
                return 1;
            }
            else if (Int32.Parse(numbersOfVersionOne[i]) < Int32.Parse(numbersOfVersionTwo[i]))
            {
                return -1;
            }
        }
        return 0;
    }
}
​
​
/// <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 AtmMachineTests().Start();
        new VersionComparerTests().Start();
    }
}
​
​
​
public class AtmMachineTests
{
    public void Start()
    {
        Tests.Run($"{nameof(AtmMachine)} should", (it) =>
        {
            it.Should(() => NotProcessNegativeValues(), "Not process negative values");
            it.Should(() => ReturnMultipleDenominationAmounts(), "Return multiple denomination amounts");
            it.Should(() => NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount(), "Not process witdrawals greater than inventory");
            it.Should(() => ReturnAllAvailableMoney(), "Return all available money");
            it.Should(() => KeepStateBetweenWithdrawals(), "Keep state between withdrawals");
            it.Should(() => NotChangeStateIfWithdrawalIsntSuccessful(), "Not change state if withdrawal isn't successful");
        });
    }
​
    private int CountMoney(List<Tuple<int, int>> amounts) => amounts.Aggregate(0, (a, i) => a + i.Item1 * i.Item2);
​
    public void NotChangeStateIfWithdrawalIsntSuccessful()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 }, { 10, 5 } });
​
        var r1 = atm.Withdraw(50);
        CountMoney(r1).ShouldBe(50);
​
        var r2 = atm.Withdraw(50);
        CountMoney(r2).ShouldBe(0);
​
        var r3 = atm.Withdraw(20);
        CountMoney(r3).ShouldBe(20);
    }
​
    public void NotProcessNegativeValues()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 } });
        var result = atm.Withdraw(-5);
        CountMoney(result).ShouldBe(0);
    }
​
    public void KeepStateBetweenWithdrawals()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 } });
        var r1 = atm.Withdraw(5);
        CountMoney(r1).ShouldBe(5);
        var r2 = atm.Withdraw(26);
        CountMoney(r2).ShouldBe(0);
    }
​
    public void ReturnAllAvailableMoney()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8660);
        var sum = CountMoney(result);
        sum.ShouldBe(8660);
    }
​
    public void ReturnMultipleDenominationAmounts()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 } });
        var result = atm.Withdraw(87);
        CountMoney(result).ShouldBe(87);
    }
​
    public void NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8661);
        CountMoney(result).ShouldBe(0);
    }
}
​
/// <summary>
/// This class contains the unit tests for the MaxcodeLatinTranslator exercise
/// </summary>
public class VersionComparerTests
{
    public void Start()
    {
        Tests.Run("VersionComparer should", (it) =>
        {
            it.Should(() => CompareEqualVersions(), "Compare equal versions");
            it.Should(() => CompareDifferentVersions(), "Compare different versions");
        });
    }
​
    public void CompareEqualVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("0", "0.0.0").ShouldBe(0);
        comparer.Compare("0.01", "0.1").ShouldBe(0);
        comparer.Compare("1.001", "1.1").ShouldBe(0);
        comparer.Compare("7.015.84", "7.15.84").ShouldBe(0);
        comparer.Compare("7.1", "7.1.0.0").ShouldBe(0);
    }
​
    public void CompareDifferentVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("01.0.1", "1.1.0").ShouldBe(-1);
        comparer.Compare("33.1", "33.0.5").ShouldBe(1);
        comparer.Compare("7.0105.84", "7.15.84").ShouldBe(-1);
    }
}
​
​
/// <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();
    }
}

Total marbles: 512
Working set has 25 marbles with [red] as a characteristic
Working set has 29 marbles with [sticky] as a characteristic
Working set has 31 marbles with [smelly] as a characteristic
Working set has 33 marbles with [brass] as a characteristic
Working set has 27 marbles with [hollow] as a characteristic
Working set has 28 marbles with [jingly] as a characteristic
Working set has 29 marbles with [heated] as a characteristic
Working set has 38 marbles with [sweet] as a characteristic
Working set has 23 marbles with [forbidden] as a characteristic
Working set has 487 marbles with [not red] as a characteristic
Working set has 483 marbles with [not sticky] as a characteristic
Working set has 481 marbles with [not smelly] as a characteristic
Working set has 479 marbles with [not brass] as a characteristic
Working set has 485 marbles with [not hollow] as a characteristic
Working set has 484 marbles with [not jingly] as a characteristic
Working set has 483 marbles with [not heated] as a characteristic
Working set has 474 marbles with [not sweet] as a characteristic
Working set has 489 marbles with [not forbidden] as a characteristic
Made 5120 selections
Selected 250 marbles with red - expected 250
Selected 295 marbles with sticky - expected 290
Selected 301 marbles with smelly - expected 310
Selected 294 marbles with brass - expected 330 -> This was underrepresented by 10.909096%
Selected 259 marbles with hollow - expected 270
Selected 274 marbles with jingly - expected 280
Selected 306 marbles with heated - expected 290 -> This was overrepresented by 5.5172424%
Selected 353 marbles with sweet - expected 380 -> This was underrepresented by 7.1052628%
Selected 225 marbles with forbidden - expected 230

Cached Result
Last Run:	8:43:33 pm
Compile:	0.016s
Execute:	0.07s
Memory:	4.77Mb
CPU:	0.086s

View IL Code