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> EX1

/// 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>

//am rezolvat in java, am scris mai jos

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)

    {

        throw new NotImplementedException();

    }

}

//am rezolvat problema in java pentru ca inca nu stiu c#, dar voi invata

//aici

import java.net.Inet4Address;

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.stream.Collectors;

import java.util.stream.Stream;

​

public class AtmMachine {

    private Map<Integer,Integer> amounts;

    public AtmMachine(Map<Integer,Integer> a){

​

        this.amounts=a;

    }

​

    public Integer totalSumOfAtm(){

        Integer sum=0;

        for (Map.Entry<Integer,Integer> entry : amounts.entrySet()){

            sum+= entry.getKey()*entry.getValue();

        }

        return sum;

    }

​

    public Map<Integer,Integer> Withdraw(int amount){

        if(amount>totalSumOfAtm() || amount<=0){

            return Collections.emptyMap();

        }

​

        Map<Integer,Integer> result = new HashMap<>();

​

        Stream<Map.Entry<Integer,Integer>> sortedMap = amounts.entrySet()

                                                            .stream()

                                                            .sorted(Collections.reverseOrder(Map.Entry.comparingByKey()));

​

        Map<Integer,Integer> amountsSorted =  sortedMap.collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue, (e1,e2)->e1, LinkedHashMap::new));

​

        for (Map.Entry<Integer,Integer> entry : amountsSorted.entrySet()){

            //entry.key este bancnota si entry.value este nr de bancnote

            Integer nrBills=entry.getValue();

            Integer added = 0;

            while(entry.getKey()<=amount && nrBills>0 && amount>0){

                amount-=entry.getKey();

                added++;

                nrBills--;

                entry.setValue(nrBills);

            }

            if(added>0){

                result.put(entry.getKey(),added);

            }

        }

        if(amount!=0){

            return Collections.emptyMap();

        }

        return result;

    }

}

//testat in main:

import java.util.HashMap;

import java.util.Map;

​

public class Main {

    public static void main(String[] args) {

        Map<Integer,Integer> map = new HashMap<>();

        map.put(1,10); map.put(5,10); map.put(10,10);

​

        AtmMachine a = new AtmMachine(map);

​

        System.out.println(a.totalSumOfAtm());

        Map<Integer,Integer> result =  a.Withdraw(27);

        for (Map.Entry<Integer,Integer> entry : result.entrySet()){

            System.out.println(entry.getKey()+" "+ entry.getValue());

        }

    }

}

//-------------------------------

​

/// <summary> EX 2

/// 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)

    {

        throw new NotImplementedException();

    }

​

}

//rezolvare java: 

public class VersionComparer {

    String s1;

    String s2;

    public VersionComparer(String s1,String s2){

        this.s1=processedString(s1);

        this.s2=processedString(s2);

    }

    public String processedString(String s){

        StringBuilder result = new StringBuilder();

        if(s.contains("0")){

​

            for(Integer i = 0; i<s.length();i++){

                if(s.charAt(i)!='0'){

                    result.append(s.charAt(i));

                }

            }

        }

        if(!s.contains(".")){

            for(Integer i = 0; i<s.length();i++){

                result.append(s.charAt(i));

            }

            result.append(".0");

        }

        return result.toString();

    }

​

    public boolean containsDigits(String s){

        return(s.contains("1") || s.contains("2")|| s.contains("3") || s.contains("4") || s.contains("5") ||

                s.contains("6") || s.contains("7") || s.contains("8") || s.contains("9") );

    }

​

    public int compare(String versionOne,String versionTwo){

        if(versionOne.equals(versionTwo)) return 0;

​

        if(!containsDigits(versionOne) && !containsDigits(versionTwo) ) return 0;

        Integer minLength = versionOne.length()<versionTwo.length() ? versionOne.length() : versionTwo.length();

​

        for(Integer index=0;index<minLength;index++){

            if(versionOne.charAt(index)!=versionTwo.charAt(index)){

                return Character.compare(versionOne.charAt(index),versionTwo.charAt(index));

            }

        }

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

    }

}