Added tasks 3163-3165

Author: javadev

src/main/kotlin/g3101_3200/s3163_string_compression_iii/Solution.kt

@@ -0,0 +1,29 @@
+package g3101_3200.s3163_string_compression_iii
+
+// #Medium #String #2024_06_03_Time_331_ms_(66.13%)_Space_45.8_MB_(41.94%)
+
+class Solution {
+    fun compressedString(word: String): String {
+        val builder = StringBuilder()
+        var last = word[0]
+        var count = 1
+        var i = 1
+        val l = word.length
+        while (i < l) {
+            if (word[i] == last) {
+                count++
+                if (count == 10) {
+                    builder.append(9).append(last)
+                    count = 1
+                }
+            } else {
+                builder.append(count).append(last)
+                last = word[i]
+                count = 1
+            }
+            i++
+        }
+        builder.append(count).append(last)
+        return builder.toString()
+    }
+}

src/main/kotlin/g3101_3200/s3163_string_compression_iii/readme.md

@@ -0,0 +1,42 @@
+3163\. String Compression III
+
+Medium
+
+Given a string `word`, compress it using the following algorithm:
+
+*   Begin with an empty string `comp`. While `word` is **not** empty, use the following operation:
+    *   Remove a maximum length prefix of `word` made of a _single character_ `c` repeating **at most** 9 times.
+    *   Append the length of the prefix followed by `c` to `comp`.
+
+Return the string `comp`.
+
+**Example 1:**
+
+**Input:** word = "abcde"
+
+**Output:** "1a1b1c1d1e"
+
+**Explanation:**
+
+Initially, `comp = ""`. Apply the operation 5 times, choosing `"a"`, `"b"`, `"c"`, `"d"`, and `"e"` as the prefix in each operation.
+
+For each prefix, append `"1"` followed by the character to `comp`.
+
+**Example 2:**
+
+**Input:** word = "aaaaaaaaaaaaaabb"
+
+**Output:** "9a5a2b"
+
+**Explanation:**
+
+Initially, `comp = ""`. Apply the operation 3 times, choosing `"aaaaaaaaa"`, `"aaaaa"`, and `"bb"` as the prefix in each operation.
+
+*   For prefix `"aaaaaaaaa"`, append `"9"` followed by `"a"` to `comp`.
+*   For prefix `"aaaaa"`, append `"5"` followed by `"a"` to `comp`.
+*   For prefix `"bb"`, append `"2"` followed by `"b"` to `comp`.
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 2 * 10<sup>5</sup></code>
+*   `word` consists only of lowercase English letters.

src/main/kotlin/g3101_3200/s3164_find_the_number_of_good_pairs_ii/Solution.kt

@@ -0,0 +1,35 @@
+package g3101_3200.s3164_find_the_number_of_good_pairs_ii
+
+// #Medium #Array #Hash_Table #2024_06_03_Time_1175_ms_(90.00%)_Space_75_MB_(65.00%)
+
+class Solution {
+    fun numberOfPairs(nums1: IntArray, nums2: IntArray, k: Int): Long {
+        val hm = HashMap<Int, Int>()
+        var ans: Long = 0
+        for (`val` in nums2) {
+            hm[`val` * k] = hm.getOrDefault(`val` * k, 0) + 1
+        }
+        for (index in nums1.indices) {
+            if (nums1[index] % k != 0) {
+                continue
+            }
+            var factor = 1
+            while (factor * factor <= nums1[index]) {
+                if (nums1[index] % factor != 0) {
+                    factor++
+                    continue
+                }
+                val factor1 = factor
+                val factor2 = nums1[index] / factor
+                if (hm.containsKey(factor1)) {
+                    ans += hm[factor1]!!.toLong()
+                }
+                if (factor1 != factor2 && hm.containsKey(factor2)) {
+                    ans += hm[factor2]!!.toLong()
+                }
+                factor++
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g3101_3200/s3164_find_the_number_of_good_pairs_ii/readme.md

@@ -0,0 +1,35 @@
+3164\. Find the Number of Good Pairs II
+
+Medium
+
+You are given 2 integer arrays `nums1` and `nums2` of lengths `n` and `m` respectively. You are also given a **positive** integer `k`.
+
+A pair `(i, j)` is called **good** if `nums1[i]` is divisible by `nums2[j] * k` (`0 <= i <= n - 1`, `0 <= j <= m - 1`).
+
+Return the total number of **good** pairs.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3,4], nums2 = [1,3,4], k = 1
+
+**Output:** 5
+
+**Explanation:**
+
+The 5 good pairs are `(0, 0)`, `(1, 0)`, `(1, 1)`, `(2, 0)`, and `(2, 2)`.
+
+**Example 2:**
+
+**Input:** nums1 = [1,2,4,12], nums2 = [2,4], k = 3
+
+**Output:** 2
+
+**Explanation:**
+
+The 2 good pairs are `(3, 0)` and `(3, 1)`.
+
+**Constraints:**
+
+*   <code>1 <= n, m <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i], nums2[j] <= 10<sup>6</sup></code>
+*   <code>1 <= k <= 10<sup>3</sup></code>

src/main/kotlin/g3101_3200/s3165_maximum_sum_of_subsequence_with_non_adjacent_elements/Solution.kt

@@ -0,0 +1,124 @@
+package g3101_3200.s3165_maximum_sum_of_subsequence_with_non_adjacent_elements
+
+// #Hard #Array #Dynamic_Programming #Divide_and_Conquer #Segment_Tree
+// #2024_06_03_Time_1301_ms_(22.22%)_Space_69.8_MB_(100.00%)
+
+import java.util.stream.Stream
+import kotlin.math.max
+
+class Solution {
+    fun maximumSumSubsequence(nums: IntArray, queries: Array<IntArray>): Int {
+        var ans = 0
+        val segTree = SegTree(nums)
+        for (q in queries) {
+            val idx = q[0]
+            val `val` = q[1]
+            segTree.update(idx, `val`)
+            ans = (ans + segTree.max!!) % MOD
+        }
+        return ans
+    }
+
+    internal class SegTree(private val nums: IntArray) {
+        private class Record {
+            var takeFirstTakeLast: Int = 0
+            var takeFirstSkipLast: Int = 0
+            var skipFirstSkipLast: Int = 0
+            var skipFirstTakeLast: Int = 0
+
+            val max: Int
+                get() = Stream.of(
+                    this.takeFirstSkipLast,
+                    this.takeFirstTakeLast,
+                    this.skipFirstSkipLast,
+                    this.skipFirstTakeLast
+                )
+                    .max { x: Int?, y: Int? -> x!!.compareTo(y!!) }
+                    .orElse(null)
+
+            fun skipLast(): Int? {
+                return Stream.of(this.takeFirstSkipLast, this.skipFirstSkipLast)
+                    .max { x: Int?, y: Int? -> x!!.compareTo(y!!) }
+                    .orElse(null)
+            }
+
+            fun takeLast(): Int? {
+                return Stream.of(this.skipFirstTakeLast, this.takeFirstTakeLast)
+                    .max { x: Int?, y: Int? -> x!!.compareTo(y!!) }
+                    .orElse(null)
+            }
+        }
+
+        private val seg = arrayOfNulls<Record>(4 * nums.size)
+
+        init {
+            for (i in 0 until 4 * nums.size) {
+                seg[i] = Record()
+            }
+            build(0, nums.size - 1, 0)
+        }
+
+        private fun build(i: Int, j: Int, k: Int) {
+            if (i == j) {
+                seg[k]!!.takeFirstTakeLast = nums[i]
+                return
+            }
+            val mid = (i + j) shr 1
+            build(i, mid, 2 * k + 1)
+            build(mid + 1, j, 2 * k + 2)
+            merge(k)
+        }
+
+        // merge [2*k+1, 2*k+2] into k
+        private fun merge(k: Int) {
+            seg[k]!!.takeFirstSkipLast = max(
+                (seg[2 * k + 1]!!.takeFirstSkipLast + seg[2 * k + 2]!!.skipLast()!!),
+                (seg[2 * k + 1]!!.takeFirstTakeLast + seg[2 * k + 2]!!.skipFirstSkipLast)
+            )
+
+            seg[k]!!.takeFirstTakeLast = max(
+                (seg[2 * k + 1]!!.takeFirstSkipLast + seg[2 * k + 2]!!.takeLast()!!),
+                (seg[2 * k + 1]!!.takeFirstTakeLast + seg[2 * k + 2]!!.skipFirstTakeLast)
+            )
+
+            seg[k]!!.skipFirstTakeLast = max(
+                (seg[2 * k + 1]!!.skipFirstSkipLast + seg[2 * k + 2]!!.takeLast()!!),
+                (seg[2 * k + 1]!!.skipFirstTakeLast + seg[2 * k + 2]!!.skipFirstTakeLast)
+            )
+
+            seg[k]!!.skipFirstSkipLast = max(
+                (seg[2 * k + 1]!!.skipFirstSkipLast + seg[2 * k + 2]!!.skipLast()!!),
+                (seg[2 * k + 1]!!.skipFirstTakeLast + seg[2 * k + 2]!!.skipFirstSkipLast)
+            )
+        }
+
+        // child -> parent
+        fun update(idx: Int, `val`: Int) {
+            val i = 0
+            val j = nums.size - 1
+            val k = 0
+            update(idx, `val`, k, i, j)
+        }
+
+        private fun update(idx: Int, `val`: Int, k: Int, i: Int, j: Int) {
+            if (i == j) {
+                seg[k]!!.takeFirstTakeLast = `val`
+                return
+            }
+            val mid = (i + j) shr 1
+            if (idx <= mid) {
+                update(idx, `val`, 2 * k + 1, i, mid)
+            } else {
+                update(idx, `val`, 2 * k + 2, mid + 1, j)
+            }
+            merge(k)
+        }
+
+        val max: Int?
+            get() = seg[0]?.max
+    }
+
+    companion object {
+        private const val MOD = 1000000007
+    }
+}

src/main/kotlin/g3101_3200/s3165_maximum_sum_of_subsequence_with_non_adjacent_elements/readme.md

@@ -0,0 +1,41 @@
+3165\. Maximum Sum of Subsequence With Non-adjacent Elements
+
+Hard
+
+You are given an array `nums` consisting of integers. You are also given a 2D array `queries`, where <code>queries[i] = [pos<sub>i</sub>, x<sub>i</sub>]</code>.
+
+For query `i`, we first set <code>nums[pos<sub>i</sub>]</code> equal to <code>x<sub>i</sub></code>, then we calculate the answer to query `i` which is the **maximum** sum of a subsequence of `nums` where **no two adjacent elements are selected**.
+
+Return the _sum_ of the answers to all queries.
+
+Since the final answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A **subsequence** is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
+
+**Example 1:**
+
+**Input:** nums = [3,5,9], queries = [[1,-2],[0,-3]]
+
+**Output:** 21
+
+**Explanation:**   
+ After the 1<sup>st</sup> query, `nums = [3,-2,9]` and the maximum sum of a subsequence with non-adjacent elements is `3 + 9 = 12`.   
+ After the 2<sup>nd</sup> query, `nums = [-3,-2,9]` and the maximum sum of a subsequence with non-adjacent elements is 9.
+
+**Example 2:**
+
+**Input:** nums = [0,-1], queries = [[0,-5]]
+
+**Output:** 0
+
+**Explanation:**   
+ After the 1<sup>st</sup> query, `nums = [-5,-1]` and the maximum sum of a subsequence with non-adjacent elements is 0 (choosing an empty subsequence).
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 5 * 10<sup>4</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+*   <code>1 <= queries.length <= 5 * 10<sup>4</sup></code>
+*   <code>queries[i] == [pos<sub>i</sub>, x<sub>i</sub>]</code>
+*   <code>0 <= pos<sub>i</sub> <= nums.length - 1</code>
+*   <code>-10<sup>5</sup> <= x<sub>i</sub> <= 10<sup>5</sup></code>

src/test/kotlin/g3101_3200/s3163_string_compression_iii/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g3101_3200.s3163_string_compression_iii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun compressedString() {
+        assertThat(Solution().compressedString("abcde"), equalTo("1a1b1c1d1e"))
+    }
+
+    @Test
+    fun compressedString2() {
+        assertThat(Solution().compressedString("aaaaaaaaaaaaaabb"), equalTo("9a5a2b"))
+    }
+}

src/test/kotlin/g3101_3200/s3164_find_the_number_of_good_pairs_ii/SolutionTest.kt

@@ -0,0 +1,23 @@
+package g3101_3200.s3164_find_the_number_of_good_pairs_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun numberOfPairs() {
+        assertThat(
+            Solution().numberOfPairs(intArrayOf(1, 3, 4), intArrayOf(1, 3, 4), 1),
+            equalTo(5L)
+        )
+    }
+
+    @Test
+    fun numberOfPairs2() {
+        assertThat(
+            Solution().numberOfPairs(intArrayOf(1, 2, 4, 12), intArrayOf(2, 4), 3),
+            equalTo(2L)
+        )
+    }
+}

src/test/kotlin/g3101_3200/s3165_maximum_sum_of_subsequence_with_non_adjacent_elements/SolutionTest.kt

@@ -0,0 +1,24 @@
+package g3101_3200.s3165_maximum_sum_of_subsequence_with_non_adjacent_elements
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maximumSumSubsequence() {
+        assertThat(
+            Solution()
+                .maximumSumSubsequence(intArrayOf(3, 5, 9), arrayOf(intArrayOf(1, -2), intArrayOf(0, -3))),
+            equalTo(21)
+        )
+    }
+
+    @Test
+    fun maximumSumSubsequence2() {
+        assertThat(
+            Solution().maximumSumSubsequence(intArrayOf(0, -1), arrayOf(intArrayOf(0, -5))),
+            equalTo(0)
+        )
+    }
+}