Added tasks 3701-3704

Author: javadev

src/main/kotlin/g3701_3800/s3701_compute_alternating_sum/Solution.kt

@@ -0,0 +1,18 @@
+package g3701_3800.s3701_compute_alternating_sum
+
+// #Easy #Weekly_Contest_470 #2025_10_06_Time_1_ms_(100.00%)_Space_47.16_MB_(11.11%)
+
+class Solution {
+    fun alternatingSum(nums: IntArray): Int {
+        var sum = 0
+        for (i in nums.indices) {
+            val num = nums[i]
+            if (i % 2 == 0) {
+                sum += num
+            } else {
+                sum -= num
+            }
+        }
+        return sum
+    }
+}

src/main/kotlin/g3701_3800/s3701_compute_alternating_sum/readme.md

@@ -0,0 +1,38 @@
+3701\. Compute Alternating Sum
+
+Easy
+
+You are given an integer array `nums`.
+
+The **alternating sum** of `nums` is the value obtained by **adding** elements at even indices and **subtracting** elements at odd indices. That is, `nums[0] - nums[1] + nums[2] - nums[3]...`
+
+Return an integer denoting the alternating sum of `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,3,5,7]
+
+**Output:** \-4
+
+**Explanation:**
+
+*   Elements at even indices are `nums[0] = 1` and `nums[2] = 5` because 0 and 2 are even numbers.
+*   Elements at odd indices are `nums[1] = 3` and `nums[3] = 7` because 1 and 3 are odd numbers.
+*   The alternating sum is `nums[0] - nums[1] + nums[2] - nums[3] = 1 - 3 + 5 - 7 = -4`.
+
+**Example 2:**
+
+**Input:** nums = [100]
+
+**Output:** 100
+
+**Explanation:**
+
+*   The only element at even indices is `nums[0] = 100` because 0 is an even number.
+*   There are no elements on odd indices.
+*   The alternating sum is `nums[0] = 100`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`

src/main/kotlin/g3701_3800/s3702_longest_subsequence_with_non_zero_bitwise_xor/Solution.kt

@@ -0,0 +1,20 @@
+package g3701_3800.s3702_longest_subsequence_with_non_zero_bitwise_xor
+
+// #Medium #Weekly_Contest_470 #2025_10_06_Time_2_ms_(100.00%)_Space_79.41_MB_(83.33%)
+
+class Solution {
+    fun longestSubsequence(nums: IntArray): Int {
+        var xorSum = 0
+        var allZero = true
+        for (num in nums) {
+            xorSum = xorSum xor num
+            if (num != 0) {
+                allZero = false
+            }
+        }
+        if (allZero) {
+            return 0
+        }
+        return if (xorSum != 0) nums.size else nums.size - 1
+    }
+}

src/main/kotlin/g3701_3800/s3702_longest_subsequence_with_non_zero_bitwise_xor/readme.md

@@ -0,0 +1,32 @@
+3702\. Longest Subsequence With Non-Zero Bitwise XOR
+
+Medium
+
+You are given an integer array `nums`.
+
+Return the length of the **longest subsequence** in `nums` whose bitwise **XOR** is **non-zero**. If no such **subsequence** exists, return 0.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 2
+
+**Explanation:**
+
+One longest subsequence is `[2, 3]`. The bitwise XOR is computed as `2 XOR 3 = 1`, which is non-zero.
+
+**Example 2:**
+
+**Input:** nums = [2,3,4]
+
+**Output:** 3
+
+**Explanation:**
+
+The longest subsequence is `[2, 3, 4]`. The bitwise XOR is computed as `2 XOR 3 XOR 4 = 5`, which is non-zero.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>

src/main/kotlin/g3701_3800/s3703_remove_k_balanced_substrings/Solution.kt

@@ -0,0 +1,38 @@
+package g3701_3800.s3703_remove_k_balanced_substrings
+
+// #Medium #Weekly_Contest_470 #2025_10_06_Time_58_ms_(100.00%)_Space_51.31_MB_(80.00%)
+
+class Solution {
+    fun removeSubstring(s: String, k: Int): String {
+        val sb = StringBuilder()
+        var count = 0
+        for (ch in s.toCharArray()) {
+            sb.append(ch)
+            if (ch == '(') {
+                count++
+            } else {
+                if (count >= k && sb.length >= 2 * k) {
+                    val len = sb.length
+                    var b = true
+                    for (i in len - 2 * k..<len - k) {
+                        if (sb.get(i) != '(') {
+                            b = false
+                            break
+                        }
+                    }
+                    for (i in len - k..<len) {
+                        if (sb.get(i) != ')') {
+                            b = false
+                            break
+                        }
+                    }
+                    if (b) {
+                        sb.delete(sb.length - 2 * k, sb.length)
+                        count -= k
+                    }
+                }
+            }
+        }
+        return sb.toString()
+    }
+}

src/main/kotlin/g3701_3800/s3703_remove_k_balanced_substrings/readme.md

@@ -0,0 +1,70 @@
+3703\. Remove K-Balanced Substrings
+
+Medium
+
+You are given a string `s` consisting of `'('` and `')'`, and an integer `k`.
+
+A **string** is **k-balanced** if it is **exactly** `k` **consecutive** `'('` followed by `k` **consecutive** `')'`, i.e., `'(' * k + ')' * k`.
+
+For example, if `k = 3`, k-balanced is `"((()))"`.
+
+You must **repeatedly** remove all **non-overlapping k-balanced **substring**** from `s`, and then join the remaining parts. Continue this process until no k-balanced **substring** exists.
+
+Return the final string after all possible removals.
+
+**Example 1:**
+
+**Input:** s = "(())", k = 1
+
+**Output:** ""
+
+**Explanation:**
+
+k-balanced substring is `"()"`
+
+| Step | Current `s`  | `k-balanced`             | Result `s` |
+|------|--------------|--------------------------|------------|
+| 1    | `(() )`      | `(<s>**()**</s>)`        | `()`       |
+| 2    | `()`         | `<s>**()`**</s>`         | Empty      |
+
+Thus, the final string is `""`.
+
+**Example 2:**
+
+**Input:** s = "(()(", k = 1
+
+**Output:** "(("
+
+**Explanation:**
+
+k-balanced substring is `"()"`
+
+| Step | Current `s`  | `k-balanced`         | Result `s` |
+|------|--------------|----------------------|------------|
+| 1    | `(()(`       | `(~**()**~)(`        | `((`       |
+| 2    | `((`         | -                    | `((`       |
+
+Thus, the final string is `"(("`.
+
+**Example 3:**
+
+**Input:** s = "((()))()()()", k = 3
+
+**Output:** "()()()"
+
+**Explanation:**
+
+k-balanced substring is `"((()))"`
+
+| Step | Current `s`       | `k-balanced`                     | Result `s` |
+|------|-------------------|----------------------------------|------------|
+| 1    | `((()))()()()`    | ~~**((()))**~~`()()()`           | `()()()`   |
+| 2    | `()()()`          | -                                | `()()()`   |
+
+Thus, the final string is `"()()()"`.
+
+**Constraints:**
+
+*   <code>2 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists only of `'('` and `')'`.
+*   `1 <= k <= s.length / 2`

src/main/kotlin/g3701_3800/s3704_count_no_zero_pairs_that_sum_to_n/Solution.kt

@@ -0,0 +1,61 @@
+package g3701_3800.s3704_count_no_zero_pairs_that_sum_to_n
+
+// #Hard #Weekly_Contest_470 #2025_10_06_Time_11_ms_(100.00%)_Space_42.73_MB_(100.00%)
+
+class Solution {
+    fun countNoZeroPairs(n: Long): Long {
+        var m = 0
+        var base: Long = 1
+        while (base <= n) {
+            m++
+            base = base * 10
+        }
+        val digits = IntArray(m)
+        var c = n
+        for (i in 0..<m) {
+            digits[i] = (c % 10).toInt()
+            c = c / 10
+        }
+        var total: Long = 0
+        var extra = longArrayOf(1, 0)
+        base = 1
+        for (p in 0..<m) {
+            val nextExtra = longArrayOf(0, 0)
+            for (e in 0..1) {
+                for (i in 1..9) {
+                    for (j in 1..9) {
+                        if ((i + j + e) % 10 == digits[p]) {
+                            nextExtra[(i + j + e) / 10] += extra[e]
+                        }
+                    }
+                }
+            }
+            extra = nextExtra
+            base = base * 10
+            for (e in 0..1) {
+                val left = n / base - e
+                if (left < 0) {
+                    continue
+                }
+                if (left == 0L) {
+                    total += extra[e]
+                } else if (isGood(left)) {
+                    total += 2 * extra[e]
+                }
+            }
+        }
+
+        return total
+    }
+
+    private fun isGood(num: Long): Boolean {
+        var num = num
+        while (num > 0) {
+            if (num % 10 == 0L) {
+                return false
+            }
+            num = num / 10
+        }
+        return true
+    }
+}

src/main/kotlin/g3701_3800/s3704_count_no_zero_pairs_that_sum_to_n/readme.md

@@ -0,0 +1,46 @@
+3704\. Count No-Zero Pairs That Sum to N
+
+Hard
+
+A **no-zero** integer is a **positive** integer that **does not contain the digit** 0 in its decimal representation.
+
+Given an integer `n`, count the number of pairs `(a, b)` where:
+
+*   `a` and `b` are **no-zero** integers.
+*   `a + b = n`
+
+Return an integer denoting the number of such pairs.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 1
+
+**Explanation:**
+
+The only pair is `(1, 1)`.
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 2
+
+**Explanation:**
+
+The pairs are `(1, 2)` and `(2, 1)`.
+
+**Example 3:**
+
+**Input:** n = 11
+
+**Output:** 8
+
+**Explanation:**
+
+The pairs are `(2, 9)`, `(3, 8)`, `(4, 7)`, `(5, 6)`, `(6, 5)`, `(7, 4)`, `(8, 3)`, and `(9, 2)`. Note that `(1, 10)` and `(10, 1)` do not satisfy the conditions because 10 contains 0 in its decimal representation.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>15</sup></code>

src/test/kotlin/g3701_3800/s3701_compute_alternating_sum/SolutionTest.kt

@@ -0,0 +1,20 @@
+package g3701_3800.s3701_compute_alternating_sum
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun alternatingSum() {
+        assertThat<Int>(
+            Solution().alternatingSum(intArrayOf(1, 3, 5, 7)),
+            equalTo<Int>(-4),
+        )
+    }
+
+    @Test
+    fun alternatingSum2() {
+        assertThat<Int>(Solution().alternatingSum(intArrayOf(100)), equalTo<Int>(100))
+    }
+}

src/test/kotlin/g3701_3800/s3702_longest_subsequence_with_non_zero_bitwise_xor/SolutionTest.kt

@@ -0,0 +1,23 @@
+package g3701_3800.s3702_longest_subsequence_with_non_zero_bitwise_xor
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun longestSubsequence() {
+        assertThat<Int>(
+            Solution().longestSubsequence(intArrayOf(1, 2, 3)),
+            equalTo<Int>(2),
+        )
+    }
+
+    @Test
+    fun longestSubsequence2() {
+        assertThat<Int>(
+            Solution().longestSubsequence(intArrayOf(2, 3, 4)),
+            equalTo<Int>(3),
+        )
+    }
+}