Added tasks 2745-2749

Author: ThanhNIT

src/main/kotlin/g2701_2800/s2745_construct_the_longest_new_string/Solution.kt

@@ -0,0 +1,13 @@
+package g2701_2800.s2745_construct_the_longest_new_string
+
+// #Medium #Math #Greedy #Brainteaser #2023_08_08_Time_146_ms_(97.37%)_Space_33.6_MB_(94.74%)
+
+class Solution {
+    fun longestString(x: Int, y: Int, z: Int): Int {
+        var first = x.coerceAtMost(y)
+        var second = if (x == y) first else first + 1
+        first = first shl 1
+        second = second shl 1
+        return first + second + (z shl 1)
+    }
+}

src/main/kotlin/g2701_2800/s2745_construct_the_longest_new_string/readme.md

@@ -0,0 +1,31 @@
+2745\. Construct the Longest New String
+
+Medium
+
+You are given three integers `x`, `y`, and `z`.
+
+You have `x` strings equal to `"AA"`, `y` strings equal to `"BB"`, and `z` strings equal to `"AB"`. You want to choose some (possibly all or none) of these strings and concactenate them in some order to form a new string. This new string must not contain `"AAA"` or `"BBB"` as a substring.
+
+Return _the maximum possible length of the new string_.
+
+A **substring** is a contiguous **non-empty** sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** x = 2, y = 5, z = 1
+
+**Output:** 12
+
+**Explanation:** We can concactenate the strings "BB", "AA", "BB", "AA", "BB", and "AB" in that order. Then, our new string is "BBAABBAABBAB". That string has length 12, and we can show that it is impossible to construct a string of longer length.
+
+**Example 2:**
+
+**Input:** x = 3, y = 2, z = 2
+
+**Output:** 14
+
+**Explanation:** We can concactenate the strings "AB", "AB", "AA", "BB", "AA", "BB", and "AA" in that order. Then, our new string is "ABABAABBAABBAA". That string has length 14, and we can show that it is impossible to construct a string of longer length.
+
+**Constraints:**
+
+*   `1 <= x, y, z <= 50`

src/main/kotlin/g2701_2800/s2746_decremental_string_concatenation/Solution.kt

@@ -0,0 +1,48 @@
+package g2701_2800.s2746_decremental_string_concatenation
+
+// #Medium #Array #String #Dynamic_Programming
+// #2023_08_08_Time_264_ms_(100.00%)_Space_44.7_MB_(59.38%)
+
+class Solution {
+    private val inf = 1e9.toInt()
+    private lateinit var dp: Array<Array<Array<Int?>>>
+
+    fun minimizeConcatenatedLength(words: Array<String>): Int {
+        val n = words.size
+        dp = Array(n) {
+            Array(26) {
+                arrayOfNulls(
+                    26
+                )
+            }
+        }
+        val curWord = words[0]
+        val curLen = curWord.length
+        val curFirst = curWord[0]
+        val curLast = curWord[curLen - 1]
+        return curLen + solve(1, curFirst, curLast, n, words)
+    }
+
+    private fun solve(idx: Int, prevFirst: Char, prevLast: Char, n: Int, words: Array<String>): Int {
+        if (idx == n) return 0
+        if (dp[idx][prevFirst.code - 'a'.code][prevLast.code - 'a'.code] != null) {
+            return dp[idx][prevFirst.code - 'a'.code][prevLast.code - 'a'.code]!!
+        }
+        val curWord = words[idx]
+        val curLen = curWord.length
+        val curFirst = curWord[0]
+        val curLast = curWord[curLen - 1]
+        var ans = inf
+        ans = if (prevFirst == curLast) {
+            ans.coerceAtMost(curLen - 1 + solve(idx + 1, curFirst, prevLast, n, words))
+        } else {
+            ans.coerceAtMost(curLen + solve(idx + 1, curFirst, prevLast, n, words))
+        }
+        ans = if (prevLast == curFirst) {
+            ans.coerceAtMost(curLen - 1 + solve(idx + 1, prevFirst, curLast, n, words))
+        } else {
+            ans.coerceAtMost(curLen + solve(idx + 1, prevFirst, curLast, n, words))
+        }
+        return ans.also { dp[idx][prevFirst.code - 'a'.code][prevLast.code - 'a'.code] = it }
+    }
+}

src/main/kotlin/g2701_2800/s2746_decremental_string_concatenation/readme.md

@@ -0,0 +1,64 @@
+2746\. Decremental String Concatenation
+
+Medium
+
+You are given a **0-indexed** array `words` containing `n` strings.
+
+Let's define a **join** operation `join(x, y)` between two strings `x` and `y` as concatenating them into `xy`. However, if the last character of `x` is equal to the first character of `y`, one of them is **deleted**.
+
+For example `join("ab", "ba") = "aba"` and `join("ab", "cde") = "abcde"`.
+
+You are to perform `n - 1` **join** operations. Let <code>str<sub>0</sub> = words[0]</code>. Starting from `i = 1` up to `i = n - 1`, for the <code>i<sup>th</sup></code> operation, you can do one of the following:
+
+*   Make <code>str<sub>i</sub> = join(str<sub>i - 1</sub>, words[i])</code>
+*   Make <code>str<sub>i</sub> = join(words[i], str<sub>i - 1</sub>)</code>
+
+Your task is to **minimize** the length of <code>str<sub>n - 1</sub></code>.
+
+Return _an integer denoting the minimum possible length of_ <code>str<sub>n - 1</sub></code>.
+
+**Example 1:**
+
+**Input:** words = ["aa","ab","bc"]
+
+**Output:** 4
+
+**Explanation:** In this example, we can perform join operations in the following order to minimize the length of str<sub>2</sub>: 
+
+str<sub>0</sub> = "aa" 
+
+str<sub>1</sub> = join(str<sub>0</sub>, "ab") = "aab" 
+
+str<sub>2</sub> = join(str<sub>1</sub>, "bc") = "aabc" 
+
+It can be shown that the minimum possible length of str<sub>2</sub> is 4.
+
+**Example 2:**
+
+**Input:** words = ["ab","b"]
+
+**Output:** 2
+
+**Explanation:** In this example, str<sub>0</sub> = "ab", there are two ways to get str<sub>1</sub>: join(str<sub>0</sub>, "b") = "ab" or join("b", str<sub>0</sub>) = "bab". The first string, "ab", has the minimum length. Hence, the answer is 2.
+
+**Example 3:**
+
+**Input:** words = ["aaa","c","aba"]
+
+**Output:** 6
+
+**Explanation:** In this example, we can perform join operations in the following order to minimize the length of str<sub>2</sub>: 
+
+str<sub>0</sub> = "aaa" 
+
+str<sub>1</sub> = join(str<sub>0</sub>, "c") = "aaac" 
+
+str<sub>2</sub> = join("aba", str<sub>1</sub>) = "abaaac" 
+
+It can be shown that the minimum possible length of str<sub>2</sub> is 6.
+
+**Constraints:**
+
+*   `1 <= words.length <= 1000`
+*   `1 <= words[i].length <= 50`
+*   Each character in `words[i]` is an English lowercase letter

src/main/kotlin/g2701_2800/s2747_count_zero_request_servers/Solution.kt

@@ -0,0 +1,42 @@
+package g2701_2800.s2747_count_zero_request_servers
+
+// #Medium #Array #Hash_Table #Sorting #Sliding_Window
+// #2023_08_08_Time_991_ms_(100.00%)_Space_109.2_MB_(90.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun countServers(n: Int, logs: Array<IntArray>, x: Int, qs: IntArray): IntArray {
+        val m = qs.size
+        val valIdx = Array(m) { IntArray(2) }
+        for (i in 0 until m) valIdx[i] = intArrayOf(qs[i], i)
+        Arrays.sort(valIdx) { a: IntArray, b: IntArray ->
+            a[0] - b[0]
+        }
+        Arrays.sort(logs) { a: IntArray, b: IntArray ->
+            a[1] - b[1]
+        }
+        var l = 0
+        var r = 0
+        val res = IntArray(m)
+        val servCount: HashMap<Int, Int> = HashMap<Int, Int>()
+        for (q in valIdx) {
+            val rVal = q[0]
+            val lVal = q[0] - x
+            val i = q[1]
+            while (r < logs.size && logs[r][1] <= rVal) servCount.merge(logs[r++][0], 1) { a: Int, b: Int ->
+                Integer.sum(
+                    a,
+                    b
+                )
+            }
+            while (l < r && logs[l][1] < lVal) {
+                servCount.compute(logs[l][0]) { _, v -> v!! - 1 }
+                servCount.remove(logs[l][0], 0)
+                l++
+            }
+            res[i] = n - servCount.size
+        }
+        return res
+    }
+}

src/main/kotlin/g2701_2800/s2747_count_zero_request_servers/readme.md

@@ -0,0 +1,48 @@
+2747\. Count Zero Request Servers
+
+Medium
+
+You are given an integer `n` denoting the total number of servers and a **2D** **0-indexed** integer array `logs`, where `logs[i] = [server_id, time]` denotes that the server with id `server_id` received a request at time `time`.
+
+You are also given an integer `x` and a **0-indexed** integer array `queries`.
+
+Return _a **0-indexed** integer array_ `arr` _of length_ `queries.length` _where_ `arr[i]` _represents the number of servers that **did not receive** any requests during the time interval_ `[queries[i] - x, queries[i]]`.
+
+Note that the time intervals are inclusive.
+
+**Example 1:**
+
+**Input:** n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]
+
+**Output:** [1,2]
+
+**Explanation:** 
+
+For queries[0]: The servers with ids 1 and 2 get requests in the duration of [5, 10]. 
+
+Hence, only server 3 gets zero requests. 
+
+For queries[1]: Only the server with id 2 gets a request in duration of [6,11]. Hence, the servers with ids 1 and 3 are the only servers that do not receive any requests during that time period.
+
+**Example 2:**
+
+**Input:** n = 3, logs = [[2,4],[2,1],[1,2],[3,1]], x = 2, queries = [3,4]
+
+**Output:** [0,1]
+
+**Explanation:** 
+
+For queries[0]: All servers get at least one request in the duration of [1, 3].
+
+For queries[1]: Only server with id 3 gets no request in the duration [2,4].
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= logs.length <= 10<sup>5</sup></code>
+*   <code>1 <= queries.length <= 10<sup>5</sup></code>
+*   `logs[i].length == 2`
+*   `1 <= logs[i][0] <= n`
+*   <code>1 <= logs[i][1] <= 10<sup>6</sup></code>
+*   <code>1 <= x <= 10<sup>5</sup></code>
+*   <code>x < queries[i] <= 10<sup>6</sup></code>

src/main/kotlin/g2701_2800/s2748_number_of_beautiful_pairs/Solution.kt

@@ -0,0 +1,38 @@
+package g2701_2800.s2748_number_of_beautiful_pairs
+
+// #Easy #Array #Math #Number_Theory #2023_08_08_Time_227_ms_(100.00%)_Space_38.5_MB_(100.00%)
+
+class Solution {
+    fun countBeautifulPairs(nums: IntArray): Int {
+        var beautifulPairs = 0
+        var i = 0
+        var j = 1
+        while (i < nums.size - 1) {
+            val firstDigit = getFirstDigit(nums[i])
+            while (j < nums.size) {
+                val lastDigit = nums[j] % 10
+                val botDigitsAreEqualAndNot1 = firstDigit == lastDigit && firstDigit > 1
+                val botDigitsAreDivisibleBy2 = firstDigit % 2 == 0 && lastDigit % 2 == 0
+                val botDigitsAreDivisibleBy3 = firstDigit % 3 == 0 && lastDigit % 3 == 0
+
+                if (!botDigitsAreEqualAndNot1 && !botDigitsAreDivisibleBy2 && !botDigitsAreDivisibleBy3) {
+                    beautifulPairs++
+                }
+                j++
+            }
+            i++
+            j = i + 1
+        }
+        return beautifulPairs
+    }
+
+    private fun getFirstDigit(num: Int): Int {
+        var n = num
+        var digit = 0
+        while (n > 0) {
+            digit = n % 10
+            n /= 10
+        }
+        return digit
+    }
+}

src/main/kotlin/g2701_2800/s2748_number_of_beautiful_pairs/readme.md

@@ -0,0 +1,49 @@
+2748\. Number of Beautiful Pairs
+
+Easy
+
+You are given a **0-indexed** integer array `nums`. A pair of indices `i`, `j` where `0 <= i < j < nums.length` is called beautiful if the **first digit** of `nums[i]` and the **last digit** of `nums[j]` are **coprime**.
+
+Return _the total number of beautiful pairs in_ `nums`.
+
+Two integers `x` and `y` are **coprime** if there is no integer greater than 1 that divides both of them. In other words, `x` and `y` are coprime if `gcd(x, y) == 1`, where `gcd(x, y)` is the **greatest common divisor** of `x` and `y`.
+
+**Example 1:**
+
+**Input:** nums = [2,5,1,4]
+
+**Output:** 5
+
+**Explanation:** There are 5 beautiful pairs in nums: 
+
+When i = 0 and j = 1: the first digit of nums[0] is 2, and the last digit of nums[1] is 5. We can confirm that 2 and 5 are coprime, since gcd(2,5) == 1. 
+
+When i = 0 and j = 2: the first digit of nums[0] is 2, and the last digit of nums[2] is 1. Indeed, gcd(2,1) == 1. 
+
+When i = 1 and j = 2: the first digit of nums[1] is 5, and the last digit of nums[2] is 1. Indeed, gcd(5,1) == 1.
+
+When i = 1 and j = 3: the first digit of nums[1] is 5, and the last digit of nums[3] is 4. Indeed, gcd(5,4) == 1.
+
+When i = 2 and j = 3: the first digit of nums[2] is 1, and the last digit of nums[3] is 4. Indeed, gcd(1,4) == 1. 
+
+Thus, we return 5.
+
+**Example 2:**
+
+**Input:** nums = [11,21,12]
+
+**Output:** 2
+
+**Explanation:** There are 2 beautiful pairs: 
+
+When i = 0 and j = 1: the first digit of nums[0] is 1, and the last digit of nums[1] is 1. Indeed, gcd(1,1) == 1. 
+
+When i = 0 and j = 2: the first digit of nums[0] is 1, and the last digit of nums[2] is 2. Indeed, gcd(1,2) == 1. 
+
+Thus, we return 2.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 100`
+*   `1 <= nums[i] <= 9999`
+*   `nums[i] % 10 != 0`

src/main/kotlin/g2701_2800/s2749_minimum_operations_to_make_the_integer_zero/Solution.kt

@@ -0,0 +1,18 @@
+package g2701_2800.s2749_minimum_operations_to_make_the_integer_zero
+
+// #Medium #Bit_Manipulation #Brainteaser #2023_08_08_Time_132_ms_(91.67%)_Space_33.2_MB_(62.50%)
+
+class Solution {
+    fun makeTheIntegerZero(num1: Int, num2: Int): Int {
+        val n1 = num1.toLong()
+        val n2 = num2.toLong()
+        for (i in 0..60) {
+            val target = n1 - n2 * i
+            val noOfBits = java.lang.Long.bitCount(target)
+            if (i.toLong() in noOfBits..target) {
+                return i
+            }
+        }
+        return -1
+    }
+}