Added tasks 3876-3892

Author: ThanhNIT

src/main/java/g3801_3900/s3876_construct_uniform_parity_array_ii/Solution.java

@@ -0,0 +1,22 @@
+package g3801_3900.s3876_construct_uniform_parity_array_ii;
+
+// #Medium #Array #Math #Senior #Weekly_Contest_494
+// #2026_08_13_Time_2_ms_(100.00%)_Space_121.98_MB_(11.30%)
+
+public class Solution {
+    public boolean uniformArray(int[] nums1) {
+        int min = Integer.MAX_VALUE;
+        for (int x : nums1) {
+            min = Math.min(min, x);
+        }
+        if (min % 2 == 1) {
+            return true;
+        }
+        for (int x : nums1) {
+            if (x % 2 == 1) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/g3801_3900/s3876_construct_uniform_parity_array_ii/readme.md

@@ -0,0 +1,55 @@
+3876\. Construct Uniform Parity Array II
+
+Medium
+
+You are given an array `nums1` of `n` **distinct** integers.
+
+You want to construct another array `nums2` of length `n` such that the elements in `nums2` are either **all odd or all even**.
+
+For each index `i`, you must choose **exactly one** of the following (in any order):
+
+*   `nums2[i] = nums1[i]`
+*   `nums2[i] = nums1[i] - nums1[j]`, for an index `j != i`, such that `nums1[i] - nums1[j] >= 1`
+
+Return `true` if it is possible to construct such an array, otherwise return `false`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,4,7]
+
+**Output:** true
+
+**Explanation:**
+
+*   Set `nums2[0] = nums1[0] = 1`.
+*   Set `nums2[1] = nums1[1] - nums1[0] = 4 - 1 = 3`.
+*   Set `nums2[2] = nums1[2] = 7`.
+*   `nums2 = [1, 3, 7]`, and all elements are odd. Thus, the answer is `true`.
+
+**Example 2:**
+
+**Input:** nums1 = [2,3]
+
+**Output:** false
+
+**Explanation:**
+
+It is not possible to construct `nums2` such that all elements have the same parity. Thus, the answer is `false`.
+
+**Example 3:**
+
+**Input:** nums1 = [4,6]
+
+**Output:** true
+
+**Explanation:**
+
+*   Set `nums2[0] = nums1[0] = 4`.
+*   Set `nums2[1] = nums1[1] = 6`.
+*   `nums2 = [4, 6]`, and all elements are even. Thus, the answer is `true`.
+
+**Constraints:**
+
+*   <code>1 <= n == nums1.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i] <= 10<sup>9</sup></code>
+*   `nums1` consists of distinct integers.

src/main/java/g3801_3900/s3877_minimum_removals_to_achieve_target_xor/Solution.java

@@ -0,0 +1,29 @@
+package g3801_3900.s3877_minimum_removals_to_achieve_target_xor;
+
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation #Staff #Weekly_Contest_494
+// #2026_08_13_Time_10_ms_(100.00%)_Space_48.52_MB_(75.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int minRemovals(int[] nums, int target) {
+        int max = 0;
+        for (int n : nums) {
+            max = Math.max(max, n);
+        }
+        int u = 1 << (32 - Integer.numberOfLeadingZeros(max));
+        if (target >= u) {
+            return -1;
+        }
+        int n = nums.length;
+        int[][] f = new int[n + 1][u];
+        Arrays.fill(f[0], Integer.MAX_VALUE / 2);
+        f[0][0] = 0;
+        for (int i = 0; i < n; i++) {
+            for (int x = 0; x < u; x++) {
+                f[i + 1][x] = Math.min(f[i][x] + 1, f[i][x ^ nums[i]]);
+            }
+        }
+        return f[n][target] == Integer.MAX_VALUE / 2 ? -1 : f[n][target];
+    }
+}

src/main/java/g3801_3900/s3877_minimum_removals_to_achieve_target_xor/readme.md

@@ -0,0 +1,49 @@
+3877\. Minimum Removals to Achieve Target XOR
+
+Medium
+
+You are given an integer array `nums` and an integer `target`.
+
+You may remove **any** number of elements from `nums` (possibly zero).
+
+Return the **minimum** number of removals required so that the **bitwise XOR** of the remaining elements equals `target`. If it is impossible to achieve `target`, return -1.
+
+The bitwise XOR of an empty array is 0.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], target = 2
+
+**Output:** 1
+
+**Explanation:**
+
+*   Removing `nums[1] = 2` leaves `[nums[0], nums[2]] = [1, 3]`.
+*   The XOR of `[1, 3]` is 2, which equals `target`.
+*   It is not possible to achieve XOR = 2 in less than one removal, therefore the answer is 1.
+
+**Example 2:**
+
+**Input:** nums = [2,4], target = 1
+
+**Output:** \-1
+
+**Explanation:**
+
+It is impossible to remove elements to achieve `target`. Thus, the answer is -1.
+
+**Example 3:**
+
+**Input:** nums = [7], target = 7
+
+**Output:** 0
+
+**Explanation:**
+
+The XOR of all elements is `nums[0] = 7`, which equals `target`. Thus, no removal is needed.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 40`
+*   <code>0 <= nums[i] <= 10<sup>4</sup></code>
+*   <code>0 <= target <= 10<sup>4</sup></code>

src/main/java/g3801_3900/s3878_count_good_subarrays/Solution.java

@@ -0,0 +1,25 @@
+package g3801_3900.s3878_count_good_subarrays;
+
+// #Hard #Array #Bit_Manipulation #Stack #Monotonic_Stack #Senior_Staff #Weekly_Contest_494
+// #2026_08_13_Time_6_ms_(100.00%)_Space_105.66_MB_(98.88%)
+
+public class Solution {
+    public long countGoodSubarrays(int[] nums) {
+        int n = nums.length;
+        long ans = 0;
+        int[] prev = new int[n];
+        for (int i = 0; i < n; i++) {
+            int left = i - 1;
+            while (left >= 0 && (nums[left] | nums[i]) == nums[i]) {
+                left = prev[left];
+            }
+            prev[i] = left;
+            int right = i + 1;
+            while (right < n && nums[right] != nums[i] && (nums[right] | nums[i]) == nums[i]) {
+                right++;
+            }
+            ans += (long) (i - left) * (right - i);
+        }
+        return ans;
+    }
+}

src/main/java/g3801_3900/s3878_count_good_subarrays/readme.md

@@ -0,0 +1,49 @@
+3878\. Count Good Subarrays
+
+Hard
+
+You are given an integer array `nums`.
+
+A **non-empty subarrays** is called **good** if the **bitwise OR** of all its elements is equal to **at least one** element present in that subarray.
+
+Return the number of good subarrays in `nums`.
+
+Here, the bitwise OR of two integers `a` and `b` is denoted by `a | b`.
+
+**Example 1:**
+
+**Input:** nums = [4,2,3]
+
+**Output:** 4
+
+**Explanation:**
+
+The subarrays of `nums` are:
+
+| Subarray    | Bitwise OR        | Present in Subarray |
+| ----------- | ----------------- | ------------------- |
+| `[4]`       | `4 = 4`           | Yes                 |
+| `[2]`       | `2 = 2`           | Yes                 |
+| `[3]`       | `3 = 3`           | Yes                 |
+| `[4, 2]`    | `4 \| 2 = 6`      | No                  |
+| `[2, 3]`    | `2 \| 3 = 3`      | Yes                 |
+| `[4, 2, 3]` | `4 \| 2 \| 3 = 7` | No                  |
+
+Thus, the good subarrays of `nums` are `[4]`, `[2]`, `[3]` and `[2, 3]`. Thus, the answer is 4.
+
+**Example 2:**
+
+**Input:** nums = [1,3,1]
+
+**Output:** 6
+
+**Explanation:**
+
+Any subarray of `nums` containing 3 has bitwise OR equal to 3, and subarrays containing only 1 have bitwise OR equal to 1.
+
+In both cases, the result is present in the subarray, so all subarrays are good, and the answer is 6.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g3801_3900/s3880_minimum_absolute_difference_between_two_values/Solution.java

@@ -0,0 +1,39 @@
+package g3801_3900.s3880_minimum_absolute_difference_between_two_values;
+
+// #Easy #Array #Enumeration #Mid_Level #Biweekly_Contest_179
+// #2026_08_13_Time_1_ms_(99.36%)_Space_46.20_MB_(85.90%)
+
+public class Solution {
+    public int minAbsoluteDifference(int[] nums) {
+        int min = Integer.MAX_VALUE;
+        int n = nums.length;
+        int prev = -1;
+        int last = -1;
+        for (int i = 0; i < n; i++) {
+            if (prev == -1) {
+                if (nums[i] == 1) {
+                    prev = 1;
+                    last = i;
+                } else if (nums[i] == 2) {
+                    prev = 2;
+                    last = i;
+                }
+            } else {
+                if (nums[i] == 1) {
+                    if (prev == 2) {
+                        min = Math.min(min, i - last);
+                        prev = 1;
+                    }
+                    last = i;
+                } else if (nums[i] == 2) {
+                    if (prev == 1) {
+                        min = Math.min(min, i - last);
+                        prev = 2;
+                    }
+                    last = i;
+                }
+            }
+        }
+        return min != Integer.MAX_VALUE ? min : -1;
+    }
+}

src/main/java/g3801_3900/s3880_minimum_absolute_difference_between_two_values/readme.md

@@ -0,0 +1,41 @@
+3880\. Minimum Absolute Difference Between Two Values
+
+Easy
+
+You are given an integer array `nums` consisting only of 0, 1, and 2.
+
+A pair of indices `(i, j)` is called **valid** if `nums[i] == 1` and `nums[j] == 2`.
+
+Return the **minimum** absolute difference between `i` and `j` among all valid pairs. If no valid pair exists, return -1.
+
+The absolute difference between indices `i` and `j` is defined as `abs(i - j)`.
+
+**Example 1:**
+
+**Input:** nums = [1,0,0,2,0,1]
+
+**Output:** 2
+
+**Explanation:**
+
+The valid pairs are:
+
+*   (0, 3) which has absolute difference of `abs(0 - 3) = 3`.
+*   (5, 3) which has absolute difference of `abs(5 - 3) = 2`.
+
+Thus, the answer is 2.
+
+**Example 2:**
+
+**Input:** nums = [1,0,1,0]
+
+**Output:** \-1
+
+**Explanation:**
+
+There are no valid pairs in the array, thus the answer is -1.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 2`

src/main/java/g3801_3900/s3881_direction_assignments_with_exactly_k_visible_people/Solution.java

@@ -0,0 +1,39 @@
+package g3801_3900.s3881_direction_assignments_with_exactly_k_visible_people;
+
+// #Medium #Math #Combinatorics #Staff #Biweekly_Contest_179
+// #2026_08_13_Time_4_ms_(100.00%)_Space_42.91_MB_(67.27%)
+
+@SuppressWarnings("java:S1172")
+public class Solution {
+    private static final long MOD = 1_000_000_007L;
+
+    public int countVisiblePeople(int n, int pos, int k) {
+        int total = n - 1;
+        long combinations = nCr(total, k);
+        return (int) (2L * combinations % MOD);
+    }
+
+    private long nCr(int n, int r) {
+        r = Math.min(r, n - r);
+        long numerator = 1;
+        long denominator = 1;
+        for (int i = 1; i <= r; i++) {
+            numerator = numerator * (n - r + i) % MOD;
+            denominator = denominator * i % MOD;
+        }
+        return numerator * modPow(denominator, MOD - 2) % MOD;
+    }
+
+    private long modPow(long base, long exponent) {
+        long result = 1;
+        while (exponent > 0) {
+            if ((exponent & 1) == 1) {
+                result = result * base % MOD;
+            }
+
+            base = base * base % MOD;
+            exponent >>= 1;
+        }
+        return result;
+    }
+}