Spiral Matrix II

class Solution {
public:
    vector<vector<int>> fillMatrix(int size) {
        vector<vector<int>> matrix(size, vector<int>(size));
        int number = 1;
        for (int level = 0; level < (size + 1) / 2; level++) {
            // fill rightwards
            for (int i = level; i < size - level; i++) {
                matrix[level][i] = number++;
            }
            // fill downwards
            for (int i = level + 1; i < size - level; i++) {
                matrix[i][size - level - 1] = number++;
            }
            // fill leftwards
            for (int i = size - level - 2; i >= level; i--) {
                matrix[size - level - 1][i] = number++;
            }
            // fill upwards
            for (int i = size - level - 2; i > level; i--) {
                matrix[i][level] = number++;
            }
        }
        return matrix;
    }
};

The problem solution provided involves generating a square matrix filled with numbers from 1 to n^2 in a spiral order, where n is specified by the size parameter of the fillMatrix function. Developed in C++, the code is structured within a Solution class.

Key insights of the implementation include:

• Create a matrix with dimensions size x size, initialized with zeros.

• Use a four-step loop to fill the matrix:

  • Fill rightwards: Populate the top row from left to right.
  • Fill downwards: Populate the last column from top to bottom.
  • Fill leftwards: Populate the bottom row from right to left.
  • Fill upwards: Populate the first column from bottom to top.

• Each of these filling steps is bound by level, which ensures internal spirals are correctly populated as the matrix builds from the outer layers towards the center.

The function returns the populated matrix, making it easily accessible for verification or for further processing in other parts of your application. This approach effectively addresses the problem requirements while maintaining clarity and operational efficiency.

class MatrixGenerator {
    public int[][] spiralMatrix(int size) {
        int[][] matrix = new int[size][size];
        int num = 1;
        for (int level = 0; level < (size + 1) / 2; level++) {
            // moving right
            for (int i = level; i < size - level; i++) {
                matrix[level][i] = num++;
            }
            // moving down
            for (int i = level + 1; i < size - level; i++) {
                matrix[i][size - level - 1] = num++;
            }
            // moving left
            for (int i = level + 1; i < size - level; i++) {
                matrix[size - level - 1][size - i - 1] = num++;
            }
            // moving up
            for (int i = level + 1; i < size - level - 1; i++) {
                matrix[size - i - 1][level] = num++;
            }
        }
        return matrix;
    }
}

Problem Title: Spiral Matrix II

Language: Java

Solution Summary:

The Java code defines a class MatrixGenerator with a method spiralMatrix that generates a square matrix filled with numbers arranged in a spiral order. The matrix's size is determined by the input parameter size. The methodology is divided into four directional movements to fill the matrix in the required spiral order.

1. Initialize a 2D array matrix of size [size][size] and a variable num to track the current number being placed in the matrix.
2. Use a loop to handle the filling of the matrix layer by layer. This loop runs from the outermost layer to the innermost, based on the variable level.
3. In each iteration of the loop, handle matrix filling in these directions:
   • Right: Incrementally fill positions from the current level index to size - level, at the top of the current level.
   • Down: Move down the right side of the current square from the next row at the current level up to size - level.
   • Left: Move left at the bottom of the current square from right to left.
   • Up: Move up the left side of the current square, completing the spiral cycle for the current level.
4. Repeat these steps for each level until numbers are filled, and return the matrix.

This approach efficiently fills a 2D matrix in a spiral order, optimizing operations based on the matrix's size and ensuring completeness with each loop cycle handling all sides of the current spiral level. This technique ensures all cells in the matrix are filled exactly once, maintaining an O(n^2) complexity, where n is the dimension of the matrix and the number of elements to insert.

int** createSpiralMatrix(int size, int* matrixSize, int** columnSizes) {
    int** matrix = (int**)malloc(size * sizeof(int*));
    *matrixSize = size;
    *columnSizes = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        matrix[i] = (int*)malloc(size * sizeof(int));
        (*columnSizes)[i] = size;
    }
    int number = 1;
    for (int level = 0; level < (size + 1) / 2; level++) {
        for (int idx = level; idx < size - level; idx++) {
            matrix[level][idx] = number++;
        }
        for (int idx = level + 1; idx < size - level; idx++) {
            matrix[idx][size - level - 1] = number++;
        }
        for (int idx = size - level - 2; idx >= level; idx--) {
            matrix[size - level - 1][idx] = number++;
        }
        for (int idx = size - level - 2; idx > level; idx--) {
            matrix[idx][level] = number++;
        }
    }
    return matrix;
}

The given C function createSpiralMatrix is designed to generate a square matrix filled with integers from 1 to size * size in a spiral order. The implementation efficiently manages memory allocation and matrix population, ensuring error-free filling by handling different directions of the spiral within nested loops.

Follow these steps to comprehend how the function achieves the task:

1. Initialize and allocate memory dynamically for the 2D matrix using malloc. Each row in the matrix equally receives an allocation for size integers.

2. Utilize four nested for loops to fill the matrix in the spiral order, which are:

   • The first loop determines the outer boundary or the level of the spiral to be filled.
   • Inside each level, four loops manage the direction-specific filling:
     • Rightward across the top of the current level.
     • Downward along the right side of the current square or level.
     • Leftward on the bottom from right to left.
     • Upward on the left side, finishing below the start of the top right fill.

3. Each filled value in the matrix increments sequentially, starting from 1 and counting up through the final value of size * size.

4. The matrix is finally returned, with each row having a uniformly set column size indicative of a well-formed square matrix.

This method is efficient and straightforward, integrating control structures and memory management to accomplish the matrix creation task. Moreover, the spiral filling algorithm is precisely coordinated to ensure the correct order of number insertion and to avoid overlap or unfilled entries within the matrix.

var createSpiralMatrix = function(size) {
    let matrix = Array.from({ length: size }, () => Array(size).fill(0));
    let num = 1;
    for (let level = 0; level < Math.floor((size + 1) / 2); level++) {
        // Fill left to right
        for (let i = level; i < size - level; i++) {
            matrix[level][i] = num++;
        }
        // Fill top to bottom
        for (let j = level + 1; j < size - level; j++) {
            matrix[j][size - level - 1] = num++;
        }
        // Fill right to left
        for (let i = size - level - 2; i >= level; i--) {
            matrix[size - level - 1][i] = num++;
        }
        // Fill bottom to top
        for (let j = size - level - 2; j > level; j--) {
            matrix[j][level] = num++;
        }
    }
    return matrix;
};

The provided JavaScript function createSpiralMatrix generates a square matrix filled with integers in a spiral order, taking size as an input that determines the dimensions of the matrix (i.e., size x size). The logic involves creating a square matrix initially filled with zeros. The filling process is structured into four main loops which cover the spiral's left to right, top to bottom, right to left, and bottom to top movements:

• Initially, the matrix is created using Array.from with each inner array filled with zeros.
• A nested loop structure, based on level, controls the entry of numbers into the matrix. The outer loop divides the matrix into levels, where each level corresponds to a complete lap around the outer edge of the remaining unsubscribed matrix.
• The first nested loop fills the numbers from left to right in the topmost row of the current level.
• The second nested loop fills numbers from top to bottom along the rightmost column of the current level.
• The third loop fills numbers from right to left in the bottom row of the current level.
• The fourth and final loop completes the current spiral by filling numbers from bottom to top along the leftmost column.
• The function then increments the number each time a new integer is placed in the matrix.

As num starts at 1 and is incremented after assigning to a matrix cell, the matrix is filled with integers from 1 to size*size. The number placement spirals inward until the entire matrix is filled, returning the complete matrix filled in a spiral order. Ensure to properly understand the iterative handling of the matrix indices to visualize the spiral pattern accurately. This solution effectively manages to simulate the spiral pattern using a tiered loop approach that incrementally restricts the operational area.

class MatrixGenerator:
    def spiralOrderMatrix(self, size: int) -> list[list[int]]:
        matrix = [[0] * size for i in range(size)]
        num = 1
        for level in range((size + 1) // 2):
            # rightward
            for i in range(level, size - level):
                matrix[level][i] = num
                num += 1
            # downward
            for i in range(level + 1, size - level):
                matrix[i][size - level - 1] = num
                num += 1
            # leftward
            for i in range(size - level - 2, level - 1, -1):
                matrix[size - level - 1][i] = num
                num += 1
            # upward
            for i in range(size - level - 2, level, -1):
                matrix[i][level] = num
                num += 1
        return matrix

The provided Python code defines a class MatrixGenerator with a method spiralOrderMatrix which generates an n x n spiral matrix with integers from 1 to n^2 using a layered approach.

• Initialize an n x n matrix of zeroes.
• Use a layered (or level-wise) loop. For each layer:
  • Fill the top row of the current layer from left to right.
  • Fill the right column of the current layer from top to bottom.
  • Fill the bottom row of the current layer from right to left.
  • Fill the left column of the current layer from bottom to top.

This method efficiently fills up the matrix in a spiral order while incrementing values from 1 up to n^2. Each sub-step strictly adheres to filling specific parts of the current layer, ensuring no overlaps occur and all cells are filled precisely once. The layered nature of the operations allows the method to gracefully handle both odd and even dimensions of the matrix.