Added tasks 2614-2618

Author: ThanhNIT

src/main/java/g2601_2700/s2614_prime_in_diagonal/Solution.java

@@ -0,0 +1,41 @@
+package g2601_2700.s2614_prime_in_diagonal;
+
+// #Easy #Array #Math #Matrix #Number_Theory #2023_08_30_Time_0_ms_(100.00%)_Space_56.5_MB_(21.81%)
+
+public class Solution {
+    public int diagonalPrime(int[][] nums) {
+        int i = 0;
+        int j = nums[0].length - 1;
+        int lp = 0;
+        while (i < nums.length) {
+            int n1 = nums[i][i];
+            if (n1 > lp && isPrime(n1)) {
+                lp = n1;
+            }
+            int n2 = nums[i][j];
+            if (n2 > lp && isPrime(n2)) {
+                lp = n2;
+            }
+            i++;
+            j--;
+        }
+        return lp;
+    }
+
+    private boolean isPrime(int n) {
+        if (n == 1) {
+            return false;
+        }
+        if (n == 2 || n == 3) {
+            return true;
+        }
+        int i = 2;
+        while (i <= Math.sqrt(n)) {
+            if (n % i == 0) {
+                return false;
+            }
+            i++;
+        }
+        return true;
+    }
+}

src/main/java/g2601_2700/s2614_prime_in_diagonal/readme.md

@@ -0,0 +1,38 @@
+2614\. Prime In Diagonal
+
+Easy
+
+You are given a 0-indexed two-dimensional integer array `nums`.
+
+Return _the largest **prime** number that lies on at least one of the **diagonals** of_ `nums`. In case, no prime is present on any of the diagonals, return _0._
+
+Note that:
+
+*   An integer is **prime** if it is greater than `1` and has no positive integer divisors other than `1` and itself.
+*   An integer `val` is on one of the **diagonals** of `nums` if there exists an integer `i` for which `nums[i][i] = val` or an `i` for which `nums[i][nums.length - i - 1] = val`.
+
+![](https://assets.leetcode.com/uploads/2023/03/06/screenshot-2023-03-06-at-45648-pm.png)
+
+In the above diagram, one diagonal is **[1,5,9]** and another diagonal is **[3,5,7]**.
+
+**Example 1:**
+
+**Input:** nums = [[1,2,3],[5,6,7],[9,10,11]]
+
+**Output:** 11
+
+**Explanation:** The numbers 1, 3, 6, 9, and 11 are the only numbers present on at least one of the diagonals. Since 11 is the largest prime, we return 11.
+
+**Example 2:**
+
+**Input:** nums = [[1,2,3],[5,17,7],[9,11,10]]
+
+**Output:** 17
+
+**Explanation:** The numbers 1, 3, 9, 10, and 17 are all present on at least one of the diagonals. 17 is the largest prime, so we return 17.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 300`
+*   <code>nums.length == nums<sub>i</sub>.length</code>
+*   <code>1 <= nums[i][j] <= 4*10<sup>6</sup></code>

src/main/java/g2601_2700/s2615_sum_of_distances/Solution.java

@@ -0,0 +1,25 @@
+package g2601_2700.s2615_sum_of_distances;
+
+// #Medium #Array #Hash_Table #Prefix_Sum #2023_08_30_Time_13_ms_(100.00%)_Space_70.4_MB_(43.45%)
+
+import java.util.HashMap;
+
+public class Solution {
+    public long[] distance(int[] nums) {
+        HashMap<Integer, long[]> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            long[] temp = map.computeIfAbsent(nums[i], k -> new long[4]);
+            temp[0] += i;
+            temp[2]++;
+        }
+        long[] ans = new long[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            long[] temp = map.get(nums[i]);
+            ans[i] += i * temp[3] - temp[1];
+            temp[1] += i;
+            temp[3]++;
+            ans[i] += temp[0] - temp[1] - i * (temp[2] - temp[3]);
+        }
+        return ans;
+    }
+}

src/main/java/g2601_2700/s2615_sum_of_distances/readme.md

@@ -0,0 +1,38 @@
+2615\. Sum of Distances
+
+Medium
+
+You are given a **0-indexed** integer array `nums`. There exists an array `arr` of length `nums.length`, where `arr[i]` is the sum of `|i - j|` over all `j` such that `nums[j] == nums[i]` and `j != i`. If there is no such `j`, set `arr[i]` to be `0`.
+
+Return _the array_ `arr`_._
+
+**Example 1:**
+
+**Input:** nums = [1,3,1,1,2]
+
+**Output:** [5,0,3,4,0]
+
+**Explanation:**
+
+When i = 0, nums[0] == nums[2] and nums[0] == nums[3]. Therefore, arr[0] = |0 - 2| + |0 - 3| = 5.
+
+When i = 1, arr[1] = 0 because there is no other index with value 3.
+
+When i = 2, nums[2] == nums[0] and nums[2] == nums[3]. Therefore, arr[2] = |2 - 0| + |2 - 3| = 3.
+
+When i = 3, nums[3] == nums[0] and nums[3] == nums[2]. Therefore, arr[3] = |3 - 0| + |3 - 2| = 4.
+
+When i = 4, arr[4] = 0 because there is no other index with value 2.
+
+**Example 2:**
+
+**Input:** nums = [0,5,3]
+
+**Output:** [0,0,0]
+
+**Explanation:** Since each element in nums is distinct, arr[i] = 0 for all i.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2601_2700/s2616_minimize_the_maximum_difference_of_pairs/Solution.java

@@ -0,0 +1,38 @@
+package g2601_2700.s2616_minimize_the_maximum_difference_of_pairs;
+
+// #Medium #Array #Greedy #Binary_Search #2023_08_30_Time_16_ms_(91.77%)_Space_58.7_MB_(90.15%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private boolean isPossible(int[] nums, int p, int diff) {
+        int n = nums.length;
+        int i = 1;
+        while (i < n) {
+            if (nums[i] - nums[i - 1] <= diff) {
+                p--;
+                i++;
+            }
+            i++;
+        }
+        return p <= 0;
+    }
+
+    public int minimizeMax(int[] nums, int p) {
+        int n = nums.length;
+        Arrays.sort(nums);
+        int left = 0;
+        int right = nums[n - 1] - nums[0];
+        int ans = right;
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            if (isPossible(nums, p, mid)) {
+                ans = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2601_2700/s2616_minimize_the_maximum_difference_of_pairs/readme.md

@@ -0,0 +1,37 @@
+2616\. Minimize the Maximum Difference of Pairs
+
+Medium
+
+You are given a **0-indexed** integer array `nums` and an integer `p`. Find `p` pairs of indices of `nums` such that the **maximum** difference amongst all the pairs is **minimized**. Also, ensure no index appears more than once amongst the `p` pairs.
+
+Note that for a pair of elements at the index `i` and `j`, the difference of this pair is `|nums[i] - nums[j]|`, where `|x|` represents the **absolute** **value** of `x`.
+
+Return _the **minimum** **maximum** difference among all_ `p` _pairs._ We define the maximum of an empty set to be zero.
+
+**Example 1:**
+
+**Input:** nums = [10,1,2,7,1,3], p = 2
+
+**Output:** 1
+
+**Explanation:**
+
+The first pair is formed from the indices 1 and 4, and the second pair is formed from the indices 2 and 5.
+
+The maximum difference is max(|nums[1] - nums[4]|, |nums[2] - nums[5]|) = max(0, 1) = 1. Therefore, we return 1.
+
+**Example 2:**
+
+**Input:** nums = [4,2,1,2], p = 1
+
+**Output:** 0
+
+**Explanation:**
+
+Let the indices 1 and 3 form a pair. The difference of that pair is |2 - 2| = 0, which is the minimum we can attain.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>
+*   `0 <= p <= (nums.length)/2`

src/main/java/g2601_2700/s2617_minimum_number_of_visited_cells_in_a_grid/Solution.java

@@ -0,0 +1,58 @@
+package g2601_2700.s2617_minimum_number_of_visited_cells_in_a_grid;
+
+// #Hard #Array #Dynamic_Programming #Binary_Search #Stack #Union_Find #Segment_Tree
+// #Binary_Indexed_Tree #2023_08_30_Time_34_ms_(100.00%)_Space_76_MB_(65.00%)
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+public class Solution {
+    private static final int LIMIT = 2;
+
+    public int minimumVisitedCells(int[][] grid) {
+        int[][] len = new int[grid.length][grid[0].length];
+        for (int[] ints : len) {
+            Arrays.fill(ints, -1);
+        }
+        Queue<int[]> q = new ArrayDeque<>();
+        q.add(new int[] {0, 0});
+        len[0][0] = 1;
+        while (!q.isEmpty()) {
+            int[] tmp = q.poll();
+            int i = tmp[0];
+            int j = tmp[1];
+            int c = 0;
+            for (int k = Math.min(grid[0].length - 1, grid[i][j] + j); k > j; k--) {
+                if (len[i][k] != -1) {
+                    c++;
+                    if (c > LIMIT) {
+                        break;
+                    }
+                } else {
+                    len[i][k] = len[i][j] + 1;
+                    q.add(new int[] {i, k});
+                }
+            }
+            if (len[grid.length - 1][grid[0].length - 1] != -1) {
+                return len[grid.length - 1][grid[0].length - 1];
+            }
+            c = 0;
+            for (int k = Math.min(grid.length - 1, grid[i][j] + i); k > i; k--) {
+                if (len[k][j] != -1) {
+                    c++;
+                    if (c > LIMIT) {
+                        break;
+                    }
+                } else {
+                    len[k][j] = len[i][j] + 1;
+                    q.add(new int[] {k, j});
+                }
+            }
+            if (len[grid.length - 1][grid[0].length - 1] != -1) {
+                return len[grid.length - 1][grid[0].length - 1];
+            }
+        }
+        return -1;
+    }
+}

src/main/java/g2601_2700/s2617_minimum_number_of_visited_cells_in_a_grid/readme.md

@@ -0,0 +1,51 @@
+2617\. Minimum Number of Visited Cells in a Grid
+
+Hard
+
+You are given a **0-indexed** `m x n` integer matrix `grid`. Your initial position is at the **top-left** cell `(0, 0)`.
+
+Starting from the cell `(i, j)`, you can move to one of the following cells:
+
+*   Cells `(i, k)` with `j < k <= grid[i][j] + j` (rightward movement), or
+*   Cells `(k, j)` with `i < k <= grid[i][j] + i` (downward movement).
+
+Return _the minimum number of cells you need to visit to reach the **bottom-right** cell_ `(m - 1, n - 1)`. If there is no valid path, return `-1`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/01/25/ex1.png)
+
+**Input:** grid = [[3,4,2,1],[4,2,3,1],[2,1,0,0],[2,4,0,0]]
+
+**Output:** 4
+
+**Explanation:** The image above shows one of the paths that visits exactly 4 cells.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/01/25/ex2.png)
+
+**Input:** grid = [[3,4,2,1],[4,2,1,1],[2,1,1,0],[3,4,1,0]]
+
+**Output:** 3
+
+**Explanation:** The image above shows one of the paths that visits exactly 3 cells.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2023/01/26/ex3.png)
+
+**Input:** grid = [[2,1,0],[1,0,0]]
+
+**Output:** -1
+
+**Explanation:** It can be proven that no path exists.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   <code>1 <= m * n <= 10<sup>5</sup></code>
+*   `0 <= grid[i][j] < m * n`
+*   `grid[m - 1][n - 1] == 0`

src/main/java/g2601_2700/s2618_check_if_object_instance_of_class/readme.md

@@ -0,0 +1,47 @@
+2618\. Check if Object Instance of Class
+
+Medium
+
+Write a function that checks if a given value is an instance of a given class or superclass. For this problem, an object is considered an instance of a given class if that object has access to that class's methods.
+
+There are no constraints on the data types that can be passed to the function. For example, the value or the class could be `undefined`.
+
+**Example 1:**
+
+**Input:** func = () => checkIfInstanceOf(new Date(), Date)
+
+**Output:** true
+
+**Explanation:** The object returned by the Date constructor is, by definition, an instance of Date.
+
+**Example 2:**
+
+**Input:** func = () => { class Animal {}; class Dog extends Animal {}; return checkIfInstanceOf(new Dog(), Animal); }
+
+**Output:** true
+
+**Explanation:** 
+
+class Animal {}; 
+
+class Dog extends Animal {}; 
+
+checkIfInstanceOf(new Dog(), Animal); // true 
+
+Dog is a subclass of Animal. Therefore, a Dog object is an instance of both Dog and Animal.
+
+**Example 3:**
+
+**Input:** func = () => checkIfInstanceOf(Date, Date)
+
+**Output:** false
+
+**Explanation:** A date constructor cannot logically be an instance of itself.
+
+**Example 4:**
+
+**Input:** func = () => checkIfInstanceOf(5, Number)
+
+**Output:** true
+
+**Explanation:** 5 is a Number. Note that the "instanceof" keyword would return false. However, it is still considered an instance of Number because it accesses the Number methods. For example "toFixed()".