using System;

using System.Collections.Generic;

using System.Linq;

using Xunit;

​

namespace MaxcodeInternshipSpring2018

{

    /// <summary>

    /// This test has three exercises.

    /// The requirements are described in the relevant summary section of each method or class.

    /// You will need to complete the classes with the implementation.

    /// 

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

    /// 

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

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

    /// </summary>

    public static class Exercises

    {

        /// <summary>

        /// Given a list and a target sum, returns zero-based indices of any two distinct elements 

        /// whose sum is equal to the target sum. If there are no such elements, the function should return null.       

        /// </summary>

        /// <example>

        /// For example, FindTwoSum(new List<int>() { 1, 3, 5, 7, 9 }, 12) should return any of the following tuples of indices:

        /// - 1, 4 (3 + 9 = 12),

        /// - 2, 3 (5 + 7 = 12),

        /// - 3, 2 (7 + 5 = 12) or

        /// - 4, 1 (9 + 3 = 12).

        /// </example>

        /// <param name="elements">source list</param>

        /// <param name="sum">target sum</param>

        /// <returns>A pair containing the elements that matches the criteria.</returns>

        public static Tuple<int, int> FindForSum(List<int> elements, int sum)

        {

            return Tuple.Create(0, 0);

        }

​

        /// <summary>

        /// Finds the zero-based index of the longest run in a string. 

        /// A run is a consecutive sequence of the same character. If there is more than one run with the same length, 

        /// it will return the index of the first one.        

        /// </summary>

        /// <example>

        /// IndexOfLongestRun("abbcccddddcccbba") should return 6 as the longest run is dddd and it first appears on index 6.        

        /// </example>

        /// <param name="source">source string to check the longest run</param>        

        /// <returns></returns>

        public static int IndexOfLongestRun(string source)

        {

            return 0;

        }

​

​

        /// <summary>

        /// Implement a simple stack that accepts the following commands and performs the operations associated with them:

        /// </summary>

        public class MaxcodeStack

        {

            /// <summary>

            /// Push maxcoder onto the top of stack

            /// </summary>

            /// <param name="maxcoder">maxcoder to push</param>

            public void Push(Maxcoder maxcoder)

            {                

            }

​

            /// <summary>

            /// Pop the top element from the MaxcodeStack. It is guaranteed that this will not be called on an empty stack.

            /// </summary>

            /// <returns></returns>

            public Maxcoder Pop()

            {

                return null;

            }

​

            public int Count

            {

                get { return 0; }

            }

​

            /// <summary>

            /// Represents a maxcoder

            /// </summary>

            public class Maxcoder

            {

                public Maxcoder(string name)

                {

                    if (string.IsNullOrEmpty(name))

                    {

                        throw new ArgumentNullException("name");

                    }

​

                    Name = name;

                }

​

                public string Name { get; private set; }

            }

        }

    }

​

​

​

    public class Program

    {

        public static void Main(string[] args)

        {

            ExerciseFindForSum(new List<int> { 1, 3, 5, 7, 9 }, 12, new[]

            {

                Tuple.Create(1, 4),

                Tuple.Create(2, 3),

                Tuple.Create(3, 2),

                Tuple.Create(4, 1),

            });

​

            ExerciseIndexOfLongestRun("abbcccddddcccbba", 6);

​

            ExerciseMaxcodeStack();

​

            Console.WriteLine("Well done!");

        }

​

        private static void ExerciseFindForSum(List<int> elements, int sum, Tuple<int, int>[] expectedAnyOf)

        {

            var result = Exercises.FindForSum(elements, sum);

​

            var containsResult = expectedAnyOf.Any(

                c => c.Item1 == result.Item1 && c.Item2 == result.Item2

                 || c.Item1 == result.Item2 && c.Item2 == result.Item1);

​

            Assert.True(containsResult, "The pair " + result.Item1 + ", " + result.Item2 + " does not " +

                                        "match the criteria");

        }

​

        private static void ExerciseIndexOfLongestRun(string source, int expectedIndex)

        {

            var result = Exercises.IndexOfLongestRun(source);

​

            Assert.Equal(expectedIndex, result);

        }

​

        private static void ExerciseMaxcodeStack()

        {

            var stack = new Exercises.MaxcodeStack();

            var you = new Exercises.MaxcodeStack.Maxcoder("Your name");

            var me = new Exercises.MaxcodeStack.Maxcoder("My name");

​

            stack.Push(you);

            Assert.Equal(1, stack.Count);

​

            stack.Push(me);

            Assert.Equal(2, stack.Count);

            var popedMaxcoder1 = stack.Pop();

            Assert.Equal("My name", popedMaxcoder1.Name);

            Assert.Equal(1, stack.Count);

​

            var popedMaxcoder2 = stack.Pop();

            Assert.Equal("Your name", popedMaxcoder2.Name);

            Assert.Equal(0, stack.Count);

​

            stack.Pop();

        }

    }

}

​