add 1260

Author: fishercoder1534

README.md

@@ -9,6 +9,7 @@ _If you like this project, please leave me a star._ ★
 |  #  |      Title     |   Solutions   | Time          | Space         | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
 |1266|[Minimum Time Visiting All Points](https://leetcode.com/problems/minimum-time-visiting-all-points/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1266.java) |  |  | |Easy||
+|1260|[Shift 2D Grid](https://leetcode.com/problems/shift-2d-grid/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1260.java) |  |  | |Easy||
 |1252|[Cells with Odd Values in a Matrix](https://leetcode.com/problems/cells-with-odd-values-in-a-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1252.java) | O(m*n + k) | O(m*n) | |Easy||
 |1237|[Find Positive Integer Solution for a Given Equation](https://leetcode.com/problems/find-positive-integer-solution-for-a-given-equation/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1237.java) | | | |Easy||
 |1217|[Play with Chips](https://leetcode.com/problems/play-with-chips/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1217.java) |  |  | |Easy||

src/main/java/com/fishercoder/solutions/_1260.java

@@ -0,0 +1,58 @@
+package com.fishercoder.solutions;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 1260. Shift 2D Grid
+ *
+ * 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] becomes at grid[i][j + 1].
+ * Element at grid[i][n - 1] becomes at grid[i + 1][0].
+ * Element at grid[n - 1][n - 1] becomes at 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
+ * */
+public class _1260 {
+    public static class Solution1 {
+        /**credit: https://leetcode.com/problems/shift-2d-grid/discuss/431102/JavaPython-3-simple-code-using-mod*/
+        public List<List<Integer>> shiftGrid(int[][] grid, int k) {
+            int m = grid.length;
+            int n = grid[0].length;
+            int start = m * n - k % (m * n);
+            LinkedList<List<Integer>> result = new LinkedList<>();
+            for (int i = start; i < m * n + start; i++) {
+                int newIndex = i % (m * n);
+                int newRow = newIndex / n;
+                int newColumn = newIndex % n;
+                if ((i - start) % n == 0) {
+                    result.add(new ArrayList<>());
+                }
+                result.peekLast().add(grid[newRow][newColumn]);
+            }
+            return result;
+        }
+    }
+}

src/test/java/com/fishercoder/_1260Test.java

@@ -0,0 +1,78 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._1260;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1260Test {
+    private static _1260.Solution1 solution1;
+    private static int[][] grid;
+    private static List<List<Integer>> expected;
+    ;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1260.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        grid = new int[][]{
+                {1, 2, 3},
+                {4, 5, 6},
+                {7, 8, 9}
+        };
+        expected = Arrays.asList(
+                Arrays.asList(9, 1, 2),
+                Arrays.asList(3, 4, 5),
+                Arrays.asList(6, 7, 8)
+        );
+        assertEquals(expected, solution1.shiftGrid(grid, 1));
+    }
+
+    @Test
+    public void test2() {
+        grid = new int[][]{
+                {1},
+                {2},
+                {3},
+                {4},
+                {7},
+                {6},
+                {5}
+        };
+        expected = Arrays.asList(
+                Arrays.asList(6),
+                Arrays.asList(5),
+                Arrays.asList(1),
+                Arrays.asList(2),
+                Arrays.asList(3),
+                Arrays.asList(4),
+                Arrays.asList(7)
+        );
+        assertEquals(expected, solution1.shiftGrid(grid, 23));
+    }
+
+    @Test
+    public void test3() {
+        grid = new int[][]{
+                {3, 8, 1, 9},
+                {19, 7, 2, 5},
+                {4, 6, 11, 10},
+                {12, 0, 21, 13}
+        };
+        expected = Arrays.asList(
+                Arrays.asList(12, 0, 21, 13),
+                Arrays.asList(3, 8, 1, 9),
+                Arrays.asList(19, 7, 2, 5),
+                Arrays.asList(4, 6, 11, 10)
+        );
+        assertEquals(expected, solution1.shiftGrid(grid, 4));
+    }
+
+}