Added tasks 1813-1824

Author: ThanhNIT

README.md

@@ -617,6 +617,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 |-|-|-|-|-|-
 | 0155 |[Min Stack](src.save/main/kotlin/g0101_0200/s0155_min_stack/MinStack.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Stack, Design | 331 | 84.88
 | 1249 |[Minimum Remove to Make Valid Parentheses](src.save/main/kotlin/g1201_1300/s1249_minimum_remove_to_make_valid_parentheses/Solution.kt)| Medium | String, Stack | 218 | 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 | 119 | 87.50
 
 #### Day 15 Tree
 
@@ -1057,6 +1058,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 1482 |[Minimum Number of Days to Make m Bouquets](src.save/main/kotlin/g1401_1500/s1482_minimum_number_of_days_to_make_m_bouquets/Solution.kt)| Medium | Array, Binary_Search | 538 | 50.00
+| 1818 |[Minimum Absolute Sum Difference](src/main/kotlin/g1801_1900/s1818_minimum_absolute_sum_difference/Solution.kt)| Medium | Array, Sorting, Binary_Search, Ordered_Set | 447 | 100.00
 
 #### Day 8
 
@@ -1327,6 +1329,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 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 | 170 | 92.51
 | 1502 |[Can Make Arithmetic Progression From Sequence](src.save/main/kotlin/g1501_1600/s1502_can_make_arithmetic_progression_from_sequence/Solution.kt)| Easy | Array, Sorting | 156 | 94.82
 | 0202 |[Happy Number](src.save/main/kotlin/g0201_0300/s0202_happy_number/Solution.kt)| Easy | Top_Interview_Questions, Hash_Table, Math, Two_Pointers | 261 | 45.08
 | 1790 |[Check if One String Swap Can Make Strings Equal](src.save/main/kotlin/g1701_1800/s1790_check_if_one_string_swap_can_make_strings_equal/Solution.kt)| Easy | String, Hash_Table, Counting | 138 | 100.00
@@ -1831,6 +1834,16 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 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
+| 1819 |[Number of Different Subsequences GCDs](src/main/kotlin/g1801_1900/s1819_number_of_different_subsequences_gcds/Solution.kt)| Hard | Array, Math, Counting, Number_Theory | 624 | 100.00
+| 1818 |[Minimum Absolute Sum Difference](src/main/kotlin/g1801_1900/s1818_minimum_absolute_sum_difference/Solution.kt)| Medium | Array, Sorting, Binary_Search, Ordered_Set, Binary_Search_II_Day_7 | 447 | 100.00
+| 1817 |[Finding the Users Active Minutes](src/main/kotlin/g1801_1900/s1817_finding_the_users_active_minutes/Solution.kt)| Medium | Array, Hash_Table | 652 | 100.00
+| 1816 |[Truncate Sentence](src/main/kotlin/g1801_1900/s1816_truncate_sentence/Solution.kt)| Easy | Array, String | 147 | 94.74
+| 1815 |[Maximum Number of Groups Getting Fresh Donuts](src/main/kotlin/g1801_1900/s1815_maximum_number_of_groups_getting_fresh_donuts/Solution.kt)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Bitmask, Memoization | 1073 | 100.00
+| 1814 |[Count Nice Pairs in an Array](src/main/kotlin/g1801_1900/s1814_count_nice_pairs_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Math, Counting | 520 | 100.00
+| 1813 |[Sentence Similarity III](src/main/kotlin/g1801_1900/s1813_sentence_similarity_iii/Solution.kt)| Medium | Array, String, Two_Pointers | 162 | 100.00
 | 1812 |[Determine Color of a Chessboard Square](src/main/kotlin/g1801_1900/s1812_determine_color_of_a_chessboard_square/Solution.kt)| Easy | String, Math | 127 | 92.86
 | 1808 |[Maximize Number of Nice Divisors](src/main/kotlin/g1801_1900/s1808_maximize_number_of_nice_divisors/Solution.kt)| Hard | Math, Recursion | 135 | 100.00
 | 1807 |[Evaluate the Bracket Pairs of a String](src/main/kotlin/g1801_1900/s1807_evaluate_the_bracket_pairs_of_a_string/Solution.kt)| Medium | Array, String, Hash_Table | 689 | 100.00

src/main/kotlin/g1801_1900/s1813_sentence_similarity_iii/Solution.kt

@@ -0,0 +1,23 @@
+package g1801_1900.s1813_sentence_similarity_iii
+
+// #Medium #Array #String #Two_Pointers #2023_06_20_Time_162_ms_(100.00%)_Space_35.9_MB_(100.00%)
+
+class Solution {
+    fun areSentencesSimilar(sentence1: String, sentence2: String): Boolean {
+        val words1 = sentence1.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        val words2 = sentence2.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        var i = 0
+        val n1 = words1.size
+        val n2 = words2.size
+        if (n1 > n2) {
+            return areSentencesSimilar(sentence2, sentence1)
+        }
+        while (i < n1 && words1[i] == words2[i]) {
+            ++i
+        }
+        while (i < n1 && words1[i] == words2[n2 - n1 + i]) {
+            ++i
+        }
+        return i == n1
+    }
+}

src/main/kotlin/g1801_1900/s1813_sentence_similarity_iii/readme.md

@@ -0,0 +1,39 @@
+1813\. Sentence Similarity III
+
+Medium
+
+A sentence is a list of words that are separated by a single space with no leading or trailing spaces. For example, `"Hello World"`, `"HELLO"`, `"hello world hello world"` are all sentences. Words consist of **only** uppercase and lowercase English letters.
+
+Two sentences `sentence1` and `sentence2` are **similar** if it is possible to insert an arbitrary sentence **(possibly empty)** inside one of these sentences such that the two sentences become equal. For example, `sentence1 = "Hello my name is Jane"` and `sentence2 = "Hello Jane"` can be made equal by inserting `"my name is"` between `"Hello"` and `"Jane"` in `sentence2`.
+
+Given two sentences `sentence1` and `sentence2`, return `true` _if_ `sentence1` _and_ `sentence2` _are similar._ Otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** sentence1 = "My name is Haley", sentence2 = "My Haley"
+
+**Output:** true
+
+**Explanation:** sentence2 can be turned to sentence1 by inserting "name is" between "My" and "Haley".
+
+**Example 2:**
+
+**Input:** sentence1 = "of", sentence2 = "A lot of words"
+
+**Output:** false
+
+**Explanation:** No single sentence can be inserted inside one of the sentences to make it equal to the other.
+
+**Example 3:**
+
+**Input:** sentence1 = "Eating right now", sentence2 = "Eating"
+
+**Output:** true
+
+**Explanation:** sentence2 can be turned to sentence1 by inserting "right now" at the end of the sentence.
+
+**Constraints:**
+
+*   `1 <= sentence1.length, sentence2.length <= 100`
+*   `sentence1` and `sentence2` consist of lowercase and uppercase English letters and spaces.
+*   The words in `sentence1` and `sentence2` are separated by a single space.

src/main/kotlin/g1801_1900/s1814_count_nice_pairs_in_an_array/Solution.kt

@@ -0,0 +1,31 @@
+package g1801_1900.s1814_count_nice_pairs_in_an_array
+
+// #Medium #Array #Hash_Table #Math #Counting
+// #2023_06_20_Time_520_ms_(100.00%)_Space_58.8_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private fun rev(n: Int): Int {
+        var n = n
+        var r = 0
+        while (n > 0) {
+            r = r * 10 + n % 10
+            n /= 10
+        }
+        return r
+    }
+
+    fun countNicePairs(nums: IntArray): Int {
+        val revMap = HashMap<Int, Int>()
+        var cnt = 0
+        for (num in nums) {
+            val lhs = num - rev(num)
+            val prevCnt = revMap.getOrDefault(lhs, 0)
+            cnt += prevCnt
+            val mod = 1000000007
+            cnt %= mod
+            revMap[lhs] = prevCnt + 1
+        }
+        return cnt
+    }
+}

src/main/kotlin/g1801_1900/s1814_count_nice_pairs_in_an_array/readme.md

@@ -0,0 +1,33 @@
+1814\. Count Nice Pairs in an Array
+
+Medium
+
+You are given an array `nums` that consists of non-negative integers. Let us define `rev(x)` as the reverse of the non-negative integer `x`. For example, `rev(123) = 321`, and `rev(120) = 21`. A pair of indices `(i, j)` is **nice** if it satisfies all of the following conditions:
+
+*   `0 <= i < j < nums.length`
+*   `nums[i] + rev(nums[j]) == nums[j] + rev(nums[i])`
+
+Return _the number of nice pairs of indices_. Since that number can be too large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [42,11,1,97]
+
+**Output:** 2
+
+**Explanation:** The two pairs are: 
+
+- (0,3) : 42 + rev(97) = 42 + 79 = 121, 97 + rev(42) = 97 + 24 = 121. 
+
+- (1,2) : 11 + rev(1) = 11 + 1 = 12, 1 + rev(11) = 1 + 11 = 12.
+
+**Example 2:**
+
+**Input:** nums = [13,10,35,24,76]
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>

src/main/kotlin/g1801_1900/s1815_maximum_number_of_groups_getting_fresh_donuts/Solution.kt

@@ -0,0 +1,73 @@
+package g1801_1900.s1815_maximum_number_of_groups_getting_fresh_donuts
+
+// #Hard #Array #Dynamic_Programming #Bit_Manipulation #Bitmask #Memoization
+// #2023_06_20_Time_1073_ms_(100.00%)_Space_71.3_MB_(100.00%)
+
+import java.util.Objects
+
+class Solution {
+    inner class Data(var idx: Int, var arrHash: Int) {
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+            if (other == null || javaClass != other.javaClass) {
+                return false
+            }
+            val data = other as Data
+            return idx == data.idx && arrHash == data.arrHash
+        }
+
+        override fun hashCode(): Int {
+            return Objects.hash(idx, arrHash)
+        }
+    }
+
+    private var dp: HashMap<Data, Int> = HashMap()
+    fun maxHappyGroups(batchSize: Int, groups: IntArray): Int {
+        val arr = IntArray(batchSize)
+        for (group in groups) {
+            arr[group % batchSize]++
+        }
+        return arr[0] + solve(0, arr)
+    }
+
+    private fun solve(num: Int, arr: IntArray): Int {
+        if (isFull(arr)) {
+            return 0
+        }
+        val key = Data(num, arr.contentHashCode())
+        if (dp.containsKey(key)) {
+            return dp[key]!!
+        }
+        var best = Int.MIN_VALUE / 2
+        if (num == 0) {
+            for (i in 1 until arr.size) {
+                if (arr[i] <= 0) {
+                    continue
+                }
+                arr[i]--
+                best = Math.max(best, 1 + solve(i, arr))
+                arr[i]++
+            }
+        } else {
+            for (i in 1 until arr.size) {
+                if (arr[i] > 0) {
+                    arr[i]--
+                    best = best.coerceAtLeast(solve((num + i) % arr.size, arr))
+                    arr[i]++
+                }
+            }
+        }
+        dp[key] = best
+        return best
+    }
+
+    private fun isFull(arr: IntArray): Boolean {
+        var sum = 0
+        for (i in 1 until arr.size) {
+            sum += arr[i]
+        }
+        return sum == 0
+    }
+}

src/main/kotlin/g1801_1900/s1815_maximum_number_of_groups_getting_fresh_donuts/readme.md

@@ -0,0 +1,29 @@
+1815\. Maximum Number of Groups Getting Fresh Donuts
+
+Hard
+
+There is a donuts shop that bakes donuts in batches of `batchSize`. They have a rule where they must serve **all** of the donuts of a batch before serving any donuts of the next batch. You are given an integer `batchSize` and an integer array `groups`, where `groups[i]` denotes that there is a group of `groups[i]` customers that will visit the shop. Each customer will get exactly one donut.
+
+When a group visits the shop, all customers of the group must be served before serving any of the following groups. A group will be happy if they all get fresh donuts. That is, the first customer of the group does not receive a donut that was left over from the previous group.
+
+You can freely rearrange the ordering of the groups. Return _the **maximum** possible number of happy groups after rearranging the groups._
+
+**Example 1:**
+
+**Input:** batchSize = 3, groups = [1,2,3,4,5,6]
+
+**Output:** 4
+
+**Explanation:** You can arrange the groups as [6,2,4,5,1,3]. Then the 1<sup>st</sup>, 2<sup>nd</sup>, 4<sup>th</sup>, and 6<sup>th</sup> groups will be happy.
+
+**Example 2:**
+
+**Input:** batchSize = 4, groups = [1,3,2,5,2,2,1,6]
+
+**Output:** 4
+
+**Constraints:**
+
+*   `1 <= batchSize <= 9`
+*   `1 <= groups.length <= 30`
+*   <code>1 <= groups[i] <= 10<sup>9</sup></code>

src/main/kotlin/g1801_1900/s1816_truncate_sentence/Solution.kt

@@ -0,0 +1,15 @@
+package g1801_1900.s1816_truncate_sentence
+
+// #Easy #Array #String #2023_06_20_Time_147_ms_(94.74%)_Space_35.9_MB_(78.95%)
+
+class Solution {
+    fun truncateSentence(s: String, k: Int): String {
+        val words = s.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        val sb = StringBuilder()
+        for (i in 0 until k) {
+            sb.append(words[i])
+            sb.append(" ")
+        }
+        return sb.substring(0, sb.toString().length - 1)
+    }
+}

src/main/kotlin/g1801_1900/s1816_truncate_sentence/readme.md

@@ -0,0 +1,51 @@
+1816\. Truncate Sentence
+
+Easy
+
+A **sentence** is a list of words that are separated by a single space with no leading or trailing spaces. Each of the words consists of **only** uppercase and lowercase English letters (no punctuation).
+
+*   For example, `"Hello World"`, `"HELLO"`, and `"hello world hello world"` are all sentences.
+
+You are given a sentence `s` and an integer `k`. You want to **truncate** `s` such that it contains only the **first** `k` words. Return `s`_ after **truncating** it._
+
+**Example 1:**
+
+**Input:** s = "Hello how are you Contestant", k = 4
+
+**Output:** "Hello how are you"
+
+**Explanation:** 
+
+The words in s are ["Hello", "how" "are", "you", "Contestant"]. 
+
+The first 4 words are ["Hello", "how", "are", "you"]. 
+
+Hence, you should return "Hello how are you".
+
+**Example 2:**
+
+**Input:** s = "What is the solution to this problem", k = 4
+
+**Output:** "What is the solution"
+
+**Explanation:** 
+
+The words in s are ["What", "is" "the", "solution", "to", "this", "problem"]. 
+
+The first 4 words are ["What", "is", "the", "solution"].
+
+Hence, you should return "What is the solution".
+
+**Example 3:**
+
+**Input:** s = "chopper is not a tanuki", k = 5
+
+**Output:** "chopper is not a tanuki"
+
+**Constraints:**
+
+*   `1 <= s.length <= 500`
+*   `k` is in the range `[1, the number of words in s]`.
+*   `s` consist of only lowercase and uppercase English letters and spaces.
+*   The words in `s` are separated by a single space.
+*   There are no leading or trailing spaces.

src/main/kotlin/g1801_1900/s1817_finding_the_users_active_minutes/Solution.kt

@@ -0,0 +1,36 @@
+package g1801_1900.s1817_finding_the_users_active_minutes
+
+// #Medium #Array #Hash_Table #2023_06_20_Time_652_ms_(100.00%)_Space_57.8_MB_(80.00%)
+
+class Solution {
+    fun findingUsersActiveMinutes(logs: Array<IntArray>, k: Int): IntArray {
+        if (logs.size == 1) {
+            val res = IntArray(k)
+            res[0] = 1
+            return res
+        }
+        logs.sortWith(compareBy { a: IntArray -> a[0] }.thenComparingInt { a: IntArray -> a[1] })
+        val result = IntArray(k)
+        var start = 1
+        var prevUser = logs[0][0]
+        var prevMin = logs[0][1]
+        var count = 1
+        while (true) {
+            while (start < logs.size && prevUser == logs[start][0]) {
+                if (prevMin != logs[start][1]) {
+                    count++
+                }
+                prevMin = logs[start][1]
+                start++
+            }
+            result[count - 1]++
+            if (start >= logs.size) {
+                break
+            }
+            count = 1
+            prevUser = logs[start][0]
+            prevMin = logs[start][1]
+        }
+        return result
+    }
+}