Added tasks 2825-2856

Author: javadev

src/main/kotlin/g2701_2800/s2715_execute_cancellable_function_with_delay/readme.md renamed to src/main/kotlin/g2701_2800/s2715_timeout_cancellation/readme.md

@@ -1,4 +1,4 @@
-// #Easy #2023_08_02_Time_64_ms_(91.95%)_Space_42.3_MB_(96.51%)
+// #Easy #2023_09_15_Time_53_ms_(97.68%)_Space_43.2_MB_(25.10%)
 
 function cancellable(fn: Function, args: any[], t: number): Function {
     let cancelled: boolean = false

src/main/kotlin/g2701_2800/s2715_execute_cancellable_function_with_delay/solution.ts renamed to src/main/kotlin/g2701_2800/s2715_timeout_cancellation/solution.ts

@@ -0,0 +1,24 @@
+package g2801_2900.s2825_make_string_a_subsequence_using_cyclic_increments
+
+// #Medium #String #Two_Pointers #2023_12_18_Time_227_ms_(83.33%)_Space_39.6_MB_(91.67%)
+
+class Solution {
+    fun canMakeSubsequence(str1: String, str2: String): Boolean {
+        var str1ptr = 0
+        for (element in str2) {
+            val c2 = element
+            var found = false
+            while (str1ptr < str1.length) {
+                val c1 = str1[str1ptr++]
+                if (c1 == c2 || (c1.code - 'a'.code + 1) % 26 == c2.code - 'a'.code) {
+                    found = true
+                    break
+                }
+            }
+            if (!found) {
+                return false
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g2801_2900/s2825_make_string_a_subsequence_using_cyclic_increments/Solution.kt

@@ -0,0 +1,41 @@
+2825\. Make String a Subsequence Using Cyclic Increments
+
+Medium
+
+You are given two **0-indexed** strings `str1` and `str2`.
+
+In an operation, you select a **set** of indices in `str1`, and for each index `i` in the set, increment `str1[i]` to the next character **cyclically**. That is `'a'` becomes `'b'`, `'b'` becomes `'c'`, and so on, and `'z'` becomes `'a'`.
+
+Return `true` _if it is possible to make_ `str2` _a subsequence of_ `str1` _by performing the operation **at most once**_, _and_ `false` _otherwise_.
+
+**Note:** A subsequence of a string is a new string that is formed from the original string by deleting some (possibly none) of the characters without disturbing the relative positions of the remaining characters.
+
+**Example 1:**
+
+**Input:** str1 = "abc", str2 = "ad"
+
+**Output:** true
+
+**Explanation:** Select index 2 in str1. Increment str1[2] to become 'd'. Hence, str1 becomes "abd" and str2 is now a subsequence. Therefore, true is returned.
+
+**Example 2:**
+
+**Input:** str1 = "zc", str2 = "ad"
+
+**Output:** true
+
+**Explanation:** Select indices 0 and 1 in str1. Increment str1[0] to become 'a'. Increment str1[1] to become 'd'. Hence, str1 becomes "ad" and str2 is now a subsequence. Therefore, true is returned.
+
+**Example 3:**
+
+**Input:** str1 = "ab", str2 = "d"
+
+**Output:** false
+
+**Explanation:** In this example, it can be shown that it is impossible to make str2 a subsequence of str1 using the operation at most once. Therefore, false is returned.
+
+**Constraints:**
+
+*   <code>1 <= str1.length <= 10<sup>5</sup></code>
+*   <code>1 <= str2.length <= 10<sup>5</sup></code>
+*   `str1` and `str2` consist of only lowercase English letters.

src/main/kotlin/g2801_2900/s2825_make_string_a_subsequence_using_cyclic_increments/readme.md

@@ -0,0 +1,26 @@
+package g2801_2900.s2826_sorting_three_groups
+
+// #Medium #Array #Dynamic_Programming #2023_12_18_Time_250_ms_(100.00%)_Space_45_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun minimumOperations(nums: List<Int>): Int {
+        val n = nums.size
+        val arr = IntArray(3)
+        var max = 0
+        for (num in nums) {
+            var locMax = 0
+            val value = num
+            for (j in 0 until value) {
+                locMax = max(locMax, arr[j])
+            }
+            locMax++
+            arr[value - 1] = locMax
+            if (locMax > max) {
+                max = locMax
+            }
+        }
+        return n - max
+    }
+}

src/main/kotlin/g2801_2900/s2826_sorting_three_groups/Solution.kt

@@ -0,0 +1,64 @@
+2826\. Sorting Three Groups
+
+Medium
+
+You are given a **0-indexed** integer array `nums` of length `n`.
+
+The numbers from `0` to `n - 1` are divided into three groups numbered from `1` to `3`, where number `i` belongs to group `nums[i]`. Notice that some groups may be **empty**.
+
+You are allowed to perform this operation any number of times:
+
+*   Pick number `x` and change its group. More formally, change `nums[x]` to any number from `1` to `3`.
+
+A new array `res` is constructed using the following procedure:
+
+1.  Sort the numbers in each group independently.
+2.  Append the elements of groups `1`, `2`, and `3` to `res` **in this order**.
+
+Array `nums` is called a **beautiful array** if the constructed array `res` is sorted in **non-decreasing** order.
+
+Return _the **minimum** number of operations to make_ `nums` _a **beautiful array**_.
+
+**Example 1:**
+
+**Input:** nums = [2,1,3,2,1]
+
+**Output:** 3
+
+**Explanation:** It's optimal to perform three operations: 
+1. change nums[0] to 1. 
+2. change nums[2] to 1. 
+3. change nums[3] to 1. 
+
+After performing the operations and sorting the numbers in each group, group 1 becomes equal to [0,1,2,3,4] and group 2 and group 3 become empty. Hence, res is equal to [0,1,2,3,4] which is sorted in non-decreasing order. 
+
+It can be proven that there is no valid sequence of less than three operations.
+
+**Example 2:**
+
+**Input:** nums = [1,3,2,1,3,3]
+
+**Output:** 2
+
+**Explanation:** It's optimal to perform two operations: 
+1. change nums[1] to 1. 
+2. change nums[2] to 1. 
+
+After performing the operations and sorting the numbers in each group, group 1 becomes equal to [0,1,2,3], group 2 becomes empty, and group 3 becomes equal to [4,5]. Hence, res is equal to [0,1,2,3,4,5] which is sorted in non-decreasing order. 
+
+It can be proven that there is no valid sequence of less than two operations.
+
+**Example 3:**
+
+**Input:** nums = [2,2,2,2,3,3]
+
+**Output:** 0
+
+**Explanation:** It's optimal to not perform operations. 
+
+After sorting the numbers in each group, group 1 becomes empty, group 2 becomes equal to [0,1,2,3] and group 3 becomes equal to [4,5]. Hence, res is equal to [0,1,2,3,4,5] which is sorted in non-decreasing order.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 3`

src/main/kotlin/g2801_2900/s2826_sorting_three_groups/readme.md

@@ -0,0 +1,90 @@
+package g2801_2900.s2827_number_of_beautiful_integers_in_the_range
+
+// #Hard #Dynamic_Programming #Math #2023_12_18_Time_169_ms_(100.00%)_Space_38.7_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    private lateinit var dp: Array<Array<Array<Array<IntArray>>>>
+    private var maxLength = 0
+
+    fun numberOfBeautifulIntegers(low: Int, high: Int, k: Int): Int {
+        val num1 = low.toString()
+        val num2 = high.toString()
+        maxLength = max(num1.length.toDouble(), num2.length.toDouble()).toInt()
+        dp = Array(4) { Array(maxLength) { Array(maxLength) { Array(maxLength) { IntArray(k) } } } }
+        for (a in dp) {
+            for (b in a) {
+                for (c in b) {
+                    for (d in c) {
+                        d.fill(-1)
+                    }
+                }
+            }
+        }
+        return dp(num1, num2, 0, 3, 0, 0, 0, 0, k)
+    }
+
+    private fun dp(
+        low: String,
+        high: String,
+        i: Int,
+        mode: Int,
+        odd: Int,
+        even: Int,
+        num: Int,
+        rem: Int,
+        k: Int
+    ): Int {
+        if (i == maxLength) {
+            return if (num % k == 0 && odd == even) 1 else 0
+        }
+        if (dp[mode][i][odd][even][rem] != -1) {
+            return dp[mode][i][odd][even][rem]
+        }
+        var res = 0
+        val lowLimit = mode % 2 == 1
+        val highLimit = mode / 2 == 1
+        var start = 0
+        var end = 9
+        if (lowLimit) {
+            start = digitAt(low, i)
+        }
+        if (highLimit) {
+            end = digitAt(high, i)
+        }
+        for (j in start..end) {
+            var newMode = 0
+            if (j == start && lowLimit) {
+                newMode += 1
+            }
+            if (j == end && highLimit) {
+                newMode += 2
+            }
+            var newEven = even
+            if (num != 0 || j != 0) {
+                newEven += if (j % 2 == 0) 1 else 0
+            }
+            val newOdd = odd + (if (j % 2 == 1) 1 else 0)
+            res +=
+                dp(
+                    low,
+                    high,
+                    i + 1,
+                    newMode,
+                    newOdd,
+                    newEven,
+                    num * 10 + j,
+                    (num * 10 + j) % k,
+                    k
+                )
+        }
+        dp[mode][i][odd][even][rem] = res
+        return res
+    }
+
+    private fun digitAt(num: String, i: Int): Int {
+        val index = num.length - maxLength + i
+        return if (index < 0) 0 else num[index].code - '0'.code
+    }
+}

src/main/kotlin/g2801_2900/s2827_number_of_beautiful_integers_in_the_range/Solution.kt

@@ -0,0 +1,47 @@
+2827\. Number of Beautiful Integers in the Range
+
+Hard
+
+You are given positive integers `low`, `high`, and `k`.
+
+A number is **beautiful** if it meets both of the following conditions:
+
+*   The count of even digits in the number is equal to the count of odd digits.
+*   The number is divisible by `k`.
+
+Return _the number of beautiful integers in the range_ `[low, high]`.
+
+**Example 1:**
+
+**Input:** low = 10, high = 20, k = 3
+
+**Output:** 2
+
+**Explanation:** There are 2 beautiful integers in the given range: [12,18]. 
+- 12 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 3. 
+- 18 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 3. Additionally we can see that: 
+- 16 is not beautiful because it is not divisible by k = 3. 
+- 15 is not beautiful because it does not contain equal counts even and odd digits. It can be shown that there are only 2 beautiful integers in the given range.
+
+**Example 2:**
+
+**Input:** low = 1, high = 10, k = 1
+
+**Output:** 1
+
+**Explanation:** There is 1 beautiful integer in the given range: [10]. 
+- 10 is beautiful because it contains 1 odd digit and 1 even digit, and is divisible by k = 1. It can be shown that there is only 1 beautiful integer in the given range.
+
+**Example 3:**
+
+**Input:** low = 5, high = 5, k = 2
+
+**Output:** 0
+
+**Explanation:** There are 0 beautiful integers in the given range. 
+- 5 is not beautiful because it is not divisible by k = 2 and it does not contain equal even and odd digits.
+
+**Constraints:**
+
+*   <code>0 < low <= high <= 10<sup>9</sup></code>
+*   `0 < k <= 20`

src/main/kotlin/g2801_2900/s2827_number_of_beautiful_integers_in_the_range/readme.md

@@ -0,0 +1,17 @@
+package g2801_2900.s2828_check_if_a_string_is_an_acronym_of_words
+
+// #Easy #Array #String #2023_12_18_Time_180_ms_(90.14%)_Space_37.7_MB_(45.07%)
+
+class Solution {
+    fun isAcronym(words: List<String>, s: String): Boolean {
+        if (s.length != words.size) {
+            return false
+        }
+        for (i in words.indices) {
+            if (words[i][0] != s[i]) {
+                return false
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g2801_2900/s2828_check_if_a_string_is_an_acronym_of_words/Solution.kt

@@ -0,0 +1,40 @@
+2828\. Check if a String Is an Acronym of Words
+
+Easy
+
+Given an array of strings `words` and a string `s`, determine if `s` is an **acronym** of words.
+
+The string `s` is considered an acronym of `words` if it can be formed by concatenating the **first** character of each string in `words` **in order**. For example, `"ab"` can be formed from `["apple", "banana"]`, but it can't be formed from `["bear", "aardvark"]`.
+
+Return `true` _if_ `s` _is an acronym of_ `words`_, and_ `false` _otherwise._
+
+**Example 1:**
+
+**Input:** words = ["alice","bob","charlie"], s = "abc"
+
+**Output:** true
+
+**Explanation:** The first character in the words "alice", "bob", and "charlie" are 'a', 'b', and 'c', respectively. Hence, s = "abc" is the acronym.
+
+**Example 2:**
+
+**Input:** words = ["an","apple"], s = "a"
+
+**Output:** false
+
+**Explanation:** The first character in the words "an" and "apple" are 'a' and 'a', respectively. The acronym formed by concatenating these characters is "aa". Hence, s = "a" is not the acronym.
+
+**Example 3:**
+
+**Input:** words = ["never","gonna","give","up","on","you"], s = "ngguoy"
+
+**Output:** true
+
+**Explanation:** By concatenating the first character of the words in the array, we get the string "ngguoy". Hence, s = "ngguoy" is the acronym.
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `1 <= words[i].length <= 10`
+*   `1 <= s.length <= 100`
+*   `words[i]` and `s` consist of lowercase English letters.