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++)
                shifted.add(new ArrayList<Integer>());
            int index = (size - k) % size;
            for (int i = 0; i < size; i++) {
                int num = grid[index / columns][index % columns];
                shifted.get(i / columns).add(num);
                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) {
                    t.add(0);
                }
                ans.add(t);
            }
            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;
    }
    
    

All Problems

All Solutions