using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Text;

using Xunit;

​

namespace MaxcodeSummerInternship2018

{

    /// <summary>

    /// This test has three exercises.

    /// The requirements for each of these are provided in the relevant summary section.

    /// You will need to complete classes and methods with the implementation, wherever a NotImplementedException is thrown.

    /// 

    /// The Program.Main() method checks the output of each exercise by asserting the result against the expected output. 

    /// It will throw an Assert exception if the result is not the expected one.

    /// The test cases can provide useful information.

    /// 

    /// Fork this fiddle and when you feel ready save and share the link with us.

    /// You can create a dotnetfiddle account to use its Fork and Save features of just send an email to petronela.state@maxcode.net with the implementation 

    /// </summary>

    public static class Exercises

    {

        /// <summary>

        /// Convert the casing of each word in the given phrase to camel casing. Words are delimited by whitespace and common punctuation marks.

        /// For example: ConvertPhraseToCamelCase("incepe un internship la maxcode") should return "Incepe Un Internship La Maxcode"

        /// </summary>

        /// <param name="phrase">phrase with punctuation marks that should be converted to camel case</param>

        /// <returns>camel case version of the original phrase</returns>

        public static string ConvertPhraseToCamelCase(string phrase)

        {

            throw new NotImplementedException();

        }

​

        /// <summary>

        /// Without using any repetitive language elements (do, for, while) or library functions (.Sort(), .OrderBy(), .Max() etc) implment an algorithm for finding the maximum value in an array. 

        /// For example: GetMaxWithoutLoops(new[]{ 10, 12, 14, 7, 2 }) should return 14

        /// </summary>

        /// <param name="array">array to search</param>

        /// <returns>maximum value in the given array</returns>

        public static int GetMaxWithoutLoops(int[] array)

        {

            throw new NotImplementedException();

        }

    }

​

    /// <summary>

    /// An assembly line allows putting components at the beginning and taking components from the end of it.

    /// The assembly line has a maximum capacity (number of components which it can hold)

    /// The assmebly line has a maximum weight (total weight of components on the assembly line can't exceed this value)

    /// </summary>

    public class AssemblyLine

    {

        /// <summary>

        /// Assembly line capacity and maximum weight should be configurable

        /// </summary>

        /// <param name="capacity"></param>

        /// <param name="maxWeight"></param>

        public AssemblyLine(int capacity, int maxWeight)

        {

            throw new NotImplementedException();

        }

​

        /// <summary>

        /// Add a Component at the beginning of the Assembly Line. Capacity and maximum weight mustn't be exceeded.

        /// </summary>

        /// <param name="component"></param>

        public void Put(Component component)

        {

            throw new NotImplementedException();

        }

​

        /// <summary>

        /// Remove a Component for the end of the Assembly Line. It is guaranteed that this will not work when the Assembly Line is empty.

        /// </summary>

        /// <returns></returns>

        public Component Take()

        {

            throw new NotImplementedException();

        }

​

        /// <summary>

        /// Get the current number of Component(s) on the Assembly Line

        /// </summary>

        /// <returns></returns>

        public int GetSize()

        {

            throw new NotImplementedException();

        }

​

        /// <summary>

        /// Get the weight of the Component(s) on the Assembly Line

        /// </summary>

        /// <returns></returns>

        public int GetWeight()

        {

            throw new NotImplementedException();

        }

    }

​

    /// <summary>

    /// A component which can be placed or removed from an Assembly Line.

    /// </summary>

    public class Component

    {

        public string Name { get; set; }

        public int Weight { get; set; }

    }

​

    public class Program

    {

        public static void Main(string[] args)

        {

            ExerciseConvertPhraseToCamelCase();

            Console.WriteLine("camel case works");

​

            ExerciseGetMaxWithoutLoop();

            Console.WriteLine("max works");

​

            ExerciseAssemblyLine();

            Console.WriteLine("assembly line works");

​

        }

​

        static void ExerciseConvertPhraseToCamelCase()

        {

            Assert.Equal("Salut Andrei, Ce Mai Faci?", Exercises.ConvertPhraseToCamelCase("salut andrei, ce mai faci?"));

            Assert.Equal("!Salut Andrei, Ce Mai Faci?", Exercises.ConvertPhraseToCamelCase("!salut andrei, ce mai faci?"));

            Assert.Equal(" Salut Andrei, Ce Mai Faci?", Exercises.ConvertPhraseToCamelCase(" salut andrei, ce mai faci?"));

            Assert.Equal("    Andrei, Unde,, Ai Fost Anul Trecut? Ce Orase Ai Vizitat?", Exercises.ConvertPhraseToCamelCase("    Andrei, Unde,, Ai Fost Anul Trecut? Ce Orase Ai Vizitat?"));

            Assert.Equal("    Andrei, Unde,, Ai Fost Anul Trecut? Ce Orase Ai Vizitat?", Exercises.ConvertPhraseToCamelCase("    Andrei, Unde,, Ai FoSt anUL Trecut? ce Orase Ai vizitat?"));

            Assert.Equal("!    ? + ", Exercises.ConvertPhraseToCamelCase("!    ? + "));

        }

​

        static void ExerciseGetMaxWithoutLoop()

        {

            Assert.Equal(5, Exercises.GetMaxWithoutLoops(new[] { 1, 2, 3, 4, 5 }));

            Assert.Equal(6, Exercises.GetMaxWithoutLoops(new[] { 6, 1, 2, 3, 4, 5 }));

            Assert.Equal(7, Exercises.GetMaxWithoutLoops(new[] { 7 }));

            Assert.Equal(8, Exercises.GetMaxWithoutLoops(new[] { 1, 2, 8, 4, 5 }));

            Assert.Equal(5, Exercises.GetMaxWithoutLoops(new[] { 5, 5, 5, 5, 5, 5 }));

​

        }

​

        static void ExerciseAssemblyLine()

        {

            var line = new AssemblyLine(3, 30);

            line.Put(new Component { Name = "Wrench", Weight = 14 });

            Assert.Equal(1, line.GetSize());

            Assert.Equal(14, line.GetWeight());

            line.Put(new Component { Name = "Small cog", Weight = 2 });

            Assert.Equal(2, line.GetSize());

            Assert.Equal(16, line.GetWeight());

​

            var result = Record.Exception(() => { line.Put(new Component { Name = "Cog", Weight = 35 }); });

            Assert.NotNull(result);

​

            line.Put(new Component() { Name = "Wheel", Weight = 1 });

            result = Record.Exception(() => { line.Put(new Component { Name = "Bolt", Weight = 1 }); });

            Assert.NotNull(result);

​

            line.Take();

            Assert.Equal(2, line.GetSize());

            Assert.Equal(16, line.GetWeight());

            line.Take();

            line.Take();

            Assert.Equal(0, line.GetSize());

            Assert.Equal(0, line.GetWeight());

​

            result = Record.Exception(() => line.Take());

            Assert.NotNull(result);

​

        }

    }

}

​