Added tasks 3026-3030

Author: ThanhNIT

Diff for: src/main/java/g3001_3100/s3026_maximum_good_subarray_sum/Solution.java

@@ -0,0 +1,40 @@
+package g3001_3100.s3026_maximum_good_subarray_sum;
+
+// #Medium #Array #Hash_Table #Prefix_Sum #2024_03_01_Time_62_ms_(93.52%)_Space_56.2_MB_(95.77%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    private static final int NO_GOOD_SUBARRAYS = 0;
+
+    public long maximumSubarraySum(int[] input, int targetDifference) {
+        Map<Integer, Long> valueToMinPrefixSum = new HashMap<>();
+        long prefixSum = 0;
+        long maxSubarraySum = Long.MIN_VALUE;
+        for (int value : input) {
+            if (valueToMinPrefixSum.containsKey(value + targetDifference)) {
+                maxSubarraySum =
+                        Math.max(
+                                maxSubarraySum,
+                                prefixSum
+                                        + value
+                                        - valueToMinPrefixSum.get(value + targetDifference));
+            }
+            if (valueToMinPrefixSum.containsKey(value - targetDifference)) {
+                maxSubarraySum =
+                        Math.max(
+                                maxSubarraySum,
+                                prefixSum
+                                        + value
+                                        - valueToMinPrefixSum.get(value - targetDifference));
+            }
+            if (!valueToMinPrefixSum.containsKey(value)
+                    || valueToMinPrefixSum.get(value) > prefixSum) {
+                valueToMinPrefixSum.put(value, prefixSum);
+            }
+            prefixSum += value;
+        }
+        return maxSubarraySum != Long.MIN_VALUE ? maxSubarraySum : NO_GOOD_SUBARRAYS;
+    }
+}

Diff for: src/main/java/g3001_3100/s3026_maximum_good_subarray_sum/readme.md

@@ -0,0 +1,39 @@
+3026\. Maximum Good Subarray Sum
+
+Medium
+
+You are given an array `nums` of length `n` and a **positive** integer `k`.
+
+A subarray of `nums` is called **good** if the **absolute difference** between its first and last element is **exactly** `k`, in other words, the subarray `nums[i..j]` is good if `|nums[i] - nums[j]| == k`.
+
+Return _the **maximum** sum of a **good** subarray of_ `nums`. _If there are no good subarrays__, return_ `0`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5,6], k = 1
+
+**Output:** 11
+
+**Explanation:** The absolute difference between the first and last element must be 1 for a good subarray. All the good subarrays are: [1,2], [2,3], [3,4], [4,5], and [5,6]. The maximum subarray sum is 11 for the subarray [5,6].
+
+**Example 2:**
+
+**Input:** nums = [-1,3,2,4,5], k = 3
+
+**Output:** 11
+
+**Explanation:** The absolute difference between the first and last element must be 3 for a good subarray. All the good subarrays are: [-1,3,2], and [2,4,5]. The maximum subarray sum is 11 for the subarray [2,4,5].
+
+**Example 3:**
+
+**Input:** nums = [-1,-2,-3,-4], k = 2
+
+**Output:** -6
+
+**Explanation:** The absolute difference between the first and last element must be 2 for a good subarray. All the good subarrays are: [-1,-2,-3], and [-2,-3,-4]. The maximum subarray sum is -6 for the subarray [-1,-2,-3].
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>1 <= k <= 10<sup>9</sup></code>

Diff for: src/main/java/g3001_3100/s3027_find_the_number_of_ways_to_place_people_ii/Solution.java

@@ -0,0 +1,30 @@
+package g3001_3100.s3027_find_the_number_of_ways_to_place_people_ii;
+
+// #Hard #Array #Math #Sorting #Enumeration #Geometry
+// #2024_03_01_Time_59_ms_(69.95%)_Space_45.3_MB_(20.75%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int customCompare(int[] p1, int[] p2) {
+        if (p1[0] != p2[0]) {
+            return Integer.signum(p1[0] - p2[0]);
+        }
+        return Integer.signum(p2[1] - p1[1]);
+    }
+
+    public int numberOfPairs(int[][] points) {
+        Arrays.sort(points, this::customCompare);
+        int count = 0;
+        for (int i = 0; i < points.length; ++i) {
+            int m = Integer.MIN_VALUE;
+            for (int j = i + 1; j < points.length; ++j) {
+                if ((points[i][1] >= points[j][1]) && (points[j][1] > m)) {
+                    m = points[j][1];
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+}

Diff for: src/main/java/g3001_3100/s3027_find_the_number_of_ways_to_place_people_ii/readme.md

@@ -0,0 +1,63 @@
+3027\. Find the Number of Ways to Place People II
+
+Hard
+
+You are given a 2D array `points` of size `n x 2` representing integer coordinates of some points on a 2D-plane, where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>.
+
+We define the **right** direction as positive x-axis (**increasing x-coordinate**) and the **left** direction as negative x-axis (**decreasing x-coordinate**). Similarly, we define the **up** direction as positive y-axis (**increasing y-coordinate**) and the **down** direction as negative y-axis (**decreasing y-coordinate**)
+
+You have to place `n` people, including Alice and Bob, at these points such that there is **exactly one** person at every point. Alice wants to be alone with Bob, so Alice will build a rectangular fence with Alice's position as the **upper left corner** and Bob's position as the **lower right corner** of the fence (**Note** that the fence **might not** enclose any area, i.e. it can be a line). If any person other than Alice and Bob is either **inside** the fence or **on** the fence, Alice will be sad.
+
+Return _the number of **pairs of points** where you can place Alice and Bob, such that Alice **does not** become sad on building the fence_.
+
+**Note** that Alice can only build a fence with Alice's position as the upper left corner, and Bob's position as the lower right corner. For example, Alice cannot build either of the fences in the picture below with four corners `(1, 1)`, `(1, 3)`, `(3, 1)`, and `(3, 3)`, because:
+
+*   With Alice at `(3, 3)` and Bob at `(1, 1)`, Alice's position is not the upper left corner and Bob's position is not the lower right corner of the fence.
+*   With Alice at `(1, 3)` and Bob at `(1, 1)`, Bob's position is not the lower right corner of the fence.
+
+![](https://assets.leetcode.com/uploads/2024/01/04/example0alicebob-1.png)
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2024/01/04/example1alicebob.png)
+
+**Input:** points = [[1,1],[2,2],[3,3]]
+
+**Output:** 0
+
+**Explanation:** There is no way to place Alice and Bob such that Alice can build a fence with Alice's position as the upper left corner and Bob's position as the lower right corner. Hence we return 0.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2024/02/04/example2alicebob.png)
+
+**Input:** points = [[6,2],[4,4],[2,6]]
+
+**Output:** 2
+
+**Explanation:** There are two ways to place Alice and Bob such that Alice will not be sad: 
+- Place Alice at (4, 4) and Bob at (6, 2). 
+- Place Alice at (2, 6) and Bob at (4, 4). You cannot place Alice at (2, 6) and Bob at (6, 2) because the person at (4, 4) will be inside the fence.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2024/02/04/example4alicebob.png)
+
+**Input:** points = [[3,1],[1,3],[1,1]]
+
+**Output:** 2
+
+**Explanation:** There are two ways to place Alice and Bob such that Alice will not be sad: 
+- Place Alice at (1, 1) and Bob at (3, 1). 
+- Place Alice at (1, 3) and Bob at (1, 1). 
+
+You cannot place Alice at (1, 3) and Bob at (3, 1) because the person at (1, 1) will be on the fence. 
+
+Note that it does not matter if the fence encloses any area, the first and second fences in the image are valid.
+
+**Constraints:**
+
+*   `2 <= n <= 1000`
+*   `points[i].length == 2`
+*   <code>-10<sup>9</sup> <= points[i][0], points[i][1] <= 10<sup>9</sup></code>
+*   All `points[i]` are distinct.

Diff for: src/main/java/g3001_3100/s3028_ant_on_the_boundary/Solution.java

@@ -0,0 +1,17 @@
+package g3001_3100.s3028_ant_on_the_boundary;
+
+// #Easy #Array #Simulation #Prefix_Sum #2024_03_01_Time_0_ms_(100.00%)_Space_42.1_MB_(53.10%)
+
+public class Solution {
+    public int returnToBoundaryCount(int[] nums) {
+        int ans = 0;
+        int num = 0;
+        for (int n : nums) {
+            num += n;
+            if (num == 0) {
+                ans++;
+            }
+        }
+        return ans;
+    }
+}

Diff for: src/main/java/g3001_3100/s3028_ant_on_the_boundary/readme.md

@@ -0,0 +1,51 @@
+3028\. Ant on the Boundary
+
+Easy
+
+An ant is on a boundary. It sometimes goes **left** and sometimes **right**.
+
+You are given an array of **non-zero** integers `nums`. The ant starts reading `nums` from the first element of it to its end. At each step, it moves according to the value of the current element:
+
+*   If `nums[i] < 0`, it moves **left** by `-nums[i]` units.
+*   If `nums[i] > 0`, it moves **right** by `nums[i]` units.
+
+Return _the number of times the ant **returns** to the boundary._
+
+**Notes:**
+
+*   There is an infinite space on both sides of the boundary.
+*   We check whether the ant is on the boundary only after it has moved `|nums[i]|` units. In other words, if the ant crosses the boundary during its movement, it does not count.
+
+**Example 1:**
+
+**Input:** nums = [2,3,-5]
+
+**Output:** 1
+
+**Explanation:** After the first step, the ant is 2 steps to the right of the boundary. 
+
+After the second step, the ant is 5 steps to the right of the boundary. 
+
+After the third step, the ant is on the boundary. So the answer is 1.
+
+**Example 2:**
+
+**Input:** nums = [3,2,-3,-4]
+
+**Output:** 0
+
+**Explanation:** After the first step, the ant is 3 steps to the right of the boundary. 
+
+After the second step, the ant is 5 steps to the right of the boundary. 
+
+After the third step, the ant is 2 steps to the right of the boundary. 
+
+After the fourth step, the ant is 2 steps to the left of the boundary. 
+
+The ant never returned to the boundary, so the answer is 0.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `-10 <= nums[i] <= 10`
+*   `nums[i] != 0`

Diff for: src/main/java/g3001_3100/s3029_minimum_time_to_revert_word_to_initial_state_i/Solution.java

@@ -0,0 +1,16 @@
+package g3001_3100.s3029_minimum_time_to_revert_word_to_initial_state_i;
+
+// #Medium #String #Hash_Function #String_Matching #Rolling_Hash
+// #2024_03_01_Time_1_ms_(99.70%)_Space_42.7_MB_(8.42%)
+
+public class Solution {
+    public int minimumTimeToInitialState(String word, int k) {
+        int n = word.length();
+        for (int i = k; i < n; i += k) {
+            if (word.substring(i, n).equals(word.substring(0, n - i))) {
+                return i / k;
+            }
+        }
+        return (n + k - 1) / k;
+    }
+}

Diff for: src/main/java/g3001_3100/s3029_minimum_time_to_revert_word_to_initial_state_i/readme.md

@@ -0,0 +1,44 @@
+3029\. Minimum Time to Revert Word to Initial State I
+
+Medium
+
+You are given a **0-indexed** string `word` and an integer `k`.
+
+At every second, you must perform the following operations:
+
+*   Remove the first `k` characters of `word`.
+*   Add any `k` characters to the end of `word`.
+
+**Note** that you do not necessarily need to add the same characters that you removed. However, you must perform **both** operations at every second.
+
+Return _the **minimum** time greater than zero required for_ `word` _to revert to its **initial** state_.
+
+**Example 1:**
+
+**Input:** word = "abacaba", k = 3
+
+**Output:** 2
+
+**Explanation:** At the 1st second, we remove characters "aba" from the prefix of word, and add characters "bac" to the end of word. Thus, word becomes equal to "cababac". At the 2nd second, we remove characters "cab" from the prefix of word, and add "aba" to the end of word. Thus, word becomes equal to "abacaba" and reverts to its initial state. It can be shown that 2 seconds is the minimum time greater than zero required for word to revert to its initial state.
+
+**Example 2:**
+
+**Input:** word = "abacaba", k = 4
+
+**Output:** 1
+
+**Explanation:** At the 1st second, we remove characters "abac" from the prefix of word, and add characters "caba" to the end of word. Thus, word becomes equal to "abacaba" and reverts to its initial state. It can be shown that 1 second is the minimum time greater than zero required for word to revert to its initial state.
+
+**Example 3:**
+
+**Input:** word = "abcbabcd", k = 2
+
+**Output:** 4
+
+**Explanation:** At every second, we will remove the first 2 characters of word, and add the same characters to the end of word. After 4 seconds, word becomes equal to "abcbabcd" and reverts to its initial state. It can be shown that 4 seconds is the minimum time greater than zero required for word to revert to its initial state.
+
+**Constraints:**
+
+*   `1 <= word.length <= 50`
+*   `1 <= k <= word.length`
+*   `word` consists only of lowercase English letters.

Diff for: src/main/java/g3001_3100/s3030_find_the_grid_of_region_average/Solution.java

@@ -0,0 +1,65 @@
+package g3001_3100.s3030_find_the_grid_of_region_average;
+
+// #Medium #Array #Matrix #2024_03_01_Time_53_ms_(98.79%)_Space_88.4_MB_(35.20%)
+
+public class Solution {
+    public int[][] resultGrid(int[][] image, int threshold) {
+        int n = image.length;
+        int m = image[0].length;
+        int[][] intensity = new int[n][m];
+        int[][] count = new int[n][m];
+        for (int i = 1; i < n - 1; i++) {
+            for (int j = 1; j < m - 1; j++) {
+                boolean regionPossible = true;
+                int regionSum = 0;
+                int r0c0 = image[i - 1][j - 1];
+                int r0c1 = image[i - 1][j];
+                int r0c2 = image[i - 1][j + 1];
+                int r1c0 = image[i][j - 1];
+                int r1c1 = image[i][j];
+                int r1c2 = image[i][j + 1];
+                int r2c0 = image[i + 1][j - 1];
+                int r2c1 = image[i + 1][j];
+                int r2c2 = image[i + 1][j + 1];
+                regionSum += (r0c0 + r0c1 + r0c2 + r1c0 + r1c1 + r1c2 + r2c0 + r2c1 + r2c2);
+                if (Math.abs(r0c0 - r0c1) > threshold
+                        || Math.abs(r0c0 - r1c0) > threshold
+                        || Math.abs(r0c1 - r0c0) > threshold
+                        || Math.abs(r0c1 - r1c1) > threshold
+                        || Math.abs(r0c1 - r0c2) > threshold
+                        || Math.abs(r0c2 - r0c1) > threshold
+                        || Math.abs(r0c2 - r1c2) > threshold
+                        || Math.abs(r1c0 - r1c1) > threshold
+                        || Math.abs(r1c2 - r1c1) > threshold
+                        || Math.abs(r2c0 - r2c1) > threshold
+                        || Math.abs(r2c0 - r1c0) > threshold
+                        || Math.abs(r2c1 - r2c0) > threshold
+                        || Math.abs(r2c1 - r1c1) > threshold
+                        || Math.abs(r2c1 - r2c2) > threshold
+                        || Math.abs(r2c2 - r2c1) > threshold
+                        || Math.abs(r2c2 - r1c2) > threshold) {
+                    regionPossible = false;
+                }
+                if (regionPossible) {
+                    regionSum /= 9;
+                    for (int k = -1; k <= 1; k++) {
+                        for (int l = -1; l <= 1; l++) {
+                            intensity[i + k][j + l] += regionSum;
+                            count[i + k][j + l]++;
+                        }
+                    }
+                }
+            }
+        }
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (count[i][j] == 0) {
+                    intensity[i][j] = image[i][j];
+                } else {
+                    intensity[i][j] = intensity[i][j] / count[i][j];
+                }
+            }
+        }
+        return intensity;
+    }
+}

Diff for: src/main/java/g3001_3100/s3030_find_the_grid_of_region_average/readme.md

@@ -0,0 +1,49 @@
+3030\. Find the Grid of Region Average
+
+Medium
+
+You are given a **0-indexed** `m x n` grid `image` which represents a grayscale image, where `image[i][j]` represents a pixel with intensity in the range`[0..255]`. You are also given a **non-negative** integer `threshold`.
+
+Two pixels `image[a][b]` and `image[c][d]` are said to be **adjacent** if `|a - c| + |b - d| == 1`.
+
+A **region** is a `3 x 3` subgrid where the **absolute difference** in intensity between any two **adjacent** pixels is **less than or equal to** `threshold`.
+
+All pixels in a **region** belong to that region, note that a pixel **can** belong to **multiple** regions.
+
+You need to calculate a **0-indexed** `m x n` grid `result`, where `result[i][j]` is the **average** intensity of the region to which `image[i][j]` belongs, **rounded down** to the nearest integer. If `image[i][j]` belongs to multiple regions, `result[i][j]` is the **average** of the **rounded down average** intensities of these regions, **rounded down** to the nearest integer. If `image[i][j]` does **not** belong to any region, `result[i][j]` is **equal to** `image[i][j]`.
+
+Return _the grid_ `result`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/12/21/example0corrected.png)
+
+**Input:** image = [[5,6,7,10],[8,9,10,10],[11,12,13,10]], threshold = 3
+
+**Output:** [[9,9,9,9],[9,9,9,9],[9,9,9,9]]
+
+**Explanation:** There exist two regions in the image, which are shown as the shaded areas in the picture. The average intensity of the first region is 9, while the average intensity of the second region is 9.67 which is rounded down to 9. The average intensity of both of the regions is (9 + 9) / 2 = 9. As all the pixels belong to either region 1, region 2, or both of them, the intensity of every pixel in the result is 9. Please note that the rounded-down values are used when calculating the average of multiple regions, hence the calculation is done using 9 as the average intensity of region 2, not 9.67.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/12/21/example1corrected.png)
+
+**Input:** image = [[10,20,30],[15,25,35],[20,30,40],[25,35,45]], threshold = 12
+
+**Output:** [[25,25,25],[27,27,27],[27,27,27],[30,30,30]]
+
+**Explanation:** There exist two regions in the image, which are shown as the shaded areas in the picture. The average intensity of the first region is 25, while the average intensity of the second region is 30. The average intensity of both of the regions is (25 + 30) / 2 = 27.5 which is rounded down to 27. All the pixels in row 0 of the image belong to region 1, hence all the pixels in row 0 in the result are 25. Similarly, all the pixels in row 3 in the result are 30. The pixels in rows 1 and 2 of the image belong to region 1 and region 2, hence their assigned value is 27 in the result.
+
+**Example 3:**
+
+**Input:** image = [[5,6,7],[8,9,10],[11,12,13]], threshold = 1
+
+**Output:** [[5,6,7],[8,9,10],[11,12,13]]
+
+**Explanation:** There does not exist any region in image, hence result[i][j] == image[i][j] for all the pixels.
+
+**Constraints:**
+
+*   `3 <= n, m <= 500`
+*   `0 <= image[i][j] <= 255`
+*   `0 <= threshold <= 255`

Diff for: src/test/java/g3001_3100/s3026_maximum_good_subarray_sum/SolutionTest.java

@@ -0,0 +1,24 @@
+package g3001_3100.s3026_maximum_good_subarray_sum;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maximumSubarraySum() {
+        assertThat(
+                new Solution().maximumSubarraySum(new int[] {1, 2, 3, 4, 5, 6}, 1), equalTo(11L));
+    }
+
+    @Test
+    void maximumSubarraySum2() {
+        assertThat(new Solution().maximumSubarraySum(new int[] {-1, 3, 2, 4, 5}, 3), equalTo(11L));
+    }
+
+    @Test
+    void maximumSubarraySum3() {
+        assertThat(new Solution().maximumSubarraySum(new int[] {-1, -2, -3, -4}, 2), equalTo(-6L));
+    }
+}

Diff for: src/test/java/g3001_3100/s3027_find_the_number_of_ways_to_place_people_ii/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3001_3100.s3027_find_the_number_of_ways_to_place_people_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numberOfPairs() {
+        assertThat(new Solution().numberOfPairs(new int[][] {{1, 1}, {2, 2}, {3, 3}}), equalTo(0));
+    }
+
+    @Test
+    void numberOfPairs2() {
+        assertThat(new Solution().numberOfPairs(new int[][] {{6, 2}, {4, 4}, {2, 6}}), equalTo(2));
+    }
+
+    @Test
+    void numberOfPairs3() {
+        assertThat(new Solution().numberOfPairs(new int[][] {{3, 1}, {1, 3}, {1, 1}}), equalTo(2));
+    }
+}

Diff for: src/test/java/g3001_3100/s3028_ant_on_the_boundary/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3001_3100.s3028_ant_on_the_boundary;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void returnToBoundaryCount() {
+        assertThat(new Solution().returnToBoundaryCount(new int[] {2, 3, -5}), equalTo(1));
+    }
+
+    @Test
+    void returnToBoundaryCount2() {
+        assertThat(new Solution().returnToBoundaryCount(new int[] {3, 2, -3, -4}), equalTo(0));
+    }
+}

Diff for: src/test/java/g3001_3100/s3029_minimum_time_to_revert_word_to_initial_state_i/SolutionTest.java

@@ -0,0 +1,23 @@
+package g3001_3100.s3029_minimum_time_to_revert_word_to_initial_state_i;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumTimeToInitialState() {
+        assertThat(new Solution().minimumTimeToInitialState("abacaba", 3), equalTo(2));
+    }
+
+    @Test
+    void minimumTimeToInitialState2() {
+        assertThat(new Solution().minimumTimeToInitialState("abacaba", 4), equalTo(1));
+    }
+
+    @Test
+    void minimumTimeToInitialState3() {
+        assertThat(new Solution().minimumTimeToInitialState("abcbabcd", 2), equalTo(4));
+    }
+}

Diff for: src/test/java/g3001_3100/s3030_find_the_grid_of_region_average/SolutionTest.java

@@ -0,0 +1,51 @@
+package g3001_3100.s3030_find_the_grid_of_region_average;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.CommonUtils;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void resultGrid() {
+        assertThat(
+                new Solution()
+                        .resultGrid(
+                                CommonUtils
+                                        .convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray(
+                                                "[5,6,7,10],[8,9,10,10],[11,12,13,10]"),
+                                3),
+                equalTo(
+                        CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray(
+                                "[9,9,9,9],[9,9,9,9],[9,9,9,9]")));
+    }
+
+    @Test
+    void resultGrid2() {
+        assertThat(
+                new Solution()
+                        .resultGrid(
+                                CommonUtils
+                                        .convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray(
+                                                "[10,20,30],[15,25,35],[20,30,40],[25,35,45]"),
+                                12),
+                equalTo(
+                        CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray(
+                                "[25,25,25],[27,27,27],[27,27,27],[30,30,30]")));
+    }
+
+    @Test
+    void resultGrid3() {
+        assertThat(
+                new Solution()
+                        .resultGrid(
+                                CommonUtils
+                                        .convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray(
+                                                "[5,6,7],[8,9,10],[11,12,13]"),
+                                1),
+                equalTo(
+                        CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray(
+                                "[5,6,7],[8,9,10],[11,12,13]")));
+    }
+}