Maxcode Internship 2021 | C# Online Compiler

Maxcode Internship 2021 by Geta Resios

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)
    {
        throw new NotImplementedException();
    }
}
/// <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>
​
​
    public int Count(int[,] sandPile)
    {
        throw new NotImplementedException();
    }
}
/// <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();
    }
}
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​

Z
e
The first index of character e is 1
The first index of character e is 6
True
False
Z
e
t
C
o
d
e

Last Run:	5:18:41 am
Compile:	0.183s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code