Added tasks 2427, 2428, 2429, 2430.

Author: ThanhNIT

src/main/java/g2401_2500/s2427_number_of_common_factors/Solution.java

@@ -0,0 +1,15 @@
+package g2401_2500.s2427_number_of_common_factors;
+
+// #Easy #Math #Enumeration #Number_Theory #2022_12_07_Time_1_ms_(81.93%)_Space_38.7_MB_(98.17%)
+
+public class Solution {
+    public int commonFactors(int a, int b) {
+        int ans = 0;
+        for (int i = 1; i <= Math.min(a, b); i++) {
+            if (a % i == 0 && b % i == 0) {
+                ans++;
+            }
+        }
+        return ans;
+    }
+}

src/main/java/g2401_2500/s2427_number_of_common_factors/readme.md

@@ -0,0 +1,27 @@
+2427\. Number of Common Factors
+
+Easy
+
+Given two positive integers `a` and `b`, return _the number of **common** factors of_ `a` _and_ `b`.
+
+An integer `x` is a **common factor** of `a` and `b` if `x` divides both `a` and `b`.
+
+**Example 1:**
+
+**Input:** a = 12, b = 6
+
+**Output:** 4
+
+**Explanation:** The common factors of 12 and 6 are 1, 2, 3, 6.
+
+**Example 2:**
+
+**Input:** a = 25, b = 30
+
+**Output:** 2
+
+**Explanation:** The common factors of 25 and 30 are 1, 5.
+
+**Constraints:**
+
+*   `1 <= a, b <= 1000`

src/main/java/g2401_2500/s2428_maximum_sum_of_an_hourglass/Solution.java

@@ -0,0 +1,41 @@
+package g2401_2500.s2428_maximum_sum_of_an_hourglass;
+
+// #Medium #Array #Matrix #Prefix_Sum #2022_12_07_Time_4_ms_(93.51%)_Space_44.1_MB_(86.28%)
+
+public class Solution {
+    public int maxSum(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int res = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (isHourGlass(i, j, m, n)) {
+                    res = Math.max(res, calculate(i, j, grid));
+                } else {
+                    // If we cannot form an hour glass from the current row anymore, just move to
+                    // the next one
+                    break;
+                }
+            }
+        }
+        return res;
+    }
+
+    // Check if an hour glass can be formed from the current position
+    private boolean isHourGlass(int r, int c, int m, int n) {
+        return r + 2 < m && c + 2 < n;
+    }
+
+    // Once we know an hourglass can be formed, just traverse the value
+    private int calculate(int r, int c, int[][] grid) {
+        int sum = 0;
+        // Traverse the bottom and the top row of the hour glass at the same time
+        for (int i = c; i <= c + 2; i++) {
+            sum += grid[r][i];
+            sum += grid[r + 2][i];
+        }
+        // Add the middle vlaue
+        sum += grid[r + 1][c + 1];
+        return sum;
+    }
+}

src/main/java/g2401_2500/s2428_maximum_sum_of_an_hourglass/readme.md

@@ -0,0 +1,40 @@
+2428\. Maximum Sum of an Hourglass
+
+Medium
+
+You are given an `m x n` integer matrix `grid`.
+
+We define an **hourglass** as a part of the matrix with the following form:
+
+![](https://assets.leetcode.com/uploads/2022/08/21/img.jpg)
+
+Return _the **maximum** sum of the elements of an hourglass_.
+
+**Note** that an hourglass cannot be rotated and must be entirely contained within the matrix.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/08/21/1.jpg)
+
+**Input:** grid = [[6,2,1,3],[4,2,1,5],[9,2,8,7],[4,1,2,9]]
+
+**Output:** 30
+
+**Explanation:** The cells shown above represent the hourglass with the maximum sum: 6 + 2 + 1 + 2 + 9 + 2 + 8 = 30.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/08/21/2.jpg)
+
+**Input:** grid = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** 35
+
+**Explanation:** There is only one hourglass in the matrix, with the sum: 1 + 2 + 3 + 5 + 7 + 8 + 9 = 35.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `3 <= m, n <= 150`
+*   <code>0 <= grid[i][j] <= 10<sup>6</sup></code>

src/main/java/g2401_2500/s2429_minimize_xor/Solution.java

@@ -0,0 +1,23 @@
+package g2401_2500.s2429_minimize_xor;
+
+// #Medium #Greedy #Bit_Manipulation #2022_12_07_Time_0_ms_(100.00%)_Space_39.6_MB_(87.47%)
+
+public class Solution {
+    public int minimizeXor(int num1, int num2) {
+        int bits = Integer.bitCount(num2);
+        int result = 0;
+        for (int i = 30; i >= 0 && bits > 0; --i) {
+            if ((1 << i & num1) != 0) {
+                --bits;
+                result = result ^ (1 << i);
+            }
+        }
+        for (int i = 0; i <= 30 && bits > 0; ++i) {
+            if ((1 << i & num1) == 0) {
+                --bits;
+                result = result ^ (1 << i);
+            }
+        }
+        return result;
+    }
+}

src/main/java/g2401_2500/s2429_minimize_xor/readme.md

@@ -0,0 +1,34 @@
+2429\. Minimize XOR
+
+Medium
+
+Given two positive integers `num1` and `num2`, find the positive integer `x` such that:
+
+*   `x` has the same number of set bits as `num2`, and
+*   The value `x XOR num1` is **minimal**.
+
+Note that `XOR` is the bitwise XOR operation.
+
+Return _the integer_ `x`. The test cases are generated such that `x` is **uniquely determined**.
+
+The number of **set bits** of an integer is the number of `1`'s in its binary representation.
+
+**Example 1:**
+
+**Input:** num1 = 3, num2 = 5
+
+**Output:** 3
+
+**Explanation:** The binary representations of num1 and num2 are 0011 and 0101, respectively. The integer **3** has the same number of set bits as num2, and the value `3 XOR 3 = 0` is minimal.
+
+**Example 2:**
+
+**Input:** num1 = 1, num2 = 12
+
+**Output:** 3
+
+**Explanation:** The binary representations of num1 and num2 are 0001 and 1100, respectively. The integer **3** has the same number of set bits as num2, and the value `3 XOR 1 = 2` is minimal.
+
+**Constraints:**
+
+*   <code>1 <= num1, num2 <= 10<sup>9</sup></code>

src/main/java/g2401_2500/s2430_maximum_deletions_on_a_string/Solution.java

@@ -0,0 +1,65 @@
+package g2401_2500.s2430_maximum_deletions_on_a_string;
+
+// #Hard #String #Dynamic_Programming #Hash_Function #String_Matching #Rolling_Hash
+// #2022_12_07_Time_159_ms_(93.39%)_Space_42.7_MB_(79.28%)
+
+import java.util.HashMap;
+
+public class Solution {
+    private String s;
+    private int[] hash;
+    private int[] pows;
+    private HashMap<Integer, Integer> visited;
+
+    public int deleteString(String s) {
+        this.s = s;
+        if (isBad()) {
+            return s.length();
+        }
+        visited = new HashMap<>();
+        fill();
+
+        return helper(0, 1, 0, 1);
+    }
+
+    private int helper(int a, int b, int id1, int id2) {
+        int mask = (id1 << 12) + id2;
+        int ans = 1;
+        if (visited.containsKey(mask)) {
+            return visited.get(mask);
+        }
+        for (; b < s.length(); a++, id2++, b += 2) {
+            if ((hash[a + 1] - hash[id1]) * pows[id2] == (hash[b + 1] - hash[id2]) * pows[id1]) {
+                if (id2 + 1 == s.length()) {
+                    ans = Math.max(ans, 2);
+                } else {
+                    ans = Math.max(ans, 1 + helper(id2, id2 + 1, id2, id2 + 1));
+                }
+            }
+        }
+        visited.put(mask, ans);
+        return ans;
+    }
+
+    private void fill() {
+        int n = s.length();
+        hash = new int[n + 1];
+        pows = new int[n];
+        pows[0] = 1;
+        hash[1] = s.charAt(0);
+        for (int i = 1; i != n; i++) {
+            int temp = pows[i] = pows[i - 1] * 1000000007;
+            hash[i + 1] = s.charAt(i) * temp + hash[i];
+        }
+    }
+
+    private boolean isBad() {
+        int i = 1;
+        while (i < s.length()) {
+            if (s.charAt(0) != s.charAt(i++)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/g2401_2500/s2430_maximum_deletions_on_a_string/readme.md

@@ -0,0 +1,58 @@
+2430\. Maximum Deletions on a String
+
+Hard
+
+You are given a string `s` consisting of only lowercase English letters. In one operation, you can:
+
+*   Delete **the entire string** `s`, or
+*   Delete the **first** `i` letters of `s` if the first `i` letters of `s` are **equal** to the following `i` letters in `s`, for any `i` in the range `1 <= i <= s.length / 2`.
+
+For example, if `s = "ababc"`, then in one operation, you could delete the first two letters of `s` to get `"abc"`, since the first two letters of `s` and the following two letters of `s` are both equal to `"ab"`.
+
+Return _the **maximum** number of operations needed to delete all of_ `s`.
+
+**Example 1:**
+
+**Input:** s = "abcabcdabc"
+
+**Output:** 2
+
+**Explanation:** 
+- Delete the first 3 letters ("abc") since the next 3 letters are equal. Now, s = "abcdabc". 
+ 
+- Delete all the letters. 
+
+We used 2 operations so return 2. It can be proven that 2 is the maximum number of operations needed. 
+
+Note that in the second operation we cannot delete "abc" again because the next occurrence of "abc" does not happen in the next 3 letters.
+
+**Example 2:**
+
+**Input:** s = "aaabaab"
+
+**Output:** 4
+
+**Explanation:** 
+- 
+- Delete the first letter ("a") since the next letter is equal. Now, s = "aabaab". 
+
+- Delete the first 3 letters ("aab") since the next 3 letters are equal. Now, s = "aab". 
+
+- Delete the first letter ("a") since the next letter is equal. Now, s = "ab".
+
+- Delete all the letters. 
+
+We used 4 operations so return 4. It can be proven that 4 is the maximum number of operations needed.
+
+**Example 3:**
+
+**Input:** s = "aaaaa"
+
+**Output:** 5
+
+**Explanation:** In each operation, we can delete the first letter of s.
+
+**Constraints:**
+
+*   `1 <= s.length <= 4000`
+*   `s` consists only of lowercase English letters.

src/test/java/g2401_2500/s2427_number_of_common_factors/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2401_2500.s2427_number_of_common_factors;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void commonFactors() {
+        assertThat(new Solution().commonFactors(12, 6), equalTo(4));
+    }
+
+    @Test
+    void commonFactors2() {
+        assertThat(new Solution().commonFactors(25, 30), equalTo(2));
+    }
+}

src/test/java/g2401_2500/s2428_maximum_sum_of_an_hourglass/SolutionTest.java

@@ -0,0 +1,25 @@
+package g2401_2500.s2428_maximum_sum_of_an_hourglass;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maxSum() {
+        assertThat(
+                new Solution()
+                        .maxSum(
+                                new int[][] {
+                                    {6, 2, 1, 3}, {4, 2, 1, 5}, {9, 2, 8, 7}, {4, 1, 2, 9}
+                                }),
+                equalTo(30));
+    }
+
+    @Test
+    void maxSum2() {
+        assertThat(
+                new Solution().maxSum(new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}), equalTo(35));
+    }
+}