##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1260.html

# 1260. Shift 2D Grid (Easy)

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.

Example 1:

Input: grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1
Output: [[9,1,2],[3,4,5],[6,7,8]]


Example 2:

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]]


Example 3:

Input: grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9
Output: [[1,2,3],[4,5,6],[7,8,9]]


Constraints:

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

Related Topics:
Array

## Solution 1.

• class Solution {
public List<List<Integer>> shiftGrid(int[][] grid, int k) {
int rows = grid.length, columns = grid[0].length;
int size = rows * columns;
k %= size;
List<List<Integer>> shifted = new ArrayList<List<Integer>>();
for (int i = 0; i < rows; i++)
int index = (size - k) % size;
for (int i = 0; i < size; i++) {
int num = grid[index / columns][index % columns];
index = (index + 1) % size;
}
return shifted;
}
}

############

class Solution {
public List<List<Integer>> shiftGrid(int[][] grid, int k) {
int m = grid.length, n = grid[0].length;
k %= (m * n);
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < m; ++i) {
List<Integer> t = new ArrayList<>();
for (int j = 0; j < n; ++j) {
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
int t = (i * n + j + k) % (m * n);
ans.get(t / n).set(t % n, grid[i][j]);
}
}
return ans;
}
}

• // OJ: https://leetcode.com/problems/shift-2d-grid/
// Time: O(MN)
// Space: O(K)
class Solution {
public:
vector<vector<int>> shiftGrid(vector<vector<int>>& A, int k) {
int M = A.size(), N = A[0].size();
k %= M * N;
if (k == 0) return A;
queue<int> q;
for (int i = 0; i < M * N + k; ++i) {
int j = i % (M * N), x = j / N, y = j % N;
if (i < k) q.push(A[x][y]);
else {
q.push(A[x][y]);
A[x][y] = q.front();
q.pop();
}
}
return A;
}
};

• class Solution:
def shiftGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:
m, n = len(grid), len(grid[0])
k %= m * n
t = [grid[i][j] for i in range(m) for j in range(n)]
t = t[-k:] + t[:-k]
for i in range(m):
for j in range(n):
grid[i][j] = t[i * n + j]
return grid

############

# 1260. Shift 2D Grid
# https://leetcode.com/problems/shift-2d-grid/

class Solution:
def shiftGrid(self, grid: List[List[int]], k: int):
col, nums = len(grid[0]), sum(grid, [])
k = k % len(nums)
nums = nums[-k:] + nums[:-k]
return [nums[i:i+col] for i in range(0, len(nums), col)]

def shiftGrid(self, grid: List[List[int]], k: int):
rows, cols = len(grid), len(grid[0])

for _ in range(k):
res = [[0]*cols for _ in range(rows)]
for i in range(rows):
if i + 1 < rows and cols > 0:
res[i+1][0] = grid[i][cols-1]

for j in range(cols):
if j + 1 < cols:
res[i][j+1] = grid[i][j]

if rows > 0 and cols > 0:
res[0][0] = grid[rows-1][cols-1]

grid = res

return grid

• func shiftGrid(grid [][]int, k int) [][]int {
m, n := len(grid), len(grid[0])
ans := make([][]int, m)
for i := range ans {
ans[i] = make([]int, n)
}
for i := 0; i < m; i++ {
for j := 0; j < n; j++ {
t := (i*n + j + k) % (m * n)
ans[t/n][t%n] = grid[i][j]
}
}
return ans
}

• function shiftGrid(grid: number[][], k: number): number[][] {
const m = grid.length,
n = grid[0].length;
const size = m * n;
k = k % size;
if (k == 0 || size <= 1) return grid;
let arr = grid.flat();
if (size <= 1) return grid;
let ans = Array.from({ length: m }, v => new Array(n));
for (let i = 0, j = size - k; i < size; i++) {
ans[Math.floor(i / n)][i % n] = arr[j];
j = j == size - 1 ? 0 : j + 1;
}
return ans;
}