Added tasks 3158-3162

src/main/java/g3101_3200/s3158_find_the_xor_of_numbers_which_appear_twice/Solution.java

@@ -0,0 +1,17 @@
+package g3101_3200.s3158_find_the_xor_of_numbers_which_appear_twice;
+
+// #Easy #Array #Hash_Table #Bit_Manipulation #2024_05_30_Time_1_ms_(99.87%)_Space_42.3_MB_(99.40%)
+
+public class Solution {
+    public int duplicateNumbersXOR(int[] nums) {
+        boolean[] appeared = new boolean[51];
+        int res = 0;
+        for (int num : nums) {
+            if (appeared[num]) {
+                res ^= num;
+            }
+            appeared[num] = true;
+        }
+        return res;
+    }
+}

src/main/java/g3101_3200/s3158_find_the_xor_of_numbers_which_appear_twice/readme.md

@@ -0,0 +1,43 @@
+3158\. Find the XOR of Numbers Which Appear Twice
+
+Easy
+
+You are given an array `nums`, where each number in the array appears **either** once or twice.
+
+Return the bitwise `XOR` of all the numbers that appear twice in the array, or 0 if no number appears twice.
+
+**Example 1:**
+
+**Input:** nums = [1,2,1,3]
+
+**Output:** 1
+
+**Explanation:**
+
+The only number that appears twice in `nums` is 1.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 0
+
+**Explanation:**
+
+No number appears twice in `nums`.
+
+**Example 3:**
+
+**Input:** nums = [1,2,2,1]
+
+**Output:** 3
+
+**Explanation:**
+
+Numbers 1 and 2 appeared twice. `1 XOR 2 == 3`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 50`
+*   `1 <= nums[i] <= 50`
+*   Each number in `nums` appears either once or twice.

src/main/java/g3101_3200/s3159_find_occurrences_of_an_element_in_an_array/Solution.java

@@ -0,0 +1,22 @@
+package g3101_3200.s3159_find_occurrences_of_an_element_in_an_array;
+
+// #Medium #Array #Hash_Table #2024_05_30_Time_4_ms_(96.74%)_Space_64_MB_(69.94%)
+
+import java.util.ArrayList;
+
+public class Solution {
+    public int[] occurrencesOfElement(int[] nums, int[] queries, int x) {
+        ArrayList<Integer> a = new ArrayList<>();
+        for (int i = 0, l = nums.length; i < l; i++) {
+            if (nums[i] == x) {
+                a.add(i);
+            }
+        }
+        int l = queries.length;
+        int[] r = new int[l];
+        for (int i = 0; i < l; i++) {
+            r[i] = queries[i] > a.size() ? -1 : a.get(queries[i] - 1);
+        }
+        return r;
+    }
+}

src/main/java/g3101_3200/s3159_find_occurrences_of_an_element_in_an_array/readme.md

@@ -0,0 +1,38 @@
+3159\. Find Occurrences of an Element in an Array
+
+Medium
+
+You are given an integer array `nums`, an integer array `queries`, and an integer `x`.
+
+For each `queries[i]`, you need to find the index of the <code>queries[i]<sup>th</sup></code> occurrence of `x` in the `nums` array. If there are fewer than `queries[i]` occurrences of `x`, the answer should be -1 for that query.
+
+Return an integer array `answer` containing the answers to all queries.
+
+**Example 1:**
+
+**Input:** nums = [1,3,1,7], queries = [1,3,2,4], x = 1
+
+**Output:** [0,-1,2,-1]
+
+**Explanation:**
+
+*   For the 1<sup>st</sup> query, the first occurrence of 1 is at index 0.
+*   For the 2<sup>nd</sup> query, there are only two occurrences of 1 in `nums`, so the answer is -1.
+*   For the 3<sup>rd</sup> query, the second occurrence of 1 is at index 2.
+*   For the 4<sup>th</sup> query, there are only two occurrences of 1 in `nums`, so the answer is -1.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3], queries = [10], x = 5
+
+**Output:** [-1]
+
+**Explanation:**
+
+*   For the 1<sup>st</sup> query, 5 doesn't exist in `nums`, so the answer is -1.
+
+**Constraints:**
+
+*   <code>1 <= nums.length, queries.length <= 10<sup>5</sup></code>
+*   <code>1 <= queries[i] <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], x <= 10<sup>4</sup></code>

src/main/java/g3101_3200/s3160_find_the_number_of_distinct_colors_among_the_balls/Solution.java

@@ -0,0 +1,32 @@
+package g3101_3200.s3160_find_the_number_of_distinct_colors_among_the_balls;
+
+// #Medium #Array #Hash_Table #Simulation #2024_05_30_Time_36_ms_(98.82%)_Space_79.6_MB_(93.03%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+@SuppressWarnings("java:S1172")
+public class Solution {
+    public int[] queryResults(int ignoredLimit, int[][] queries) {
+        Map<Integer, Integer> ballToColor = new HashMap<>();
+        Map<Integer, Integer> colorToCnt = new HashMap<>();
+        int[] ret = new int[queries.length];
+        for (int i = 0; i < queries.length; i += 1) {
+            final int ball = queries[i][0];
+            final int color = queries[i][1];
+            if (ballToColor.containsKey(ball)) {
+                int oldColor = ballToColor.get(ball);
+                int oldColorCnt = colorToCnt.get(oldColor);
+                if (oldColorCnt >= 2) {
+                    colorToCnt.put(oldColor, oldColorCnt - 1);
+                } else {
+                    colorToCnt.remove(oldColor);
+                }
+            }
+            ballToColor.put(ball, color);
+            colorToCnt.put(color, colorToCnt.getOrDefault(color, 0) + 1);
+            ret[i] = colorToCnt.size();
+        }
+        return ret;
+    }
+}

src/main/java/g3101_3200/s3160_find_the_number_of_distinct_colors_among_the_balls/readme.md

@@ -0,0 +1,50 @@
+3160\. Find the Number of Distinct Colors Among the Balls
+
+Medium
+
+You are given an integer `limit` and a 2D array `queries` of size `n x 2`.
+
+There are `limit + 1` balls with **distinct** labels in the range `[0, limit]`. Initially, all balls are uncolored. For every query in `queries` that is of the form `[x, y]`, you mark ball `x` with the color `y`. After each query, you need to find the number of **distinct** colors among the balls.
+
+Return an array `result` of length `n`, where `result[i]` denotes the number of distinct colors _after_ <code>i<sup>th</sup></code> query.
+
+**Note** that when answering a query, lack of a color _will not_ be considered as a color.
+
+**Example 1:**
+
+**Input:** limit = 4, queries = [[1,4],[2,5],[1,3],[3,4]]
+
+**Output:** [1,2,2,3]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/04/17/ezgifcom-crop.gif)
+
+*   After query 0, ball 1 has color 4.
+*   After query 1, ball 1 has color 4, and ball 2 has color 5.
+*   After query 2, ball 1 has color 3, and ball 2 has color 5.
+*   After query 3, ball 1 has color 3, ball 2 has color 5, and ball 3 has color 4.
+
+**Example 2:**
+
+**Input:** limit = 4, queries = [[0,1],[1,2],[2,2],[3,4],[4,5]]
+
+**Output:** [1,2,2,3,4]
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/04/17/ezgifcom-crop2.gif)**
+
+*   After query 0, ball 0 has color 1.
+*   After query 1, ball 0 has color 1, and ball 1 has color 2.
+*   After query 2, ball 0 has color 1, and balls 1 and 2 have color 2.
+*   After query 3, ball 0 has color 1, balls 1 and 2 have color 2, and ball 3 has color 4.
+*   After query 4, ball 0 has color 1, balls 1 and 2 have color 2, ball 3 has color 4, and ball 4 has color 5.
+
+**Constraints:**
+
+*   <code>1 <= limit <= 10<sup>9</sup></code>
+*   <code>1 <= n == queries.length <= 10<sup>5</sup></code>
+*   `queries[i].length == 2`
+*   `0 <= queries[i][0] <= limit`
+*   <code>1 <= queries[i][1] <= 10<sup>9</sup></code>

src/main/java/g3101_3200/s3161_block_placement_queries/Solution.java

@@ -0,0 +1,107 @@
+package g3101_3200.s3161_block_placement_queries;
+
+// #Hard #Array #Binary_Search #Segment_Tree #Binary_Indexed_Tree
+// #2024_05_30_Time_137_ms_(99.38%)_Space_143.7_MB_(54.52%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private static class Seg {
+        private final int start;
+        private final int end;
+        private int min;
+        private int max;
+        private int len;
+        private boolean obstacle;
+        private Seg left;
+        private Seg right;
+
+        public static Seg init(int n) {
+            return new Seg(0, n);
+        }
+
+        private Seg(int start, int end) {
+            this.start = start;
+            this.end = end;
+            if (start >= end) {
+                return;
+            }
+            int mid = start + ((end - start) >> 1);
+            left = new Seg(start, mid);
+            right = new Seg(mid + 1, end);
+            refresh();
+        }
+
+        public void set(int i) {
+            if (i < start || i > end) {
+                return;
+            } else if (i == start && i == end) {
+                obstacle = true;
+                min = max = start;
+                return;
+            }
+            left.set(i);
+            right.set(i);
+            refresh();
+        }
+
+        private void refresh() {
+            if (left.obstacle) {
+                min = left.min;
+                if (right.obstacle) {
+                    max = right.max;
+                    len = Math.max(right.min - left.max, Math.max(left.len, right.len));
+                } else {
+                    max = left.max;
+                    len = Math.max(left.len, right.end - left.max);
+                }
+                obstacle = true;
+            } else if (right.obstacle) {
+                min = right.min;
+                max = right.max;
+                len = Math.max(right.len, right.min - left.start);
+                obstacle = true;
+            } else {
+                len = end - start;
+            }
+        }
+
+        public void max(int n, int[] t) {
+            if (end <= n) {
+                t[0] = Math.max(t[0], len);
+                if (obstacle) {
+                    t[1] = max;
+                }
+                return;
+            }
+            left.max(n, t);
+            if (!right.obstacle || right.min >= n) {
+                return;
+            }
+            t[0] = Math.max(t[0], right.min - t[1]);
+            right.max(n, t);
+        }
+    }
+
+    public List<Boolean> getResults(int[][] queries) {
+        int max = 0;
+        for (int[] i : queries) {
+            max = Math.max(max, i[1]);
+        }
+        Seg root = Seg.init(max);
+        root.set(0);
+
+        List<Boolean> res = new ArrayList<>(queries.length);
+        for (int[] i : queries) {
+            if (i[0] == 1) {
+                root.set(i[1]);
+            } else {
+                int[] t = new int[2];
+                root.max(i[1], t);
+                res.add(Math.max(t[0], i[1] - t[1]) >= i[2]);
+            }
+        }
+        return res;
+    }
+}

src/main/java/g3101_3200/s3161_block_placement_queries/readme.md

@@ -0,0 +1,46 @@
+3161\. Block Placement Queries
+
+Hard
+
+There exists an infinite number line, with its origin at 0 and extending towards the **positive** x-axis.
+
+You are given a 2D array `queries`, which contains two types of queries:
+
+1.  For a query of type 1, `queries[i] = [1, x]`. Build an obstacle at distance `x` from the origin. It is guaranteed that there is **no** obstacle at distance `x` when the query is asked.
+2.  For a query of type 2, `queries[i] = [2, x, sz]`. Check if it is possible to place a block of size `sz` _anywhere_ in the range `[0, x]` on the line, such that the block **entirely** lies in the range `[0, x]`. A block **cannot** be placed if it intersects with any obstacle, but it may touch it. Note that you do **not** actually place the block. Queries are separate.
+
+Return a boolean array `results`, where `results[i]` is `true` if you can place the block specified in the <code>i<sup>th</sup></code> query of type 2, and `false` otherwise.
+
+**Example 1:**
+
+**Input:** queries = [[1,2],[2,3,3],[2,3,1],[2,2,2]]
+
+**Output:** [false,true,true]
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/04/22/example0block.png)**
+
+For query 0, place an obstacle at `x = 2`. A block of size at most 2 can be placed before `x = 3`.
+
+**Example 2:**
+
+**Input:** queries = [[1,7],[2,7,6],[1,2],[2,7,5],[2,7,6]]
+
+**Output:** [true,true,false]
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/04/22/example1block.png)**
+
+*   Place an obstacle at `x = 7` for query 0. A block of size at most 7 can be placed before `x = 7`.
+*   Place an obstacle at `x = 2` for query 2. Now, a block of size at most 5 can be placed before `x = 7`, and a block of size at most 2 before `x = 2`.
+
+**Constraints:**
+
+*   <code>1 <= queries.length <= 15 * 10<sup>4</sup></code>
+*   `2 <= queries[i].length <= 3`
+*   `1 <= queries[i][0] <= 2`
+*   <code>1 <= x, sz <= min(5 * 10<sup>4</sup>, 3 * queries.length)</code>
+*   The input is generated such that for queries of type 1, no obstacle exists at distance `x` when the query is asked.
+*   The input is generated such that there is at least one query of type 2.

src/main/java/g3101_3200/s3162_find_the_number_of_good_pairs_i/Solution.java

@@ -0,0 +1,17 @@
+package g3101_3200.s3162_find_the_number_of_good_pairs_i;
+
+// #Easy #Array #Hash_Table #2024_05_30_Time_1_ms_(99.96%)_Space_42.1_MB_(99.36%)
+
+public class Solution {
+    public int numberOfPairs(int[] nums1, int[] nums2, int k) {
+        int c = 0;
+        for (int j : nums1) {
+            for (int value : nums2) {
+                if (j % (value * k) == 0) {
+                    c++;
+                }
+            }
+        }
+        return c;
+    }
+}