Added tasks 1863, 1864, 1865, 1866, 1869.

Author: ThanhNIT

src/main/java/g1801_1900/s1863_sum_of_all_subset_xor_totals/Solution.java

@@ -0,0 +1,39 @@
+package g1801_1900.s1863_sum_of_all_subset_xor_totals;
+
+// #Easy #Array #Math #Bit_Manipulation #Backtracking #Combinatorics
+// #2022_05_10_Time_22_ms_(11.36%)_Space_52.2_MB_(6.49%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+@SuppressWarnings("java:S5413")
+public class Solution {
+    public int subsetXORSum(int[] nums) {
+        int sum = 0;
+        List<List<Integer>> subsets = subsets(nums);
+        for (List<Integer> subset : subsets) {
+            int xor = 0;
+            for (int i : subset) {
+                xor ^= i;
+            }
+            sum += xor;
+        }
+        return sum;
+    }
+
+    private List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        backtracking(result, new ArrayList<>(), nums, 0);
+        return result;
+    }
+
+    private void backtracking(
+            List<List<Integer>> result, List<Integer> list, int[] nums, int start) {
+        result.add(new ArrayList<>(list));
+        for (int i = start; i < nums.length; i++) {
+            list.add(nums[i]);
+            backtracking(result, list, nums, i + 1);
+            list.remove(list.size() - 1);
+        }
+    }
+}

src/main/java/g1801_1900/s1863_sum_of_all_subset_xor_totals/readme.md

@@ -0,0 +1,70 @@
+1863\. Sum of All Subset XOR Totals
+
+Easy
+
+The **XOR total** of an array is defined as the bitwise `XOR` of **all its elements**, or `0` if the array is **empty**.
+
+*   For example, the **XOR total** of the array `[2,5,6]` is `2 XOR 5 XOR 6 = 1`.
+
+Given an array `nums`, return _the **sum** of all **XOR totals** for every **subset** of_ `nums`.
+
+**Note:** Subsets with the **same** elements should be counted **multiple** times.
+
+An array `a` is a **subset** of an array `b` if `a` can be obtained from `b` by deleting some (possibly zero) elements of `b`.
+
+**Example 1:**
+
+**Input:** nums = [1,3]
+
+**Output:** 6
+
+**Explanation:** The 4 subsets of [1,3] are: 
+
+- The empty subset has an XOR total of 0. 
+
+- [1] has an XOR total of 1. 
+
+- [3] has an XOR total of 3. 
+
+- [1,3] has an XOR total of 1 XOR 3 = 2. 
+  
+0 + 1 + 3 + 2 = 6
+
+**Example 2:**
+
+**Input:** nums = [5,1,6]
+
+**Output:** 28
+
+**Explanation:** The 8 subsets of [5,1,6] are: 
+
+- The empty subset has an XOR total of 0. 
+
+- [5] has an XOR total of 5.
+
+- [1] has an XOR total of 1. 
+
+- [6] has an XOR total of 6. 
+
+- [5,1] has an XOR total of 5 XOR 1 = 4. 
+
+- [5,6] has an XOR total of 5 XOR 6 = 3. 
+
+- [1,6] has an XOR total of 1 XOR 6 = 7. 
+
+- [5,1,6] has an XOR total of 5 XOR 1 XOR 6 = 2. 
+  
+0 + 5 + 1 + 6 + 4 + 3 + 7 + 2 = 28
+
+**Example 3:**
+
+**Input:** nums = [3,4,5,6,7,8]
+
+**Output:** 480
+
+**Explanation:** The sum of all XOR totals for every subset is 480.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 12`
+*   `1 <= nums[i] <= 20`

src/main/java/g1801_1900/s1864_minimum_number_of_swaps_to_make_the_binary_string_alternating/Solution.java

@@ -0,0 +1,31 @@
+package g1801_1900.s1864_minimum_number_of_swaps_to_make_the_binary_string_alternating;
+
+// #Medium #String #Greedy #2022_05_10_Time_3_ms_(43.20%)_Space_41.6_MB_(72.00%)
+
+public class Solution {
+    public int minSwaps(String s) {
+        int[][] count = new int[2][2];
+
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (i % 2 == 0) {
+                count[0][c - '0']++;
+            } else {
+                count[1][c - '0']++;
+            }
+        }
+
+        if ((count[0][0] == 0 && count[1][1] == 0) || (count[0][1] == 0 && count[1][0] == 0)) {
+            return 0;
+        }
+
+        if (count[0][0] != count[1][1] && count[0][1] != count[1][0]) {
+            return -1;
+        }
+
+        int ans1 = count[0][0] == count[1][1] ? count[0][0] : Integer.MAX_VALUE;
+        int ans2 = count[0][1] == count[1][0] ? count[0][1] : Integer.MAX_VALUE;
+
+        return Math.min(ans1, ans2);
+    }
+}

src/main/java/g1801_1900/s1864_minimum_number_of_swaps_to_make_the_binary_string_alternating/readme.md

@@ -0,0 +1,36 @@
+1864\. Minimum Number of Swaps to Make the Binary String Alternating
+
+Medium
+
+Given a binary string `s`, return _the **minimum** number of character swaps to make it **alternating**, or_ `-1` _if it is impossible._
+
+The string is called **alternating** if no two adjacent characters are equal. For example, the strings `"010"` and `"1010"` are alternating, while the string `"0100"` is not.
+
+Any two characters may be swapped, even if they are **not adjacent**.
+
+**Example 1:**
+
+**Input:** s = "111000"
+
+**Output:** 1
+
+**Explanation:** Swap positions 1 and 4: "111000" -> "101010" The string is now alternating.
+
+**Example 2:**
+
+**Input:** s = "010"
+
+**Output:** 0
+
+**Explanation:** The string is already alternating, no swaps are needed.
+
+**Example 3:**
+
+**Input:** s = "1110"
+
+**Output:** -1
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s[i]` is either `'0'` or `'1'`.

src/main/java/g1801_1900/s1865_finding_pairs_with_a_certain_sum/FindSumPairs.java

@@ -0,0 +1,36 @@
+package g1801_1900.s1865_finding_pairs_with_a_certain_sum;
+
+// #Medium #Array #Hash_Table #Design #2022_05_10_Time_195_ms_(83.97%)_Space_74.2_MB_(92.11%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FindSumPairs {
+
+    Map<Integer, Integer> numFreq = new HashMap<>();
+    int[] nums1;
+    int[] nums2;
+
+    public FindSumPairs(int[] nums1, int[] nums2) {
+        this.nums1 = nums1;
+        this.nums2 = nums2;
+        for (int num : nums2) {
+            numFreq.put(num, numFreq.getOrDefault(num, 0) + 1);
+        }
+    }
+
+    public void add(int index, int val) {
+        numFreq.put(nums2[index], numFreq.getOrDefault(nums2[index], 0) - 1);
+        nums2[index] += val;
+        numFreq.put(nums2[index], numFreq.getOrDefault(nums2[index], 0) + 1);
+    }
+
+    public int count(int tot) {
+        int res = 0;
+        for (int num : nums1) {
+            res += numFreq.getOrDefault(tot - num, 0);
+        }
+
+        return res;
+    }
+}

src/main/java/g1801_1900/s1865_finding_pairs_with_a_certain_sum/readme.md

@@ -0,0 +1,49 @@
+1865\. Finding Pairs With a Certain Sum
+
+Medium
+
+You are given two integer arrays `nums1` and `nums2`. You are tasked to implement a data structure that supports queries of two types:
+
+1.  **Add** a positive integer to an element of a given index in the array `nums2`.
+2.  **Count** the number of pairs `(i, j)` such that `nums1[i] + nums2[j]` equals a given value (`0 <= i < nums1.length` and `0 <= j < nums2.length`).
+
+Implement the `FindSumPairs` class:
+
+*   `FindSumPairs(int[] nums1, int[] nums2)` Initializes the `FindSumPairs` object with two integer arrays `nums1` and `nums2`.
+*   `void add(int index, int val)` Adds `val` to `nums2[index]`, i.e., apply `nums2[index] += val`.
+*   `int count(int tot)` Returns the number of pairs `(i, j)` such that `nums1[i] + nums2[j] == tot`.
+
+**Example 1:**
+
+**Input** ["FindSumPairs", "count", "add", "count", "count", "add", "add", "count"] [[[1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]], [7], [3, 2], [8], [4], [0, 1], [1, 1], [7]]
+
+**Output:** [null, 8, null, 2, 1, null, null, 11]
+
+**Explanation:** 
+
+FindSumPairs findSumPairs = new FindSumPairs([1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]); 
+
+findSumPairs.count(7); // return 8; pairs (2,2), (3,2), (4,2), (2,4), (3,4), (4,4) make 2 + 5 and pairs (5,1), (5,5) make 3 + 4 
+
+findSumPairs.add(3, 2); // now nums2 = [1,4,5,**4**`,5,4`] 
+
+findSumPairs.count(8); // return 2; pairs (5,2), (5,4) make 3 + 5 
+
+findSumPairs.count(4); // return 1; pair (5,0) makes 3 + 1 
+
+findSumPairs.add(0, 1); // now nums2 = [**`2`**,4,5,4`,5,4`] 
+
+findSumPairs.add(1, 1); // now nums2 = [`2`,**5**,5,4`,5,4`] 
+
+findSumPairs.count(7); // return 11; pairs (2,1), (2,2), (2,4), (3,1), (3,2), (3,4), (4,1), (4,2), (4,4) make 2 + 5 and pairs (5,3), (5,5) make 3 + 4
+
+**Constraints:**
+
+*   `1 <= nums1.length <= 1000`
+*   <code>1 <= nums2.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums1[i] <= 10<sup>9</sup></code>
+*   <code>1 <= nums2[i] <= 10<sup>5</sup></code>
+*   `0 <= index < nums2.length`
+*   <code>1 <= val <= 10<sup>5</sup></code>
+*   <code>1 <= tot <= 10<sup>9</sup></code>
+*   At most `1000` calls are made to `add` and `count` **each**.

src/main/java/g1801_1900/s1866_number_of_ways_to_rearrange_sticks_with_k_sticks_visible/Solution.java

@@ -0,0 +1,33 @@
+package g1801_1900.s1866_number_of_ways_to_rearrange_sticks_with_k_sticks_visible;
+
+// #Hard #Dynamic_Programming #Math #Combinatorics
+// #2022_05_10_Time_67_ms_(96.33%)_Space_55.1_MB_(80.73%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private static final int MOD = 1_000_000_007;
+
+    public int rearrangeSticks(int n, int k) {
+        if (k > n || k < 1) {
+            return 0;
+        }
+        if (k == n) {
+            return 1;
+        }
+
+        long[] dp = new long[k + 1];
+        Arrays.fill(dp, 1);
+
+        for (int i = 1; i + k <= n; i++) {
+            long[] dp2 = new long[k + 1];
+            for (int j = 1; j <= k; j++) {
+                dp2[j] = (dp2[j - 1] + (i + j - 1) * dp[j]) % MOD;
+            }
+
+            dp = dp2;
+        }
+
+        return (int) dp[k];
+    }
+}

src/main/java/g1801_1900/s1866_number_of_ways_to_rearrange_sticks_with_k_sticks_visible/readme.md

@@ -0,0 +1,38 @@
+1866\. Number of Ways to Rearrange Sticks With K Sticks Visible
+
+Hard
+
+There are `n` uniquely-sized sticks whose lengths are integers from `1` to `n`. You want to arrange the sticks such that **exactly** `k` sticks are **visible** from the left. A stick is **visible** from the left if there are no **longer** sticks to the **left** of it.
+
+*   For example, if the sticks are arranged `[1,3,2,5,4]`, then the sticks with lengths `1`, `3`, and `5` are visible from the left.
+
+Given `n` and `k`, return _the **number** of such arrangements_. Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 3, k = 2
+
+**Output:** 3
+
+**Explanation:** [1,3,2], [2,3,1], and [2,1,3] are the only arrangements such that exactly 2 sticks are visible. The visible sticks are underlined.
+
+**Example 2:**
+
+**Input:** n = 5, k = 5
+
+**Output:** 1
+
+**Explanation:** [1,2,3,4,5] is the only arrangement such that all 5 sticks are visible. The visible sticks are underlined.
+
+**Example 3:**
+
+**Input:** n = 20, k = 11
+
+**Output:** 647427950
+
+**Explanation:** There are 647427950 (mod 10<sup>9</sup> \+ 7) ways to rearrange the sticks such that exactly 11 sticks are visible.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`
+*   `1 <= k <= n`

src/main/java/g1801_1900/s1869_longer_contiguous_segments_of_ones_than_zeros/Solution.java

@@ -0,0 +1,28 @@
+package g1801_1900.s1869_longer_contiguous_segments_of_ones_than_zeros;
+
+// #Easy #String #2022_05_10_Time_1_ms_(88.10%)_Space_41.8_MB_(66.14%)
+
+public class Solution {
+    public boolean checkZeroOnes(String s) {
+        int zeroes = 0;
+        int ones = 0;
+        int i = 0;
+        while (i < s.length()) {
+            int start = i;
+            while (i < s.length() && s.charAt(i) == '0') {
+                i++;
+            }
+            if (i > start) {
+                zeroes = Math.max(zeroes, i - start);
+            }
+            start = i;
+            while (i < s.length() && s.charAt(i) == '1') {
+                i++;
+            }
+            if (i > start) {
+                ones = Math.max(ones, i - start);
+            }
+        }
+        return ones > zeroes;
+    }
+}