Cyclically Rotating a Grid - Practice Coding Problems

Cyclically Rotating a Grid - Problem

Imagine you have a layered matrix like an onion - each layer can be peeled away to reveal the next inner layer. You're given an m × n integer matrix where both dimensions are even, and your task is to cyclically rotate each layer counter-clockwise by k positions.

What does this mean? Think of each layer as a circular track where elements move in a counter-clockwise direction. After k rotations, each element takes the position that was k steps ahead of it in the counter-clockwise direction.

Goal: Return the matrix after applying k cyclic rotations to each layer.

Visual Example: In a 4×4 matrix with layers colored differently:
🔴 Outer layer (border elements)
🔵 Inner layer (center 2×2)
Each layer rotates independently!

Input & Output

example_1.py — Basic 4×4 Matrix

$ Input: grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], k = 2

› Output: [[3,4,8,12],[2,11,10,16],[1,7,6,15],[5,9,13,14]]

💡 Note: Layer 1: [1,2,3,4,8,12,16,15,14,13,9,5] rotates 2 positions to [3,4,8,12,16,15,14,13,9,5,1,2]. Layer 2: [6,7,11,10] rotates 2 positions to [11,10,6,7]

example_2.py — Rectangular Matrix

$ Input: grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4

› Output: [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]]

💡 Note: Layer 1 has 12 elements, k=4 means 4 positions rotation. Layer 2 has 4 elements, k=4 means full rotation (back to original). Both layers return to original positions

example_3.py — Large Rotation Value

$ Input: grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], k = 100

› Output: [[9,5,1,2],[13,7,6,3],[14,11,10,4],[15,16,12,8]]

💡 Note: Layer 1 has 12 elements: 100 % 12 = 4 effective rotations. Layer 2 has 4 elements: 100 % 4 = 0 effective rotations (stays same). Optimization prevents 100 actual rotations

Constraints

m == grid.length
n == grid[i].length
2 ≤ m, n ≤ 300
4 ≤ m * n ≤ 3 * 10⁴
Both m and n are even integers
1 ≤ grid[i][j] ≤ 10⁹
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Layer Identification

Identify concentric rectangular layers in the matrix

Element Extraction

Extract elements from each layer in counter-clockwise order

Modular Rotation

Use k % layer_size to find effective rotations needed

Element Placement

Place rotated elements back into their new positions

Key Takeaway

🎯 Key Insight: Each layer rotates independently as a circular array. Using modular arithmetic (k % layer_size) eliminates unnecessary full rotations, making the solution efficient even for very large k values.

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 12

The optimal approach is to extract each layer into an array, use modular arithmetic to calculate the effective rotation (k % layer_size), then place elements back. This avoids unnecessary full rotations and achieves O(m × n) time complexity with O(m + n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Layer-by-Layer Simulation	O(m * n * k)	O(m + n)	Extract each layer, simulate k rotations step by step, then put back

Layer-by-Layer Simulation — Algorithm Steps

Identify all layers in the matrix (outermost to innermost)
For each layer, extract elements in counter-clockwise order
Simulate k rotations by shifting array elements k times
Place the rotated elements back into their new positions
Repeat for all layers

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Layers

Matrix has concentric rectangular layers like onion rings

Extract Layer

Collect elements in counter-clockwise order: top→right→bottom→left

Rotate Array

Shift array elements by k positions using modular arithmetic

Place Back

Put rotated elements back in their new positions

Code -

solution.c — C

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

int** rotateGrid(int** grid, int gridSize, int* gridColSize, int k, int* returnSize, int** returnColumnSizes) {
    int m = gridSize, n = gridColSize[0];
    int layers = (m < n ? m : n) / 2;
    
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    // Create result grid
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
        for (int j = 0; j < n; j++) {
            result[i][j] = grid[i][j];
        }
    }
    
    for (int layer = 0; layer < layers; layer++) {
        int* elements = (int*)malloc(2 * (m + n) * sizeof(int));
        int elementCount = 0;
        
        // Extract elements from current layer
        // Top row
        for (int j = layer; j < n - layer; j++) {
            elements[elementCount++] = result[layer][j];
        }
        
        // Right column
        for (int i = layer + 1; i < m - layer; i++) {
            elements[elementCount++] = result[i][n - 1 - layer];
        }
        
        // Bottom row
        if (m - 1 - layer > layer) {
            for (int j = n - 2 - layer; j >= layer; j--) {
                elements[elementCount++] = result[m - 1 - layer][j];
            }
        }
        
        // Left column
        if (n - 1 - layer > layer) {
            for (int i = m - 2 - layer; i > layer; i--) {
                elements[elementCount++] = result[i][layer];
            }
        }
        
        // Rotate elements
        if (elementCount > 0) {
            int effectiveK = k % elementCount;
            int* rotated = (int*)malloc(elementCount * sizeof(int));
            
            for (int i = 0; i < elementCount; i++) {
                rotated[i] = elements[(i + effectiveK) % elementCount];
            }
            
            // Put elements back
            int idx = 0;
            
            // Top row
            for (int j = layer; j < n - layer; j++) {
                result[layer][j] = rotated[idx++];
            }
            
            // Right column
            for (int i = layer + 1; i < m - layer; i++) {
                result[i][n - 1 - layer] = rotated[idx++];
            }
            
            // Bottom row
            if (m - 1 - layer > layer) {
                for (int j = n - 2 - layer; j >= layer; j--) {
                    result[m - 1 - layer][j] = rotated[idx++];
                }
            }
            
            // Left column
            if (n - 1 - layer > layer) {
                for (int i = m - 2 - layer; i > layer; i--) {
                    result[i][layer] = rotated[idx++];
                }
            }
            
            free(rotated);
        }
        
        free(elements);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * k)

For each of the O(min(m,n)) layers, we extract O(m+n) elements and perform k rotation steps

✓ Linear Growth

Space Complexity

O(m + n)

Extra space needed to store elements of the largest layer during rotation

⚡ Linearithmic Space

22.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Layer-by-Layer Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler