C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Text;

public static class ConsoleHelper
{
	/// <summary>
	/// Prints a nxn matrix, given the array
	/// </summary>
	/// <param name = "label"></param>
	/// <param name = "array">matrix to be printed</param>
	public static void PrintMaze(string label, int[, ] array)
	{
		label = label ?? "The maze looks like: ";
		StringBuilder result = new StringBuilder();
		for (int i = 0; i < array.GetLength(0); i++)
		{
			StringBuilder line = new StringBuilder();
			for (int j = 0; j < array.GetLength(1); j++)
			{
				line.Append($"{array[i, j], 15}");
			}

			result.AppendLine(line.ToString());
		}

		Console.WriteLine($"{label}");
		Console.WriteLine(result);
	}
}

public class MatrixItem
{
	public int Row
	{
		get;
		set;
	}

	public int Column
	{
		get;
		set;
	}
}

public static class ArrayUtilities
{
	/// <summary>
	/// Returns a matrix containing the number of steps to the goal=exit
	/// STEPS TOWARDS EXIT MATRIX
	/// </summary>
	/// <param name = "maze">The given NxN matrix</param>
	/// <returns>A NxN matrix containing stepts to goal, where the goal is marked with 0.</returns>
	public static int[, ] WayOutOfMaze(int[, ] maze)
	{
		int[, ] stepsMatrix = new int[maze.GetLength(0), maze.GetLength(1)];
		for (int i = 0; i < maze.GetLength(0); i++)
		{
			for (int j = 0; j < maze.GetLength(1); j++)
			{
				stepsMatrix[i, j] = -1;
			}
		}

		bool pacManFound = false;
		int currentWeight = 0;
		MatrixItem exit = FindExit(maze);
		MatrixItem pacMan = FindPacMan(maze);
		stepsMatrix[exit.Row, exit.Column] = currentWeight;
		while (!pacManFound)
		{
			for (int i = 0; i < maze.GetLength(0); i++)
			{
				for (int j = 0; j < maze.GetLength(1); j++)
				{
					switch (maze[i, j]) /* We're on an free cell (not wall) */
					{
						//FREE CELLS
						case 0:
						//PAC-MAN CELL
						case int.MaxValue:
						{
							/*        TOP  
                            *  LEFT   X   RIGHT
                            *      BOTTOM      
                            */
							bool isCloseNeighbourTop = (i - 1 >= 0) /* Top neighbour is not outside of the map */ 
								                       && stepsMatrix[i - 1, j] == currentWeight /* Top neighbour was previously closer to the goal */ 
								                       && stepsMatrix[i, j] == -1; /* Not yet marked cell */
							if (isCloseNeighbourTop)
							{
								stepsMatrix[i, j] = currentWeight + 1;
							}

							bool isCloseNeighbourLeft = (j - 1 >= 0) 
								                        && stepsMatrix[i, j - 1] == currentWeight 
								                        && stepsMatrix[i, j] == -1;
							if (isCloseNeighbourLeft)
							{
								stepsMatrix[i, j] = currentWeight + 1;
							}

							bool isCloseNeighbourBottom = (i + 1 < maze.GetLength(0)) 
								                          && stepsMatrix[i + 1, j] == currentWeight 
								                          && stepsMatrix[i, j] == -1;
							if (isCloseNeighbourBottom)
							{
								stepsMatrix[i, j] = currentWeight + 1;
							}

							bool isCloseNeighbourRight = (j + 1 < maze.GetLength(1)) 
								                         && stepsMatrix[i, j + 1] == currentWeight 
								                         && stepsMatrix[i, j] == -1;
							if (isCloseNeighbourRight)
							{
								stepsMatrix[i, j] = currentWeight + 1;
							}
						}
						break;
					}
				}
			}

			currentWeight++;
			if (stepsMatrix[pacMan.Row, pacMan.Column] >= 0)
			{
				pacManFound = true;
			}

			// Uncomment to see intermediary steps:
			// ConsoleHelper.PrintMaze($"At step {currentWeight} steps matrix looks like: ", stepsMatrix);
		}

		return stepsMatrix;
	}

	/// <summary>
	/// Returns a point having two coordinates x=row, y=column in the maze where the exit is.
	/// </summary>
	/// <param name = "maze">The given matrix</param>
	/// <returns>(row, column)</returns>
	public static MatrixItem FindExit(int[, ] maze)
	{
		MatrixItem exit = new MatrixItem();
		for (int row = 0; row < maze.GetLength(0); row++)
		{
			for (int col = 0; col < maze.GetLength(1); col++)
			{
				if (maze[row, col] == -int.MaxValue)
				{
					exit.Row = row;
					exit.Column = col;
					// no reason to continue iterating
					return exit;
				}
			}
		}

		return exit;
	}

	public static MatrixItem FindPacMan(int[, ] maze)
	{
		MatrixItem pacMan = new MatrixItem();
		for (int row = 0; row < maze.GetLength(0); row++)
		{
			for (int col = 0; col < maze.GetLength(1); col++)
			{
				if (maze[row, col] == int.MaxValue)
				{
					pacMan.Row = row;
					pacMan.Column = col;
					// no reason to continue iterating
					return pacMan;
				}
			}
		}

		return pacMan;
	}

	/// <summary>
	/// Prints the pair of coordinates where Pac-Man mustgo in order to find the way out
	/// </summary>
	/// <param name = "label"></param>
	/// <param name = "maze">The initial maze: NxN matrix</param>
	/// <param name = "stepMatrix">The step matrix representing number of steps to goal</param>
	/// <returns></returns>
	public static string PrintWayOutOfMaze(string label, int[, ] stepMatrix)
	{
		label = label ?? "The way out is: ";
		StringBuilder wayOut = new StringBuilder();
		int maxSteps = 0;
		for (int row = 0; row < stepMatrix.GetLength(0); row++)
		{
			for (int col = 0; col < stepMatrix.GetLength(1); col++)
			{
				if (stepMatrix[row, col] > maxSteps)
				{
					maxSteps = stepMatrix[row, col];
				}
			}
		}

		wayOut.AppendLine($"Maximum no of steps is: {maxSteps}");
		wayOut.Append($"{label}");
		while (maxSteps >= 0)
		{
			for (int row = 0; row < stepMatrix.GetLength(0); row++)
			{
				for (int col = 0; col < stepMatrix.GetLength(1); col++)
				{
					if (stepMatrix[row, col] == maxSteps)
					{
						if (maxSteps == 0)
						{
							wayOut.Append($"exit: ");
						}

						wayOut.Append($"({row},{col})");
						if (maxSteps > 0)
						{
							wayOut.Append(", ");
						}

						maxSteps--;
					}
				}
			}
		}

		return wayOut.ToString();
	}
}

public class Program
{
	public static void Main()
	{
		    int[,] maze =
            {
                { -1,               0,  0,   0,     int.MaxValue},
                { -1,               0, -1,  -1,    -1},
                { -1,               0,  0,   0,    -1},
                { -1,              -1, -1,   0,    -1},
                { -1,              -1, -1,   0,    -int.MaxValue}
            };

            ConsoleHelper.PrintMaze("The Pac-Man maze looks like: ", maze);
            int[,] wayOutMaze = ArrayUtilities.WayOutOfMaze(maze);
            ConsoleHelper.PrintMaze("The step matrix looks like: ", wayOutMaze);

            string result = ArrayUtilities.PrintWayOutOfMaze("The way out is: ", wayOutMaze);
            Console.WriteLine(result);
	}
}

​x
 
using System;
using System.Text;
​
public static class ConsoleHelper
{
    /// <summary>
    /// Prints a nxn matrix, given the array
    /// </summary>
    /// <param name = "label"></param>
    /// <param name = "array">matrix to be printed</param>
    public static void PrintMaze(string label, int[, ] array)
    {
        label = label ?? "The maze looks like: ";
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < array.GetLength(0); i++)
        {
            StringBuilder line = new StringBuilder();
            for (int j = 0; j < array.GetLength(1); j++)
            {
                line.Append($"{array[i, j], 15}");
            }
​
            result.AppendLine(line.ToString());
        }
​
        Console.WriteLine($"{label}");
        Console.WriteLine(result);
    }
}
​
public class MatrixItem
{
    public int Row
    {
        get;
        set;
    }
​
    public int Column
    {
        get;
        set;
    }
}
​
public static class ArrayUtilities
{
    /// <summary>
    /// Returns a matrix containing the number of steps to the goal=exit
    /// STEPS TOWARDS EXIT MATRIX
    /// </summary>
    /// <param name = "maze">The given NxN matrix</param>
    /// <returns>A NxN matrix containing stepts to goal, where the goal is marked with 0.</returns>
    public static int[, ] WayOutOfMaze(int[, ] maze)
    {
        int[, ] stepsMatrix = new int[maze.GetLength(0), maze.GetLength(1)];
        for (int i = 0; i < maze.GetLength(0); i++)
        {
            for (int j = 0; j < maze.GetLength(1); j++)
            {
                stepsMatrix[i, j] = -1;
            }
        }
​
        bool pacManFound = false;
        int currentWeight = 0;
        MatrixItem exit = FindExit(maze);
        MatrixItem pacMan = FindPacMan(maze);
        stepsMatrix[exit.Row, exit.Column] = currentWeight;
        while (!pacManFound)
        {
            for (int i = 0; i < maze.GetLength(0); i++)
            {
                for (int j = 0; j < maze.GetLength(1); j++)
                {
                    switch (maze[i, j]) /* We're on an free cell (not wall) */
                    {
                        //FREE CELLS
                        case 0:
                        //PAC-MAN CELL
                        case int.MaxValue:
                        {
                            /*        TOP  
                            *  LEFT   X   RIGHT
                            *      BOTTOM      
                            */
                            bool isCloseNeighbourTop = (i - 1 >= 0) /* Top neighbour is not outside of the map */ 
                                                       && stepsMatrix[i - 1, j] == currentWeight /* Top neighbour was previously closer to the goal */ 
                                                       && stepsMatrix[i, j] == -1; /* Not yet marked cell */
                            if (isCloseNeighbourTop)
                            {
                                stepsMatrix[i, j] = currentWeight + 1;
                            }
​
                            bool isCloseNeighbourLeft = (j - 1 >= 0) 
                                                        && stepsMatrix[i, j - 1] == currentWeight 
                                                        && stepsMatrix[i, j] == -1;
                            if (isCloseNeighbourLeft)
                            {
                                stepsMatrix[i, j] = currentWeight + 1;
                            }
​
                            bool isCloseNeighbourBottom = (i + 1 < maze.GetLength(0)) 
                                                          && stepsMatrix[i + 1, j] == currentWeight 
                                                          && stepsMatrix[i, j] == -1;
                            if (isCloseNeighbourBottom)
                            {
                                stepsMatrix[i, j] = currentWeight + 1;
                            }
​
                            bool isCloseNeighbourRight = (j + 1 < maze.GetLength(1)) 
                                                         && stepsMatrix[i, j + 1] == currentWeight 
                                                         && stepsMatrix[i, j] == -1;
                            if (isCloseNeighbourRight)
                            {
                                stepsMatrix[i, j] = currentWeight + 1;
                            }
                        }
                        break;
                    }
                }
            }
​
            currentWeight++;
            if (stepsMatrix[pacMan.Row, pacMan.Column] >= 0)
            {
                pacManFound = true;
            }
​
            // Uncomment to see intermediary steps:
            // ConsoleHelper.PrintMaze($"At step {currentWeight} steps matrix looks like: ", stepsMatrix);
        }
​
        return stepsMatrix;
    }
​
    /// <summary>
    /// Returns a point having two coordinates x=row, y=column in the maze where the exit is.
    /// </summary>
    /// <param name = "maze">The given matrix</param>
    /// <returns>(row, column)</returns>
    public static MatrixItem FindExit(int[, ] maze)
    {
        MatrixItem exit = new MatrixItem();
        for (int row = 0; row < maze.GetLength(0); row++)
        {
            for (int col = 0; col < maze.GetLength(1); col++)
            {
                if (maze[row, col] == -int.MaxValue)
                {
                    exit.Row = row;
                    exit.Column = col;
                    // no reason to continue iterating
                    return exit;
                }
            }
        }
​
        return exit;
    }
​
    public static MatrixItem FindPacMan(int[, ] maze)
    {
        MatrixItem pacMan = new MatrixItem();
        for (int row = 0; row < maze.GetLength(0); row++)
        {
            for (int col = 0; col < maze.GetLength(1); col++)
            {
                if (maze[row, col] == int.MaxValue)
                {
                    pacMan.Row = row;
                    pacMan.Column = col;
                    // no reason to continue iterating
                    return pacMan;
                }
            }
        }
​
        return pacMan;
    }
​
    /// <summary>
    /// Prints the pair of coordinates where Pac-Man mustgo in order to find the way out
    /// </summary>
    /// <param name = "label"></param>
    /// <param name = "maze">The initial maze: NxN matrix</param>
    /// <param name = "stepMatrix">The step matrix representing number of steps to goal</param>
    /// <returns></returns>
    public static string PrintWayOutOfMaze(string label, int[, ] stepMatrix)
    {
        label = label ?? "The way out is: ";
        StringBuilder wayOut = new StringBuilder();
        int maxSteps = 0;
        for (int row = 0; row < stepMatrix.GetLength(0); row++)
        {
            for (int col = 0; col < stepMatrix.GetLength(1); col++)
            {
                if (stepMatrix[row, col] > maxSteps)
                {
                    maxSteps = stepMatrix[row, col];
                }
            }
        }
​
        wayOut.AppendLine($"Maximum no of steps is: {maxSteps}");
        wayOut.Append($"{label}");
        while (maxSteps >= 0)
        {
            for (int row = 0; row < stepMatrix.GetLength(0); row++)
            {
                for (int col = 0; col < stepMatrix.GetLength(1); col++)
                {
                    if (stepMatrix[row, col] == maxSteps)
                    {
                        if (maxSteps == 0)
                        {
                            wayOut.Append($"exit: ");
                        }
​
                        wayOut.Append($"({row},{col})");
                        if (maxSteps > 0)
                        {
                            wayOut.Append(", ");
                        }
​
                        maxSteps--;
                    }
                }
            }
        }
​
        return wayOut.ToString();
    }
}
​
public class Program
{
    public static void Main()
    {
            int[,] maze =
            {
                { -1,               0,  0,   0,     int.MaxValue},
                { -1,               0, -1,  -1,    -1},
                { -1,               0,  0,   0,    -1},
                { -1,              -1, -1,   0,    -1},
                { -1,              -1, -1,   0,    -int.MaxValue}
            };
​
            ConsoleHelper.PrintMaze("The Pac-Man maze looks like: ", maze);
            int[,] wayOutMaze = ArrayUtilities.WayOutOfMaze(maze);
            ConsoleHelper.PrintMaze("The step matrix looks like: ", wayOutMaze);
​
            string result = ArrayUtilities.PrintWayOutOfMaze("The way out is: ", wayOutMaze);
            Console.WriteLine(result);
    }
}

View IL Code