Added tasks 1901, 1903, 1904, 1905, 1906, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1920, 1921, 1922, 1923, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1935, 1936, 1937, 1938, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948

Author: javadev

README.md

@@ -1127,6 +1127,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 1802 |[Maximum Value at a Given Index in a Bounded Array](src/main/kotlin/g1801_1900/s1802_maximum_value_at_a_given_index_in_a_bounded_array/Solution.kt)| Medium | Greedy, Binary_Search | 118 | 100.00
+| 1901 |[Find a Peak Element II](src/main/kotlin/g1901_2000/s1901_find_a_peak_element_ii/Solution.kt)| Medium | Array, Binary_Search, Matrix, Divide_and_Conquer | 726 | 100.00
 
 #### Day 18
 
@@ -1560,6 +1561,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 1020 |[Number of Enclaves](src.save/main/kotlin/g1001_1100/s1020_number_of_enclaves/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 369 | 76.26
+| 1905 |[Count Sub Islands](src/main/kotlin/g1901_2000/s1905_count_sub_islands/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 866 | 100.00
 
 #### Day 4 Matrix Related Problems
 
@@ -1580,6 +1582,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0934 |[Shortest Bridge](src.save/main/kotlin/g0901_1000/s0934_shortest_bridge/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 301 | 80.95
+| 1926 |[Nearest Exit from Entrance in Maze](src/main/kotlin/g1901_2000/s1926_nearest_exit_from_entrance_in_maze/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix | 351 | 94.44
 
 #### Day 7 Standard Traversal
 
@@ -1834,6 +1837,43 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 1948 |[Delete Duplicate Folders in System](src/main/kotlin/g1901_2000/s1948_delete_duplicate_folders_in_system/Solution.kt)| Hard | Array, String, Hash_Table, Trie, Hash_Function | 1420 | 100.00
+| 1947 |[Maximum Compatibility Score Sum](src/main/kotlin/g1901_2000/s1947_maximum_compatibility_score_sum/Solution.kt)| Medium | Array, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask | 179 | 100.00
+| 1946 |[Largest Number After Mutating Substring](src/main/kotlin/g1901_2000/s1946_largest_number_after_mutating_substring/Solution.kt)| Medium | Array, String, Greedy | 346 | 100.00
+| 1945 |[Sum of Digits of String After Convert](src/main/kotlin/g1901_2000/s1945_sum_of_digits_of_string_after_convert/Solution.kt)| Easy | String, Simulation | 146 | 75.00
+| 1944 |[Number of Visible People in a Queue](src/main/kotlin/g1901_2000/s1944_number_of_visible_people_in_a_queue/Solution.kt)| Hard | Array, Stack, Monotonic_Stack | 605 | 90.00
+| 1943 |[Describe the Painting](src/main/kotlin/g1901_2000/s1943_describe_the_painting/Solution.kt)| Medium | Array, Prefix_Sum | 951 | 100.00
+| 1942 |[The Number of the Smallest Unoccupied Chair](src/main/kotlin/g1901_2000/s1942_the_number_of_the_smallest_unoccupied_chair/Solution.kt)| Medium | Array, Heap_Priority_Queue, Ordered_Set | 549 | 100.00
+| 1941 |[Check if All Characters Have Equal Number of Occurrences](src/main/kotlin/g1901_2000/s1941_check_if_all_characters_have_equal_number_of_occurrences/Solution.kt)| Easy | String, Hash_Table, Counting | 167 | 78.57
+| 1938 |[Maximum Genetic Difference Query](src/main/kotlin/g1901_2000/s1938_maximum_genetic_difference_query/Solution.kt)| Hard | Array, Bit_Manipulation, Trie | 855 | 100.00
+| 1937 |[Maximum Number of Points with Cost](src/main/kotlin/g1901_2000/s1937_maximum_number_of_points_with_cost/Solution.kt)| Medium | Array, Dynamic_Programming | 886 | 100.00
+| 1936 |[Add Minimum Number of Rungs](src/main/kotlin/g1901_2000/s1936_add_minimum_number_of_rungs/Solution.kt)| Medium | Array, Greedy | 405 | 100.00
+| 1935 |[Maximum Number of Words You Can Type](src/main/kotlin/g1901_2000/s1935_maximum_number_of_words_you_can_type/Solution.kt)| Easy | String, Hash_Table | 178 | 37.50
+| 1932 |[Merge BSTs to Create Single BST](src/main/kotlin/g1901_2000/s1932_merge_bsts_to_create_single_bst/Solution.kt)| Hard | Hash_Table, Depth_First_Search, Tree, Binary_Search, Binary_Tree | 1146 | 100.00
+| 1931 |[Painting a Grid With Three Different Colors](src/main/kotlin/g1901_2000/s1931_painting_a_grid_with_three_different_colors/Solution.kt)| Hard | Dynamic_Programming | 135 | 100.00
+| 1930 |[Unique Length-3 Palindromic Subsequences](src/main/kotlin/g1901_2000/s1930_unique_length_3_palindromic_subsequences/Solution.kt)| Medium | String, Hash_Table, Prefix_Sum | 273 | 100.00
+| 1929 |[Concatenation of Array](src/main/kotlin/g1901_2000/s1929_concatenation_of_array/Solution.kt)| Easy | Array | 220 | 94.47
+| 1928 |[Minimum Cost to Reach Destination in Time](src/main/kotlin/g1901_2000/s1928_minimum_cost_to_reach_destination_in_time/Solution.kt)| Hard | Dynamic_Programming, Graph | 414 | 100.00
+| 1927 |[Sum Game](src/main/kotlin/g1901_2000/s1927_sum_game/Solution.kt)| Medium | Math, Greedy, Game_Theory | 211 | 100.00
+| 1926 |[Nearest Exit from Entrance in Maze](src/main/kotlin/g1901_2000/s1926_nearest_exit_from_entrance_in_maze/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Graph_Theory_I_Day_6_Matrix_Related_Problems | 351 | 94.44
+| 1925 |[Count Square Sum Triples](src/main/kotlin/g1901_2000/s1925_count_square_sum_triples/Solution.kt)| Easy | Math, Enumeration | 161 | 40.00
+| 1923 |[Longest Common Subpath](src/main/kotlin/g1901_2000/s1923_longest_common_subpath/Solution.kt)| Hard | Array, Binary_Search, Hash_Function, Rolling_Hash, Suffix_Array | 1142 | 100.00
+| 1922 |[Count Good Numbers](src/main/kotlin/g1901_2000/s1922_count_good_numbers/Solution.kt)| Medium | Math, Recursion | 135 | 100.00
+| 1921 |[Eliminate Maximum Number of Monsters](src/main/kotlin/g1901_2000/s1921_eliminate_maximum_number_of_monsters/Solution.kt)| Medium | Array, Sorting, Greedy | 507 | 100.00
+| 1920 |[Build Array from Permutation](src/main/kotlin/g1901_2000/s1920_build_array_from_permutation/Solution.kt)| Easy | Array, Simulation | 252 | 81.25
+| 1916 |[Count Ways to Build Rooms in an Ant Colony](src/main/kotlin/g1901_2000/s1916_count_ways_to_build_rooms_in_an_ant_colony/Solution.kt)| Hard | Dynamic_Programming, Math, Tree, Graph, Topological_Sort, Combinatorics | 2564 | 100.00
+| 1915 |[Number of Wonderful Substrings](src/main/kotlin/g1901_2000/s1915_number_of_wonderful_substrings/Solution.kt)| Medium | String, Hash_Table, Bit_Manipulation, Prefix_Sum | 267 | 100.00
+| 1914 |[Cyclically Rotating a Grid](src/main/kotlin/g1901_2000/s1914_cyclically_rotating_a_grid/Solution.kt)| Medium | Array, Matrix, Simulation | 282 | 100.00
+| 1913 |[Maximum Product Difference Between Two Pairs](src/main/kotlin/g1901_2000/s1913_maximum_product_difference_between_two_pairs/Solution.kt)| Easy | Array, Sorting | 261 | 100.00
+| 1912 |[Design Movie Rental System](src/main/kotlin/g1901_2000/s1912_design_movie_rental_system/MovieRentingSystem.kt)| Hard | Array, Hash_Table, Design, Heap_Priority_Queue, Ordered_Set | 3005 | 100.00
+| 1911 |[Maximum Alternating Subsequence Sum](src/main/kotlin/g1901_2000/s1911_maximum_alternating_subsequence_sum/Solution.kt)| Medium | Array, Dynamic_Programming | 531 | 100.00
+| 1910 |[Remove All Occurrences of a Substring](src/main/kotlin/g1901_2000/s1910_remove_all_occurrences_of_a_substring/Solution.kt)| Medium | String | 177 | 100.00
+| 1909 |[Remove One Element to Make the Array Strictly Increasing](src/main/kotlin/g1901_2000/s1909_remove_one_element_to_make_the_array_strictly_increasing/Solution.kt)| Easy | Array | 176 | 50.00
+| 1906 |[Minimum Absolute Difference Queries](src/main/kotlin/g1901_2000/s1906_minimum_absolute_difference_queries/Solution.kt)| Medium | Array, Hash_Table | 1069 | 50.00
+| 1905 |[Count Sub Islands](src/main/kotlin/g1901_2000/s1905_count_sub_islands/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Graph_Theory_I_Day_3_Matrix_Related_Problems | 866 | 100.00
+| 1904 |[The Number of Full Rounds You Have Played](src/main/kotlin/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/Solution.kt)| Medium | String, Math | 149 | 100.00
+| 1903 |[Largest Odd Number in String](src/main/kotlin/g1901_2000/s1903_largest_odd_number_in_string/Solution.kt)| Easy | String, Math, Greedy | 256 | 75.00
+| 1901 |[Find a Peak Element II](src/main/kotlin/g1901_2000/s1901_find_a_peak_element_ii/Solution.kt)| Medium | Array, Binary_Search, Matrix, Divide_and_Conquer, Binary_Search_II_Day_17 | 726 | 100.00
 | 1824 |[Minimum Sideway Jumps](src/main/kotlin/g1801_1900/s1824_minimum_sideway_jumps/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy | 726 | 100.00
 | 1823 |[Find the Winner of the Circular Game](src/main/kotlin/g1801_1900/s1823_find_the_winner_of_the_circular_game/Solution.kt)| Medium | Array, Math, Simulation, Recursion, Queue, Data_Structure_II_Day_14_Stack_Queue | 119 | 87.50
 | 1822 |[Sign of the Product of an Array](src/main/kotlin/g1801_1900/s1822_sign_of_the_product_of_an_array/Solution.kt)| Easy | Array, Math, Programming_Skills_I_Day_4_Loop | 170 | 92.51

src/main/kotlin/g1901_2000/s1901_find_a_peak_element_ii/Solution.kt

@@ -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
+// #2023_06_19_Time_726_ms_(100.00%)_Space_92.7_MB_(100.00%)
+
+class Solution {
+    fun findPeakGrid(mat: Array<IntArray>): IntArray {
+        val n = mat.size
+        val m = mat[0].size
+        var l = 0
+        var r = m - 1
+        var mid: Int
+        while (l <= r) {
+            mid = (l + r) / 2
+            var mx = mat[0][mid]
+            var mxi = 0
+            for (i in 1 until n) {
+                if (mx < mat[i][mid]) {
+                    mx = mat[i][mid]
+                    mxi = i
+                }
+            }
+            val lv = if (mid > l) mat[mxi][mid - 1] else -1
+            val rv = if (mid < r) mat[mxi][mid + 1] else -1
+            if (mx > lv && mx > rv) {
+                return intArrayOf(mxi, mid)
+            } else if (mx > lv) {
+                l = mid + 1
+            } else {
+                r = mid - 1
+            }
+        }
+        return intArrayOf(-1, -1)
+    }
+}

src/main/kotlin/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/kotlin/g1901_2000/s1903_largest_odd_number_in_string/Solution.kt

@@ -0,0 +1,14 @@
+package g1901_2000.s1903_largest_odd_number_in_string
+
+// #Easy #String #Math #Greedy #2023_06_19_Time_256_ms_(75.00%)_Space_39.4_MB_(87.50%)
+
+class Solution {
+    fun largestOddNumber(num: String): String {
+        for (i in num.length - 1 downTo 0) {
+            if (("" + num[i]).toInt() % 2 == 1) {
+                return num.substring(0, i + 1)
+            }
+        }
+        return ""
+    }
+}

src/main/kotlin/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/kotlin/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/Solution.kt

@@ -0,0 +1,44 @@
+package g1901_2000.s1904_the_number_of_full_rounds_you_have_played
+
+// #Medium #String #Math #2023_06_19_Time_149_ms_(100.00%)_Space_33.4_MB_(100.00%)
+
+class Solution {
+    fun numberOfRounds(loginTime: String, logoutTime: String): Int {
+        var loginSerializeTime = serializeTime(loginTime)
+        var logoutSerializeTime = serializeTime(logoutTime)
+        if (logoutSerializeTime - 14 < loginSerializeTime &&
+            logoutSerializeTime > loginSerializeTime
+        ) {
+            return 0
+        }
+        loginSerializeTime = maskSerializeTime(loginSerializeTime, 14)
+        logoutSerializeTime = maskSerializeTime(logoutSerializeTime, 0)
+        if (loginSerializeTime == logoutSerializeTime) {
+            return 0
+        }
+        return if (loginSerializeTime > logoutSerializeTime + 14) {
+            (
+                calculateFullRounds(loginSerializeTime, MID_NIGHT_END) +
+                    calculateFullRounds(MID_NIGHT_START, logoutSerializeTime)
+                )
+        } else calculateFullRounds(loginSerializeTime, logoutSerializeTime)
+    }
+
+    private fun maskSerializeTime(serializeTime: Int, mask: Int): Int {
+        return (serializeTime + mask) / ROUND_INTERVAL * ROUND_INTERVAL
+    }
+
+    private fun serializeTime(time: String): Int {
+        return time.substring(0, 2).toInt() * 60 + time.substring(3, 5).toInt()
+    }
+
+    private fun calculateFullRounds(login: Int, logout: Int): Int {
+        return (logout - login) / ROUND_INTERVAL
+    }
+
+    companion object {
+        private const val MID_NIGHT_END = 1440
+        private const val MID_NIGHT_START = 0
+        private const val ROUND_INTERVAL = 15
+    }
+}

src/main/kotlin/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/kotlin/g1901_2000/s1905_count_sub_islands/Solution.kt

@@ -0,0 +1,36 @@
+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
+// #2023_06_19_Time_866_ms_(100.00%)_Space_81.8_MB_(100.00%)
+
+class Solution {
+    private var ans = 0
+    fun countSubIslands(grid1: Array<IntArray>, grid2: Array<IntArray>): Int {
+        var count = 0
+        for (i in grid2.indices) {
+            for (j in grid2[0].indices) {
+                if (grid2[i][j] == 1) {
+                    ans = 1
+                    dfs(grid1, grid2, i, j)
+                    count += ans
+                }
+            }
+        }
+        return count
+    }
+
+    private fun dfs(grid1: Array<IntArray>, grid2: Array<IntArray>, i: Int, j: Int) {
+        if (i < 0 || j < 0 || i >= grid1.size || j >= grid1[0].size || 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/kotlin/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`.