Shift 2D Grid

Shift 2D Grid - Problem

Given a 2D grid of size m x n and an integer k, you need to shift the grid k times.

In one shift operation:

Element at grid[i][j] moves to grid[i][j + 1]
Element at grid[i][n - 1] moves to grid[i + 1][0]
Element at grid[m - 1][n - 1] moves to grid[0][0]

Return the 2D grid after applying shift operation k times.

Input & Output

Example 1 — Basic Shift

$ Input: grid = [[1,2,3],[4,5,6]], k = 1

› Output: [[6,1,2],[3,4,5]]

💡 Note: After 1 shift: element 6 moves to [0][0], 1 moves to [0][1], 2 moves to [0][2], 3 moves to [1][0], etc.

Example 2 — Multiple Shifts

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

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

💡 Note: After 4 shifts, the last row moves to the top and all other rows shift down by one position.

Example 3 — Full Cycle

$ Input: grid = [[1,2,3],[4,5,6]], k = 6

› Output: [[1,2,3],[4,5,6]]

💡 Note: After 6 shifts (m×n = 2×3 = 6), all elements return to their original positions.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m ≤ 50
1 ≤ n ≤ 50
-1000 ≤ grid[i][j] ≤ 1000
0 ≤ k ≤ 100

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12

The key insight is to use modular arithmetic instead of simulating shifts. Map 2D grid to 1D positions, calculate new positions with (pos + k) % (m×n), then map back to 2D. Best approach is Mathematical Position Mapping. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Mathematical Position Mapping

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

Instead of simulating k shifts, flatten the 2D grid conceptually into a 1D array, calculate where each element ends up after k shifts using modulo, then map back to 2D coordinates.

Simulate K Shifts

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

For each of the k shifts, iterate through the grid and move each element to its next position according to the shift rules. This directly simulates the problem description.

Mathematical Position Mapping — Algorithm Steps

Flatten 2D grid to 1D conceptually
Calculate new position: (pos + k) % (m * n)
Map new 1D position back to 2D coordinates
Place elements at their final positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Map to 1D

Conceptually flatten grid: position = i*n + j

Calculate New Position

new_pos = (pos + k) % (m*n)

Map Back to 2D

new_i = pos/n, new_j = pos%n

Code -

solution.c — C

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

int** shiftGrid(int** grid, int gridSize, int* gridColSize, int k, int* returnSize, int** returnColumnSizes) {
    int m = gridSize;
    int n = gridColSize[0];
    int total = m * n;
    
    k = k % total;
    
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int pos = i * n + j;
            int newPos = (pos + k) % total;
            int newI = newPos / n;
            int newJ = newPos % n;
            result[newI][newJ] = grid[i][j];
        }
    }
    
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    for (int i = 0; i < m; i++) {
        (*returnColumnSizes)[i] = n;
    }
    
    return result;
}

int main() {
    char gridInput[10000];
    int k;
    
    fgets(gridInput, sizeof(gridInput), stdin);
    scanf("%d", &k);
    
    gridInput[strcspn(gridInput, "\n")] = 0;
    
    int** grid = NULL;
    int rows = 0;
    int cols = 0;
    
    char* ptr = gridInput;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    int len = strlen(ptr);
    if (len > 0 && ptr[len-1] == ']') ptr[len-1] = '\0';
    if (len > 1 && ptr[len-2] == ']') ptr[len-2] = '\0';
    
    int capacity = 10;
    grid = (int**)malloc(capacity * sizeof(int*));
    
    int i = 0;
    len = strlen(ptr);
    
    while (i < len) {
        while (i < len && (ptr[i] == ' ' || ptr[i] == ',')) i++;
        
        if (i >= len) break;
        
        if (ptr[i] == '[') {
            i++;
            int* row = (int*)malloc(100 * sizeof(int));
            int colCount = 0;
            char num[20];
            int numIdx = 0;
            
            while (i < len && ptr[i] != ']') {
                if (ptr[i] == ',') {
                    if (numIdx > 0) {
                        num[numIdx] = '\0';
                        row[colCount++] = atoi(num);
                        numIdx = 0;
                    }
                } else if (ptr[i] == '-' || isdigit(ptr[i])) {
                    num[numIdx++] = ptr[i];
                }
                i++;
            }
            
            if (numIdx > 0) {
                num[numIdx] = '\0';
                row[colCount++] = atoi(num);
            }
            
            if (cols == 0) cols = colCount;
            
            if (rows >= capacity) {
                capacity *= 2;
                grid = (int**)realloc(grid, capacity * sizeof(int*));
            }
            
            if (colCount > 0) {
                grid[rows] = row;
                rows++;
            } else {
                free(row);
            }
            
            if (i < len && ptr[i] == ']') i++;
        } else {
            i++;
        }
    }
    
    if (rows == 0 || cols == 0) {
        printf("[]\n");
        return 0;
    }
    
    int* gridColSize = (int*)malloc(rows * sizeof(int));
    for (int i = 0; i < rows; i++) {
        gridColSize[i] = cols;
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = shiftGrid(grid, rows, gridColSize, k, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Single pass through all m×n elements

✓ Linear Growth

Space Complexity

O(m × n)

Need new grid to store result

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 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

Mathematical Position Mapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler