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();

    }

}