using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

​

namespace CatchmentCalculator

{

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("Running tests for CatchmentCalculator");

​

            TestNewStationCatchment();

            TestExistingStationCatchment();

            Console.WriteLine("Press a key to continue");

            Console.ReadKey();

        }

​

        /// <summary>

        /// Calculate the catchment for the <paramref name="targetStationNode"/>.  This is the set of nodes for which the target station is the

        /// closest station (i.e. has the shortest travel time).

        /// </summary>

        /// <param name="times">A square two-dimensional array of travel times: times[i, j] is the travel time from node i to node j.</param>

        /// <param name="stationNodes">A list of station nodes.</param>

        /// <param name="targetStationNode">The node of the target station.</param>

        /// <returns>The catchment of the target station node: a list of nodes for which that station is the closest.</returns>

        //Iterate nodes check the closes with the station node ,find if the node which has low time is same as target node else cross check with the shortest time

        public static List<int> GetStationCatchment(double[,] times, List<int> stationNodes, int targetStationNode){

            //Declaring a new list for the catchment of the target station

            List<int> catchment = new List<int>();

​

            //Declaring the list that contains all stationNodes inorder to add the targetStationNode to list if stationNodes does not contain it

            List<int> stationNodesIncludingTarget = stationNodes;

            //Checks if the stationNodesIncludingTarget contains the targetStationNode and if it does not, targetStationNode is added to the list.

            if(!(stationNodesIncludingTarget.Contains(targetStationNode))){

                stationNodesIncludingTarget.Add(targetStationNode);

            }

​

            //iteration that goes through all the nodes to find out each's distance to all the nodes in the variable stationNodesIncludingTarget

            for (int i=0;i<times.GetLength(0);i++){ // times.getLength(0) so we only run this loop equal to the total number of nodes

​

                //Initialising a high value for minTime so it gets changed in the first iteration

                double minTime = double.MaxValue;

​

                //Intialising the values of variable needed in the iteration

                double currentTime = -1;  //This is declared and initialised so we do not have to access the times list more than once for one set of values

                int closestNode = -1;

​

                // iteration to find out the time taken to travel between the current node i and all the nodes in the variable stationNodesIncludingTarget

                for (int j=0;j<stationNodesIncludingTarget.Count;j++){

​

                    //sets the variable currentTime to the time it takes from node i to the node number j in stationNodesIncludingTarget list.

                    currentTime = times[i, stationNodesIncludingTarget[j] ];

​

                    //condition to check if time taken from i to current(jth) node of stationNodesIncludingTarget is less than the least time taken from i to all the other nodes in stationNodesIncludingTarget

                    if(currentTime<minTime){

​

                        //sets the minimum time to the time it takes from i to current node(jth) in stationNodesIncludingTarget

                        minTime=currentTime;

                        // sets the node to the current node(jth) in stationNodesIncludingTarget

                        closestNode = stationNodesIncludingTarget[j];

                    }

                }

​

                //checks if the closest node is the target node and if it is, it adds the node to the final catchment list

                if(closestNode==targetStationNode){

                    catchment.Add(i);

                }

            }

            return catchment;

        }

​

​

​

​

        public static void TestNewStationCatchment()

        {

            // Arrange

            var times = TestHelperMethods.GetSquareGridTimes(5);

            var stationNodes = new List<int> { 0, 12 };

            var targetStationNode = 8;

            var expectedCatchment = new List<int> { 2, 3, 4, 8, 9, 14 };

​

            // Act

            var catchment = GetStationCatchment(times, stationNodes, targetStationNode);

​

            // Assert

            TestHelperMethods.AssertAndOutputResult("GetCatchmentForNewStation", expectedCatchment, catchment);

        }

​

        public static void TestExistingStationCatchmentReordered()

        {

            // Arrange

            var times = TestHelperMethods.GetSquareGridTimes(5);

            var stations = new List<int> { 12, 8, 0 };

            var targetStationNode = 0;

            var expectedCatchment = new List<int> { 0, 1, 5, 6, 10 };

​

            // Act 

            var catchment = GetStationCatchment(times, stations, targetStationNode);

​

            // Assert

            TestHelperMethods.AssertAndOutputResult("GetCatchmentForExistingStationReordered", expectedCatchment, catchment);

        }

        public static void TestExistingStationCatchment()

        {

            // Arrange

            var times = TestHelperMethods.GetSquareGridTimes(5);

            var stations = new List<int> { 0, 8, 12 };

            var targetStationNode = 0;

            var expectedCatchment = new List<int> { 0, 1, 5, 6, 10 };

​

            // Act 

            var catchment = GetStationCatchment(times, stations, targetStationNode);

​

            // Assert

            TestHelperMethods.AssertAndOutputResult("GetCatchmentForExistingStation", expectedCatchment, catchment);

        }

    }

    public static class TestHelperMethods

    {

​

        public static void AssertAndOutputResult(string test, List<int> expected, List<int> actual)

        {

            var success = AreEquivalent(expected, actual);

            if (success)

            {

                Console.WriteLine($"{test}: PASS");

            }

            else

            {

                Console.WriteLine($"{test}: FAIL");

                Console.WriteLine($"Expected: [{string.Join(",", expected)}]");

                Console.WriteLine($"Actual: [{string.Join(",", actual)}]");

            }

        }

​

        public static double[,] GetSquareGridTimes(int width)

        {

            var nodeCount = width * width;

            var times = new double[nodeCount, nodeCount];

            for (int i = 0; i < nodeCount; i++)

            {

                double xi = i % width;

                double yi = i / width;

                for (int j = 0; j < nodeCount; j++)

                {

                    double xj = j % width;

                    double yj = j / width;

                    times[i, j] = Math.Sqrt(Math.Pow(xi - xj, 2) + Math.Pow(yi - yj, 2));

                }

            }

            return times;

        }

​

        public static bool AreEquivalent(List<int> x, List<int> y)

        {

            return !(x.Except(y).Any() || y.Except(x).Any());

        }

    }

}

​