Added tasks 3701-3704

Author: javadev

src/main/java/g3701_3800/s3701_compute_alternating_sum/Solution.java

@@ -0,0 +1,15 @@
+package g3701_3800.s3701_compute_alternating_sum;
+
+// #Easy #Weekly_Contest_470 #2025_10_05_Time_1_ms_(100.00%)_Space_44.28_MB_(66.67%)
+
+public class Solution {
+    public int alternatingSum(int[] nums) {
+        int sum = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+            if (i % 2 == 0) sum += num;
+            else sum -= num;
+        }
+        return sum;
+    }
+}

src/main/java/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/java/g3701_3800/s3702_longest_subsequence_with_non_zero_bitwise_xor/Solution.java

@@ -0,0 +1,20 @@
+package g3701_3800.s3702_longest_subsequence_with_non_zero_bitwise_xor;
+
+// #Medium #Weekly_Contest_470 #2025_10_05_Time_2_ms_(100.00%)_Space_64.20_MB_(100.00%)
+
+public class Solution {
+    public int longestSubsequence(int[] nums) {
+        int xorSum = 0;
+        boolean allZero = true;
+        for (int num : nums) {
+            xorSum ^= num;
+            if (num != 0) {
+                allZero = false;
+            }
+        }
+        if (allZero) {
+            return 0;
+        }
+        return xorSum != 0 ? nums.length : nums.length - 1;
+    }
+}

src/main/java/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/java/g3701_3800/s3703_remove_k_balanced_substrings/Solution.java

@@ -0,0 +1,38 @@
+package g3701_3800.s3703_remove_k_balanced_substrings;
+
+// #Medium #Weekly_Contest_470 #2025_10_05_Time_191_ms_(100.00%)_Space_45.86_MB_(100.00%)
+
+public class Solution {
+    public String removeSubstring(String s, int k) {
+        StringBuilder sb = new StringBuilder();
+        int count = 0;
+        for (char ch : s.toCharArray()) {
+            sb.append(ch);
+            if (ch == '(') {
+                count++;
+            } else {
+                if (count >= k && sb.length() >= 2 * k) {
+                    int len = sb.length();
+                    boolean b = true;
+                    for (int i = len - 2 * k; i < len - k; i++) {
+                        if (sb.charAt(i) != '(') {
+                            b = false;
+                            break;
+                        }
+                    }
+                    for (int i = len - k; i < len; i++) {
+                        if (sb.charAt(i) != ')') {
+                            b = false;
+                            break;
+                        }
+                    }
+                    if (b) {
+                        sb.delete(sb.length() - 2 * k, sb.length());
+                        count -= k;
+                    }
+                }
+            }
+        }
+        return sb.toString();
+    }
+}

src/main/java/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/java/g3701_3800/s3704_count_no_zero_pairs_that_sum_to_n/Solution.java

@@ -0,0 +1,61 @@
+package g3701_3800.s3704_count_no_zero_pairs_that_sum_to_n;
+
+// #Hard #Weekly_Contest_470 #2025_10_05_Time_4_ms_(97.37%)_Space_41.07_MB_(100.00%)
+
+public class Solution {
+    public long countNoZeroPairs(long n) {
+        int m = 0;
+        long base = 1;
+        while (base <= n) {
+            m++;
+            base = base * 10;
+        }
+        int[] digits = new int[m];
+        long c = n;
+        for (int i = 0; i < m; i++) {
+            digits[i] = (int) (c % 10);
+            c = c / 10;
+        }
+
+        long total = 0;
+        long[] extra = {1, 0};
+        base = 1;
+        for (int p = 0; p < m; p++) {
+            long[] nextExtra = {0, 0};
+            for (int e = 0; e <= 1; e++) {
+                for (int i = 1; i <= 9; i++) {
+                    for (int j = 1; j <= 9; j++) {
+                        if ((i + j + e) % 10 == digits[p]) {
+                            nextExtra[(i + j + e) / 10] += extra[e];
+                        }
+                    }
+                }
+            }
+            extra = nextExtra;
+            base = base * 10;
+            for (int e = 0; e <= 1; e++) {
+                long left = n / base - e;
+                if (left < 0) {
+                    continue;
+                }
+                if (left == 0) {
+                    total += extra[e];
+                } else if (isGood(left)) {
+                    total += 2 * extra[e];
+                }
+            }
+        }
+
+        return total;
+    }
+
+    private boolean isGood(long num) {
+        while (num > 0) {
+            if (num % 10 == 0) {
+                return false;
+            }
+            num = num / 10;
+        }
+        return true;
+    }
+}

src/main/java/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/java/g3701_3800/s3701_compute_alternating_sum/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3701_3800.s3701_compute_alternating_sum;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void alternatingSum() {
+        assertThat(new Solution().alternatingSum(new int[] {1, 3, 5, 7}), equalTo(-4));
+    }
+
+    @Test
+    void alternatingSum2() {
+        assertThat(new Solution().alternatingSum(new int[] {100}), equalTo(100));
+    }
+}

src/test/java/g3701_3800/s3702_longest_subsequence_with_non_zero_bitwise_xor/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3701_3800.s3702_longest_subsequence_with_non_zero_bitwise_xor;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void longestSubsequence() {
+        assertThat(new Solution().longestSubsequence(new int[] {1, 2, 3}), equalTo(2));
+    }
+
+    @Test
+    void longestSubsequence2() {
+        assertThat(new Solution().longestSubsequence(new int[] {2, 3, 4}), equalTo(3));
+    }
+}