Added tasks 1901, 1903, 1904, 1905, 1906.

Author: ThanhNIT

src/main/java/g1901_2000/s1901_find_a_peak_element_ii/Solution.java

@@ -0,0 +1,35 @@
+package g1901_2000.s1901_find_a_peak_element_ii;
+
+// #Medium #Array #Binary_Search #Matrix #Divide_and_Conquer #Binary_Search_II_Day_17
+// #2022_05_11_Time_0_ms_(100.00%)_Space_115.1_MB_(45.96%)
+
+public class Solution {
+    public int[] findPeakGrid(int[][] mat) {
+        int n = mat.length;
+        int m = mat[0].length;
+        int l = 0;
+        int r = m - 1;
+        int mid;
+        while (l <= r) {
+            mid = (l + r) / 2;
+            int mx = mat[0][mid];
+            int mxi = 0;
+            for (int i = 1; i < n; i++) {
+                if (mx < mat[i][mid]) {
+                    mx = mat[i][mid];
+                    mxi = i;
+                }
+            }
+            int lv = mid > l ? mat[mxi][mid - 1] : -1;
+            int rv = mid < r ? mat[mxi][mid + 1] : -1;
+            if (mx > lv && mx > rv) {
+                return new int[] {mxi, mid};
+            } else if (mx > lv) {
+                l = mid + 1;
+            } else {
+                r = mid - 1;
+            }
+        }
+        return new int[] {-1, -1};
+    }
+}

src/main/java/g1901_2000/s1901_find_a_peak_element_ii/readme.md

@@ -0,0 +1,39 @@
+1901\. Find a Peak Element II
+
+Medium
+
+A **peak** element in a 2D grid is an element that is **strictly greater** than all of its **adjacent** neighbors to the left, right, top, and bottom.
+
+Given a **0-indexed** `m x n` matrix `mat` where **no two adjacent cells are equal**, find **any** peak element `mat[i][j]` and return _the length 2 array_ `[i,j]`.
+
+You may assume that the entire matrix is surrounded by an **outer perimeter** with the value `-1` in each cell.
+
+You must write an algorithm that runs in `O(m log(n))` or `O(n log(m))` time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/08/1.png)
+
+**Input:** mat = [[1,4],[3,2]]
+
+**Output:** [0,1]
+
+**Explanation:** Both 3 and 4 are peak elements so [1,0] and [0,1] are both acceptable answers.
+
+**Example 2:**
+
+**![](https://assets.leetcode.com/uploads/2021/06/07/3.png)**
+
+**Input:** mat = [[10,20,15],[21,30,14],[7,16,32]]
+
+**Output:** [1,1]
+
+**Explanation:** Both 30 and 32 are peak elements so [1,1] and [2,2] are both acceptable answers.
+
+**Constraints:**
+
+*   `m == mat.length`
+*   `n == mat[i].length`
+*   `1 <= m, n <= 500`
+*   <code>1 <= mat[i][j] <= 10<sup>5</sup></code>
+*   No two adjacent cells are equal.

src/main/java/g1901_2000/s1903_largest_odd_number_in_string/Solution.java

@@ -0,0 +1,14 @@
+package g1901_2000.s1903_largest_odd_number_in_string;
+
+// #Easy #String #Math #Greedy #2022_05_11_Time_6_ms_(23.18%)_Space_43.2_MB_(81.76%)
+
+public class Solution {
+    public String largestOddNumber(String num) {
+        for (int i = num.length() - 1; i >= 0; i--) {
+            if (Integer.parseInt("" + num.charAt(i)) % 2 == 1) {
+                return num.substring(0, i + 1);
+            }
+        }
+        return "";
+    }
+}

src/main/java/g1901_2000/s1903_largest_odd_number_in_string/readme.md

@@ -0,0 +1,36 @@
+1903\. Largest Odd Number in String
+
+Easy
+
+You are given a string `num`, representing a large integer. Return _the **largest-valued odd** integer (as a string) that is a **non-empty substring** of_ `num`_, or an empty string_ `""` _if no odd integer exists_.
+
+A **substring** is a contiguous sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** num = "52"
+
+**Output:** "5"
+
+**Explanation:** The only non-empty substrings are "5", "2", and "52". "5" is the only odd number.
+
+**Example 2:**
+
+**Input:** num = "4206"
+
+**Output:** ""
+
+**Explanation:** There are no odd numbers in "4206".
+
+**Example 3:**
+
+**Input:** num = "35427"
+
+**Output:** "35427"
+
+**Explanation:** "35427" is already an odd number.
+
+**Constraints:**
+
+*   <code>1 <= num.length <= 10<sup>5</sup></code>
+*   `num` only consists of digits and does not contain any leading zeros.

src/main/java/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/Solution.java

@@ -0,0 +1,54 @@
+package g1901_2000.s1904_the_number_of_full_rounds_you_have_played;
+
+// #Medium #String #Math #2022_05_11_Time_2_ms_(37.11%)_Space_42.1_MB_(40.55%)
+
+public class Solution {
+    public int numberOfRounds(String startTime, String finishTime) {
+        int rounds = 0;
+        int startHour = Integer.parseInt(startTime.split(":")[0]);
+        int endHour = Integer.parseInt(finishTime.split(":")[0]);
+        int startMin = Integer.parseInt(startTime.split(":")[1]);
+        int endMin = Integer.parseInt(finishTime.split(":")[1]);
+        if (endHour < startHour) {
+            endHour += 24;
+        } else if (endHour == startHour && endMin < startMin) {
+            endHour += 24;
+        }
+        if (startHour == endHour) {
+            if (startMin == 0 && endMin >= 15) {
+                rounds++;
+            }
+            if (startMin <= 15 && endMin >= 30) {
+                rounds++;
+            }
+            if (startMin <= 30 && endMin >= 45) {
+                rounds++;
+            }
+            return rounds;
+        } else {
+            // compute all full rounds in the start hour
+            if (startMin == 0) {
+                rounds += 4;
+            } else if (startMin <= 15) {
+                rounds += 3;
+            } else if (startMin <= 30) {
+                rounds += 2;
+            } else if (startMin <= 45) {
+                rounds++;
+            }
+
+            // compute all full rounds in the finish hour
+            if (endMin >= 45) {
+                rounds += 3;
+            } else if (endMin >= 30) {
+                rounds += 2;
+            } else if (endMin >= 15) {
+                rounds++;
+            }
+
+            // compute all full rounds in the all full hours between finishHour and startHour
+            rounds += (endHour - startHour - 1) * 4;
+            return rounds;
+        }
+    }
+}

src/main/java/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/readme.md

@@ -0,0 +1,45 @@
+1904\. The Number of Full Rounds You Have Played
+
+Medium
+
+You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
+
+*   For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round starts at `01:30`.
+
+You are given two strings `loginTime` and `logoutTime` where:
+
+*   `loginTime` is the time you will login to the game, and
+*   `logoutTime` is the time you will logout from the game.
+
+If `logoutTime` is **earlier** than `loginTime`, this means you have played from `loginTime` to midnight and from midnight to `logoutTime`.
+
+Return _the number of full chess rounds you have played in the tournament_.
+
+**Note:** All the given times follow the 24-hour clock. That means the first round of the day starts at `00:00` and the last round of the day starts at `23:45`.
+
+**Example 1:**
+
+**Input:** loginTime = "09:31", logoutTime = "10:14"
+
+**Output:** 1
+
+**Explanation:** 
+
+You played one full round from 09:45 to 10:00. You did not play the full round from 09:30 to 09:45 because you logged in at 09:31 after it began. 
+
+You did not play the full round from 10:00 to 10:15 because you logged out at 10:14 before it ended.
+
+**Example 2:**
+
+**Input:** loginTime = "21:30", logoutTime = "03:00"
+
+**Output:** 22
+
+**Explanation:** You played 10 full rounds from 21:30 to 00:00 and 12 full rounds from 00:00 to 03:00. 10 + 12 = 22.
+
+**Constraints:**
+
+*   `loginTime` and `logoutTime` are in the format `hh:mm`.
+*   `00 <= hh <= 23`
+*   `00 <= mm <= 59`
+*   `loginTime` and `logoutTime` are not equal.

src/main/java/g1901_2000/s1905_count_sub_islands/Solution.java

@@ -0,0 +1,37 @@
+package g1901_2000.s1905_count_sub_islands;
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix #Union_Find
+// #Graph_Theory_I_Day_3_Matrix_Related_Problems
+// #2022_05_11_Time_24_ms_(85.54%)_Space_142.6_MB_(18.19%)
+
+public class Solution {
+    private int ans = 0;
+
+    public int countSubIslands(int[][] grid1, int[][] grid2) {
+        int count = 0;
+        for (int i = 0; i < grid2.length; i++) {
+            for (int j = 0; j < grid2[0].length; j++) {
+                if (grid2[i][j] == 1) {
+                    ans = 1;
+                    dfs(grid1, grid2, i, j);
+                    count += ans;
+                }
+            }
+        }
+        return count;
+    }
+
+    private void dfs(int[][] grid1, int[][] grid2, int i, int j) {
+        if (i < 0 || j < 0 || i >= grid1.length || j >= grid1[0].length || grid2[i][j] == 0) {
+            return;
+        }
+        if (grid1[i][j] == 0) {
+            ans = 0;
+        }
+        grid2[i][j] = 0;
+        dfs(grid1, grid2, i - 1, j);
+        dfs(grid1, grid2, i + 1, j);
+        dfs(grid1, grid2, i, j + 1);
+        dfs(grid1, grid2, i, j - 1);
+    }
+}

src/main/java/g1901_2000/s1905_count_sub_islands/readme.md

@@ -0,0 +1,36 @@
+1905\. Count Sub Islands
+
+Medium
+
+You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
+
+An island in `grid2` is considered a **sub-island** if there is an island in `grid1` that contains **all** the cells that make up **this** island in `grid2`.
+
+Return the _**number** of islands in_ `grid2` _that are considered **sub-islands**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/06/10/test1.png)
+
+**Input:** grid1 = [[1,1,1,0,0],[0,1,1,1,1],[0,0,0,0,0],[1,0,0,0,0],[1,1,0,1,1]], grid2 = [[1,1,1,0,0],[0,0,1,1,1],[0,1,0,0,0],[1,0,1,1,0],[0,1,0,1,0]]
+
+**Output:** 3
+
+**Explanation:** In the picture above, the grid on the left is grid1 and the grid on the right is grid2. The 1s colored red in grid2 are those considered to be part of a sub-island. There are three sub-islands.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/06/03/testcasex2.png)
+
+**Input:** grid1 = [[1,0,1,0,1],[1,1,1,1,1],[0,0,0,0,0],[1,1,1,1,1],[1,0,1,0,1]], grid2 = [[0,0,0,0,0],[1,1,1,1,1],[0,1,0,1,0],[0,1,0,1,0],[1,0,0,0,1]]
+
+**Output:** 2
+
+**Explanation:** In the picture above, the grid on the left is grid1 and the grid on the right is grid2. The 1s colored red in grid2 are those considered to be part of a sub-island. There are two sub-islands.
+
+**Constraints:**
+
+*   `m == grid1.length == grid2.length`
+*   `n == grid1[i].length == grid2[i].length`
+*   `1 <= m, n <= 500`
+*   `grid1[i][j]` and `grid2[i][j]` are either `0` or `1`.