# Solving Leetcode Interviews in Seconds with AI: Shift 2D Grid


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1260" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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  

	# Explanation
	Here's a solution that focuses on efficiency by directly calculating the final position of each element after *k* shifts.

*   **Calculate Final Positions:** For each element at `grid[i][j]`, determine its final position `(new_i, new_j)` after *k* shifts using modular arithmetic. This avoids repeatedly shifting elements.
*   **Populate New Grid:** Create a new grid of the same dimensions. Place each element `grid[i][j]` into its calculated final position `(new_i, new_j)` in the new grid.
*   **Return New Grid:** The new grid now contains the shifted elements.

*   **Runtime Complexity:** O(m\*n), where m is the number of rows and n is the number of columns in the grid.  **Storage Complexity:** O(m\*n) due to the creation of a new grid.

	
	# Code
	```python
	def shiftGrid(grid, k):
    m = len(grid)
    n = len(grid[0])
    k = k % (m * n)  # Normalize k to handle large shifts

    new_grid = [[0] * n for _ in range(m)]

    for i in range(m):
        for j in range(n):
            original_index = i * n + j
            new_index = (original_index + k) % (m * n)
            new_i = new_index // n
            new_j = new_index % n
            new_grid[new_i][new_j] = grid[i][j]

    return new_grid
	```