Rotating the Box

Rotating the Box - Problem

You are given an m x n matrix of characters boxGrid representing a side-view of a box. Each cell of the box is one of the following:

A stone '#'
A stationary obstacle '*'
Empty '.'

The box is rotated 90 degrees clockwise, causing some of the stones to fall due to gravity. Each stone falls down until it lands on an obstacle, another stone, or the bottom of the box. Gravity does not affect the obstacles' positions, and the inertia from the box's rotation does not affect the stones' horizontal positions.

It is guaranteed that each stone in boxGrid rests on an obstacle, another stone, or the bottom of the box.

Return an n x m matrix representing the box after the rotation described above.

Input & Output

Example 1 — Basic 3x3 Box

$ Input: boxGrid = [["#",".","."],["#","#","*"],["#","#","."]]

› Output: [[".","#","#"],[".",".","#"],["#","*","#"]]

💡 Note: After rotation, stones in columns 1&2 fall down. Column 0 has obstacle '*' blocking some stones.

Example 2 — Single Row

$ Input: boxGrid = [["#",".","*",".","#"]]

› Output: [["#"],["#"],["*"],["."],["."]]

💡 Note: Single row becomes a column. Stones fall to bottom, obstacle stays in place.

Example 3 — All Obstacles

$ Input: boxGrid = [["*","*"],["*","*"]]

› Output: [["*","*"],["*","*"]]

💡 Note: Obstacles don't move during rotation, so result is just rotated positions.

Constraints

m == boxGrid.length
n == boxGrid[i].length
1 ≤ m, n ≤ 500
boxGrid[i][j] is either '.', '#', or '*'

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 32 G Google 28 f Meta 22

The key insight is to handle gravity first within each row using two pointers, then rotate the matrix. This is much cleaner than rotating first and simulating falling. Best approach uses gravity-first with two pointers: Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Gravity First, Then Rotate

⏱️ Time: O(m × n) Space: O(m × n)

For each row, use two pointers to move all stones to the right (simulating gravity after rotation). Then rotate the entire matrix 90 degrees clockwise. This is more intuitive than rotating first.

Rotate Then Simulate Falling

⏱️ Time: O(m × n × max(m,n)) Space: O(m × n)

First rotate the matrix 90 degrees clockwise, then for each stone in the rotated matrix, simulate it falling down until it hits an obstacle, another stone, or the bottom.

Gravity First, Then Rotate — Algorithm Steps

Step 1: For each row, apply gravity (move stones right)
Step 2: Use two pointers to efficiently move stones to obstacles
Step 3: Rotate the gravity-applied matrix 90° clockwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Apply Gravity Per Row

Use two pointers to move stones right in each row

Pointer Movement

Read pointer scans, write pointer places stones

Rotate Result

Final 90° rotation gives the answer

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char grid[500][500];
static char result[500][500];

void solution(int m, int n, int* returnM, int* returnN) {
    // Step 1: Apply gravity to each row (stones fall to right)
    for (int i = 0; i < m; i++) {
        int writePos = n - 1;
        for (int readPos = n - 1; readPos >= 0; readPos--) {
            if (grid[i][readPos] == '*') {        // Obstacle - reset write position
                writePos = readPos - 1;
            } else if (grid[i][readPos] == '#') { // Stone - move to write position
                if (writePos != readPos) {
                    grid[i][writePos] = '#';
                    grid[i][readPos] = '.';
                }
                writePos--;
            }
            // For empty cells ('.'), just continue
        }
    }

    // Step 2: Rotate 90 degrees clockwise
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            result[j][m-1-i] = grid[i][j];
        }
    }

    *returnM = n;
    *returnN = m;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);

    int m = 0, n = 0;
    int len = strlen(line);
    int k = 0;

    // Skip outer opening bracket
    while (k < len && line[k] != '[') k++;
    k++;

    while (k < len) {
        // Skip to next '[' or ']'
        while (k < len && line[k] != '[' && line[k] != ']') k++;
        if (k >= len || line[k] == ']') break;

        k++; // skip row '['
        int j = 0;

        while (k < len) {
            // Skip to next '"' or ']'
            while (k < len && line[k] != '"' && line[k] != ']') k++;
            if (k >= len || line[k] == ']') { k++; break; }

            k++; // skip opening '"'
            while (k < len && line[k] != '"') {
                grid[m][j++] = line[k++];
            }
            k++; // skip closing '"'
        }

        if (j > 0) {
            if (n == 0) n = j;
            m++;
        }
    }

    int returnM, returnN;
    solution(m, n, &returnM, &returnN);

    // Print result as JSON 2D array — each cell as individual quoted character
    printf("[");
    for (int i = 0; i < returnM; i++) {
        printf("[");
        for (int j = 0; j < returnN; j++) {
            printf("\"%c\"", result[i][j]);
            if (j < returnN - 1) printf(",");
        }
        printf("]");
        if (i < returnM - 1) printf(",");
    }
    printf("]\n");

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Each cell processed once for gravity, once for rotation

✓ Linear Growth

Space Complexity

O(m × n)

Extra space for result matrix

⚡ Linearithmic Space

35.4K Views

Medium Frequency

~25 min Avg. Time

987 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Gravity First, Then Rotate — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler