[Fork] Maxcode Internship 2021 | C# Online Compiler

[Fork] Maxcode Internship 2021 by Anonymous

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 Count(int[,] sandPile)
    {
        int fallen = 0;
		Queue<(int i,int j)> positions = new Queue<(int i,int j)>();
		for(int i=0;i< sandPile.GetLength(0); i++)
			for(int j=0;j< sandPile.GetLength(1); j++)
				if(sandPile[i,j]>=4)
					positions.Enqueue((i,j));
		
		while (positions.Count >0)
		{
			var(l,c) = positions.Dequeue();
			if(sandPile[l,c]>=4) // will collapse
			{
				sandPile[l,c] = sandPile[l,c] -4;
				if(sandPile[l,c]>=4) // if it still has the possibility of collapse, we retain the positions again
					positions.Enqueue((l,c));
				if(l-1>=0){ //check the neighbouring
					sandPile[l-1,c] ++;
					if(sandPile[l-1,c]>=4){
						positions.Enqueue((l-1,c));
					}
				}else{
					fallen++;
				}
				if(c-1>=0){ //check the neighbouring
					sandPile[l,c-1] ++;
					if(sandPile[l,c-1]>=4){
						positions.Enqueue((l,c-1));
					}
				}else{
					fallen++;
				}
				if(l+1< sandPile.GetLength(0)){
					sandPile[l+1,c] ++;
					if(sandPile[l+1,c]>=4){
						positions.Enqueue((l+1,c));
					}
				}else{
					fallen++;
				}
				if(c+1< sandPile.GetLength(1)){
					sandPile[l,c+1] ++;
					if(sandPile[l,c+1]>=4){
						positions.Enqueue((l,c+1));
					}
				}else{
					fallen++;
				}
			}
		}
		return fallen;
    }
}
/// <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>
	private int[,] inventory; 
	
    public int CheckInventory(IEnumerable<string> transactions, string person, string productType)
    {
        int n,m;
		n = _people.Length;
		m = _productTypes.Length;
		inventory = new int[n,m];
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
				inventory[i,j]=_initialInventory;
		int product;
		int transactNo = transactions.Count();
		seller = GetSellerIndex(transactions.ElementAt(i));
        buyer = GetBuyerIndex(transactions.ElementAt(i));
		String str=transactions.ElementAt(i);
		int amount = 0;
        for (int i = 0; i < str.Length; i++)
            if (Char.IsDigit(str[i]))
                amount = amount * 10 + (int)Char.GetNumericValue(str[i]);
		for (int i = 0; i < _productTypes.Length; i++)
				if (str.IndexOf(_productTypes[i]) != -1)
						product=i;
		if(inventory[seller,product]-amount>=0){
				inventory[seller,product] -= amount;
				inventory[butyer,product] += amount;
		}

		//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>
​
​
    public int Count(int[,] sandPile)
    {
        int fallen = 0;
        Queue<(int i,int j)> positions = new Queue<(int i,int j)>();
        for(int i=0;i< sandPile.GetLength(0); i++)
            for(int j=0;j< sandPile.GetLength(1); j++)
                if(sandPile[i,j]>=4)
                    positions.Enqueue((i,j));
        
        while (positions.Count >0)
        {
            var(l,c) = positions.Dequeue();
            if(sandPile[l,c]>=4) // will collapse
            {
                sandPile[l,c] = sandPile[l,c] -4;
                if(sandPile[l,c]>=4) // if it still has the possibility of collapse, we retain the positions again
                    positions.Enqueue((l,c));
                if(l-1>=0){ //check the neighbouring
                    sandPile[l-1,c] ++;
                    if(sandPile[l-1,c]>=4){
                        positions.Enqueue((l-1,c));
                    }
                }else{
                    fallen++;
                }
                if(c-1>=0){ //check the neighbouring
                    sandPile[l,c-1] ++;
                    if(sandPile[l,c-1]>=4){
                        positions.Enqueue((l,c-1));
                    }
                }else{
                    fallen++;
                }
                if(l+1< sandPile.GetLength(0)){
                    sandPile[l+1,c] ++;
                    if(sandPile[l+1,c]>=4){
                        positions.Enqueue((l+1,c));
                    }
                }else{
                    fallen++;
                }
                if(c+1< sandPile.GetLength(1)){
                    sandPile[l,c+1] ++;
                    if(sandPile[l,c+1]>=4){
                        positions.Enqueue((l,c+1));
                    }
                }else{
                    fallen++;
                }
            }
        }
        return fallen;
    }
}
/// <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>
    private int[,] inventory; 
    
    public int CheckInventory(IEnumerable<string> transactions, string person, string productType)
    {
        int n,m;
        n = _people.Length;
        m = _productTypes.Length;
        inventory = new int[n,m];
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                inventory[i,j]=_initialInventory;
        int product;
        int transactNo = transactions.Count();
        seller = GetSellerIndex(transactions.ElementAt(i));
        buyer = GetBuyerIndex(transactions.ElementAt(i));
        String str=transactions.ElementAt(i);
        int amount = 0;
        for (int i = 0; i < str.Length; i++)
            if (Char.IsDigit(str[i]))
                amount = amount * 10 + (int)Char.GetNumericValue(str[i]);
        for (int i = 0; i < _productTypes.Length; i++)
                if (str.IndexOf(_productTypes[i]) != -1)
                        product=i;
        if(inventory[seller,product]-amount>=0){
                inventory[seller,product] -= amount;
                inventory[butyer,product] += amount;
        }
​
        //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();
    }
}
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​

Last Run:	8:28:26 am
Compile:	0.276s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code