Shift 2D Grid - Practice Coding Problems

Shift 2D Grid - Problem

Imagine you have a 2D grid filled with numbers, and you need to shift all elements in a specific pattern multiple times. Each shift operation moves every element to the next position following these rules:

📍 Shift Rules:
• Elements move right within their row: grid[i][j] → grid[i][j+1]
• When reaching the end of a row, wrap to the beginning of next row: grid[i][n-1] → grid[i+1][0]
• The last element wraps around to the very beginning: grid[m-1][n-1] → grid[0][0]

Given a 2D grid of size m × n and an integer k, return the grid after performing exactly k shift operations.

Input & Output

example_1.py — Basic 2x3 Grid

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

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

💡 Note: After 1 shift: 1→2's position, 2→3's position, 3→4's position (wrap to next row), 4→5's position, 5→6's position, 6→1's position (wrap to start)

example_2.py — 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 entire bottom row moves to the top, and all other rows shift down by one position

example_3.py — Edge Case: k > grid size

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

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

💡 Note: Since grid has 4 elements total, k=6 is equivalent to k=6%4=2 shifts. After 2 shifts: bottom row becomes top row

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Snake Pattern

Items flow left-to-right on each level, then drop to the next level

Circular Loop

Last item wraps around to the very beginning, creating a cycle

Direct Calculation

Use math to predict final positions without moving items step-by-step

Efficient Result

All items reach their destinations in a single operation

Key Takeaway

🎯 Key Insight: The 2D grid shifts follow a predictable circular pattern. By treating it as a 1D array and using modular arithmetic, we can calculate final positions directly without simulating each individual shift, achieving optimal O(m×n) performance.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal approach treats the 2D grid as a flattened 1D circular array. Instead of performing k individual shifts, we use modular arithmetic to directly calculate where each element ends up: new_position = (old_position + k) % total_elements. This reduces time complexity from O(k×m×n) to O(m×n) and handles large k values efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Simulation (Modular Arithmetic)	O(m × n)	O(m × n)	Calculate final positions directly using 1D indexing and modular arithmetic
Brute Force (Simulate Each Shift)	O(k × m × n)	O(m × n)	Perform k individual shift operations step by step

Optimized Simulation (Modular Arithmetic) — Algorithm Steps

Flatten the 2D grid conceptually into a 1D array (row by row)
Use modular arithmetic: k = k % (m * n) to handle cycles
For each element at position (i, j), calculate its 1D index: i * n + j
Calculate new 1D position: (old_pos + k) % (m * n)
Convert back to 2D: new_i = new_pos // n, new_j = new_pos % n
Place element in its final position

Visualization

Tap to expand

Step-by-Step Walkthrough

2D to 1D Mapping

Convert grid positions to linear indices

Apply Modular Shift

Calculate new positions using (pos + k) % total

1D to 2D Conversion

Map back to 2D coordinates

Final Result

Place elements in their calculated positions

Code -

solution.c — C

int** shiftGrid(int** grid, int gridSize, int* gridColSize, int k, int* returnSize, int** returnColumnSizes) {
    int m = gridSize, 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*)calloc(n, sizeof(int));
    }
    
    if (k == 0) {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = grid[i][j];
            }
        }
    } else {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int oldPos = i * n + j;
                int newPos = (oldPos + 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;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Single pass through all grid elements to calculate final positions

✓ Linear Growth

Space Complexity

O(m × n)

Need space for the result grid

⚡ Linearithmic Space

28.4K 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

Optimized Simulation (Modular Arithmetic) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler