Multidimensional Array Traversal in C#

Introduction

Hello, fellow coder! Are you excited to dive into a new, intriguing coding challenge? In this lesson, we're going to explore special traversals of matrices . Matrices are rectangular 2D arrays where each inner array maintains the same size, a property inherent to many programming languages, C# included. We'll find our way through a matrix by climbing up and down the columns, zigzagging as we go. Sound exciting? Buckle up, then, and get ready!

Task Statement

Here's the task: You've been given a 2D array consisting of individual cells, each holding a unique integer value. Your goal is to create a function that will traverse this matrix, starting at the bottom-right cell. From there, you'll travel up to the top of the same column, then move left to the next column, and then continue downward from the top of this new column. After reaching the bottom of the column, you'll again move left and start moving upward. This unique traversal pattern will be performed until all the cells have been visited. Consider this small 3x4 matrix as an example: C# int[,] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; With the described traversal pattern, your function should return this list: [12, 8, 4, 3, 7, 11, 10, 6, 2, 1, 5, 9] .

Solution Building: Step 1

The first step toward a solution is understanding the dimensions of the matrix with which we're working. We can do this using array properties. Let's set up our function and identify the matrix size: C# class Solution {public static int[] ColumnTraverse(int[,] matrix) {int rows = matrix.GetLength(0); int cols = matrix.GetLength(1);}}

Solution Building: Step 2

Now that we're aware of the matrix dimensions, we should establish the starting point (bottom-right) and the direction of travel (upward initially). Additionally, we'll need an array to keep track of the cells we've visited in order: C# class Solution {public static int[] ColumnTraverse(int[,] matrix) {int rows = matrix.GetLength(0); int cols = matrix.GetLength(1); string direction = "up"; int row = rows - 1; int col = cols - 1; int[] output = new int[rows * cols]; int index = 0;}}

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Solution Building: Step 3

It's time to go exploring! We'll now implement a while loop to traverse the matrix. This loop will continue until we have covered all the cells in the matrix. As we "visit" each cell, we'll add the value in the cell to our array.

class Solution {
    public static int[] ColumnTraverse(int[,] matrix) {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        string direction = "up";
        int row = rows - 1;
        int col = cols - 1;
        int[] output = new int[rows * cols];
        int index = 0;

        while (index < rows * cols) {
            output[index++] = matrix[row, col];

            if (direction == "up") {
                if (row - 1 < 0) {
                    direction = "down";
                    col -= 1;
                } else {
                    row -= 1;
                }
            } else {
                if (row + 1 == rows) {
                    direction = "up";
                    col -= 1;
                } else {
                    row += 1;
                }
            }
        }

        return output;
    }

    public static void Main(string[] args) {
        int[,] matrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        int[] result = ColumnTraverse(matrix);
        foreach (int num in result) {
            Console.Write(num + " ");
        }
    }
}

class Solution {
    public static int[] ColumnTraverse(int[,] matrix) {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        string direction = "up";
        int row = rows - 1;
        int col = cols - 1;
        int[] output = new int[rows * cols];
        int index = 0;

        while (index < rows * cols) {
            output[index++] = matrix[row, col];

            if (direction == "up") {
                if (row - 1 < 0) {
                    direction = "down";
                    col -= 1;
                } else {
                    row -= 1;
                }
            } else {
                if (row + 1 == rows) {
                    direction = "up";
                    col -= 1;
                } else {
                    row += 1;
                }
            }
        }

        return output;
    }

    public static void Main(string[] args) {
        int[,] matrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        int[] result = ColumnTraverse(matrix);
        foreach (int num in result) {
            Console.Write(num + " ");
        }
    }
}

The condition index < rows * cols inside the while loop is used to control the loop's termination. It checks whether all the cells in the matrix have been visited by ensuring that the index (the current cell being processed) is less than the total number of cells (rows * cols).
The condition direction == "up" checks whether the current direction is upward. If true, the row is decremented (row--) to move up within the same column. If moving up would take us out of bounds (row - 1 < 0), the direction is changed to "down", and the column is moved left (col--) to the next column.
In the else block (when direction is "down"), we first check if the row index reaches the bottom of the matrix (row + 1 == rows). If so, the direction is switched back to "up", and the column moves left again. Otherwise, the row is incremented (row++) to move down within the current column.

That's it; we've completed the function! This C# function will return the output array, which gives us the order of traversal through the matrix.

Traverse Using Decreasing Range

Let's explore one more way of traversal. We can leverage the utility of C#'s for loop to traverse a 2D matrix in reverse order. This flexibility can also create a sequence that decrements.

To achieve this, we use a for loop with decrementing indices.

Consider our familiar 3x4 matrix:

int[,] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

int[,] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

Using decrementing loops, the reverse traverse pattern would produce this list: {12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}.

Here's how we can implement this reverse traversal:

class Solution {
    public static int[] ReverseTraverse(int[,] matrix) {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        int[] output = new int[rows * cols];
        int index = 0;

        for (int row = rows - 1; row >= 0; --row) {
            for (int col = cols - 1; col >= 0; --col) {
                output[index++] = matrix[row, col];
            }
        }

        return output;
    }

    public static void Main(string[] args) {
        int[,] matrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        int[] result = ReverseTraverse(matrix);
        foreach (int num in result) {
            Console.Write(num + " ");
        }
    }
}

class Solution {
    public static int[] ReverseTraverse(int[,] matrix) {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        int[] output = new int[rows * cols];
        int index = 0;

        for (int row = rows - 1; row >= 0; --row) {
            for (int col = cols - 1; col >= 0; --col) {
                output[index++] = matrix[row, col];
            }
        }

        return output;
    }

    public static void Main(string[] args) {
        int[,] matrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        int[] result = ReverseTraverse(matrix);
        foreach (int num in result) {
            Console.Write(num + " ");
        }
    }
}

In this function, we start the loop for row from rows - 1 and run it to 0, decrementing it at each step. Similarly, our nested loop for col starts from cols - 1 and goes to 0. This allows us to start from the bottom-right corner and traverse leftward, then upward, covering the entire matrix in reverse order.

As you gain proficiency in matrix traversal in C#, you'll discover the many creative ways to utilize C#'s flexible syntax. The more you experiment with different traversal methods, the better you'll become! Happy practicing!