Added tasks 2348, 2349, 2350.

Author: javadev

README.md

@@ -1848,6 +1848,9 @@ implementation 'com.github.javadev:leetcode-in-java:1.12'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2350 |[Shortest Impossible Sequence of Rolls](src/main/java/g2301_2400/s2350_shortest_impossible_sequence_of_rolls/Solution.java)| Hard | Array, Hash_Table, Greedy | 54 | 47.18
+| 2349 |[Design a Number Container System](src/main/java/g2301_2400/s2349_design_a_number_container_system/NumberContainers.java)| Medium | Hash_Table, Design, Heap_Priority_Queue, Ordered_Set | 208 | 54.57
+| 2348 |[Number of Zero-Filled Subarrays](src/main/java/g2301_2400/s2348_number_of_zero_filled_subarrays/Solution.java)| Medium | Array, Math | 3 | 99.90
 | 2347 |[Best Poker Hand](src/main/java/g2301_2400/s2347_best_poker_hand/Solution.java)| Easy | Array, Hash_Table, Counting | 1 | 76.92
 | 2344 |[Minimum Deletions to Make Array Divisible](src/main/java/g2301_2400/s2344_minimum_deletions_to_make_array_divisible/Solution.java)| Hard | Array, Math, Sorting, Heap_Priority_Queue, Number_Theory | 13 | 88.89
 | 2343 |[Query Kth Smallest Trimmed Number](src/main/java/g2301_2400/s2343_query_kth_smallest_trimmed_number/Solution.java)| Medium | Array, String, Divide_and_Conquer, Sorting, Heap_Priority_Queue, Radix_Sort, Quickselect | 52 | 75.00

src/main/java/g2301_2400/s2348_number_of_zero_filled_subarrays/Solution.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2348_number_of_zero_filled_subarrays;
+
+// #Medium #Array #Math #2022_07_30_Time_3_ms_(99.90%)_Space_59.8_MB_(95.67%)
+
+public class Solution {
+    public long zeroFilledSubarray(int[] nums) {
+        long cnt = 0L;
+        long local = 0L;
+        for (int n : nums) {
+            if (n == 0) {
+                cnt += ++local;
+            } else {
+                local = 0;
+            }
+        }
+        return cnt;
+    }
+}

src/main/java/g2301_2400/s2348_number_of_zero_filled_subarrays/readme.md

@@ -0,0 +1,50 @@
+2348\. Number of Zero-Filled Subarrays
+
+Medium
+
+Given an integer array `nums`, return _the number of **subarrays** filled with_ `0`.
+
+A **subarray** is a contiguous non-empty sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,3,0,0,2,0,0,4]
+
+**Output:** 6
+
+**Explanation:**
+
+There are 4 occurrences of [0] as a subarray.
+
+There are 2 occurrences of [0,0] as a subarray.
+
+There is no occurrence of a subarray with a size more than 2 filled with 0. Therefore, we return 6.
+
+**Example 2:**
+
+**Input:** nums = [0,0,0,2,0,0]
+
+**Output:** 9
+
+**Explanation:**
+
+There are 5 occurrences of [0] as a subarray.
+
+There are 3 occurrences of [0,0] as a subarray.
+
+There is 1 occurrence of [0,0,0] as a subarray.
+
+There is no occurrence of a subarray with a size more than 3 filled with 0. Therefore, we return 9. 
+
+**Example 3:**
+
+**Input:** nums = [2,10,2019]
+
+**Output:** 0
+
+**Explanation:** There is no subarray filled with 0. Therefore, we return 0. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2301_2400/s2349_design_a_number_container_system/NumberContainers.java

@@ -0,0 +1,42 @@
+package g2301_2400.s2349_design_a_number_container_system;
+
+// #Medium #Hash_Table #Design #Heap_Priority_Queue #Ordered_Set
+// #2022_07_30_Time_208_ms_(54.57%)_Space_166.7_MB_(43.08%)
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeSet;
+
+@SuppressWarnings("java:S1186")
+public class NumberContainers {
+    private Map<Integer, TreeSet<Integer>> indices = new HashMap<>();
+    private Map<Integer, Integer> vals = new HashMap<>();
+
+    public NumberContainers() {}
+
+    public void change(int index, int number) {
+        if (vals.containsKey(index)) {
+            int old = vals.get(index);
+            indices.get(old).remove(index);
+            if (indices.get(old).isEmpty()) {
+                indices.remove(old);
+            }
+        }
+        vals.put(index, number);
+        indices.computeIfAbsent(number, s -> new TreeSet<>()).add(index);
+    }
+
+    public int find(int number) {
+        if (indices.containsKey(number)) {
+            return indices.get(number).first();
+        }
+        return -1;
+    }
+}
+
+/*
+ * Your NumberContainers object will be instantiated and called as such:
+ * NumberContainers obj = new NumberContainers();
+ * obj.change(index,number);
+ * int param_2 = obj.find(number);
+ */

src/main/java/g2301_2400/s2349_design_a_number_container_system/readme.md

@@ -0,0 +1,41 @@
+2349\. Design a Number Container System
+
+Medium
+
+Design a number container system that can do the following:
+
+*   **Insert** or **Replace** a number at the given index in the system.
+*   **Return** the smallest index for the given number in the system.
+
+Implement the `NumberContainers` class:
+
+*   `NumberContainers()` Initializes the number container system.
+*   `void change(int index, int number)` Fills the container at `index` with the `number`. If there is already a number at that `index`, replace it.
+*   `int find(int number)` Returns the smallest index for the given `number`, or `-1` if there is no index that is filled by `number` in the system.
+
+**Example 1:**
+
+**Input**
+
+["NumberContainers", "find", "change", "change", "change", "change", "find", "change", "find"]
+
+[[], [10], [2, 10], [1, 10], [3, 10], [5, 10], [10], [1, 20], [10]]
+
+**Output:** [null, -1, null, null, null, null, 1, null, 2]
+
+**Explanation:**
+
+    NumberContainers nc = new NumberContainers();
+    nc.find(10); // There is no index that is filled with number 10. Therefore, we return -1.
+    nc.change(2, 10); // Your container at index 2 will be filled with number 10.
+    nc.change(1, 10); // Your container at index 1 will be filled with number 10.
+    nc.change(3, 10); // Your container at index 3 will be filled with number 10.
+    nc.change(5, 10); // Your container at index 5 will be filled with number 10.
+    nc.find(10); // Number 10 is at the indices 1, 2, 3, and 5. Since the smallest index that is filled with 10 is 1, we return 1.
+    nc.change(1, 20); // Your container at index 1 will be filled with number 20. Note that index 1 was filled with 10 and then replaced with 20.
+    nc.find(10); // Number 10 is at the indices 2, 3, and 5. The smallest index that is filled with 10 is 2. Therefore, we return 2. 
+
+**Constraints:**
+
+*   <code>1 <= index, number <= 10<sup>9</sup></code>
+*   At most <code>10<sup>5</sup></code> calls will be made **in total** to `change` and `find`.

src/main/java/g2301_2400/s2350_shortest_impossible_sequence_of_rolls/Solution.java

@@ -0,0 +1,21 @@
+package g2301_2400.s2350_shortest_impossible_sequence_of_rolls;
+
+// #Hard #Array #Hash_Table #Greedy #2022_07_30_Time_54_ms_(47.18%)_Space_105.9_MB_(51.39%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public int shortestSequence(int[] rolls, int k) {
+        int res = 1;
+        Set<Integer> set = new HashSet<>();
+        for (int roll : rolls) {
+            set.add(roll);
+            if (set.size() == k) {
+                res++;
+                set.clear();
+            }
+        }
+        return res;
+    }
+}

src/main/java/g2301_2400/s2350_shortest_impossible_sequence_of_rolls/readme.md

@@ -0,0 +1,51 @@
+2350\. Shortest Impossible Sequence of Rolls
+
+Hard
+
+You are given an integer array `rolls` of length `n` and an integer `k`. You roll a `k` sided dice numbered from `1` to `k`, `n` times, where the result of the <code>i<sup>th</sup></code> roll is `rolls[i]`.
+
+Return _the length of the **shortest** sequence of rolls that **cannot** be taken from_ `rolls`.
+
+A **sequence of rolls** of length `len` is the result of rolling a `k` sided dice `len` times.
+
+**Note** that the sequence taken does not have to be consecutive as long as it is in order.
+
+**Example 1:**
+
+**Input:** rolls = [4,2,1,2,3,3,2,4,1], k = 4
+
+**Output:** 3
+
+**Explanation:** Every sequence of rolls of length 1, [1], [2], [3], [4], can be taken from rolls.
+
+Every sequence of rolls of length 2, [1, 1], [1, 2], ..., [4, 4], can be taken from rolls.
+
+The sequence [1, 4, 2] cannot be taken from rolls, so we return 3.
+
+Note that there are other sequences that cannot be taken from rolls.
+
+**Example 2:**
+
+**Input:** rolls = [1,1,2,2], k = 2
+
+**Output:** 2
+
+**Explanation:** Every sequence of rolls of length 1, [1], [2], can be taken from rolls.
+
+The sequence [2, 1] cannot be taken from rolls, so we return 2.
+
+Note that there are other sequences that cannot be taken from rolls but [2, 1] is the shortest. 
+
+**Example 3:**
+
+**Input:** rolls = [1,1,3,2,2,2,3,3], k = 4
+
+**Output:** 1
+
+**Explanation:** The sequence [4] cannot be taken from rolls, so we return 1. Note that there are other sequences that cannot be taken from rolls but [4] is the shortest. 
+
+**Constraints:**
+
+*   `n == rolls.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= rolls[i] <= k <= 10<sup>5</sup></code>

src/test/java/g2301_2400/s2348_number_of_zero_filled_subarrays/SolutionTest.java

@@ -0,0 +1,24 @@
+package g2301_2400.s2348_number_of_zero_filled_subarrays;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void zeroFilledSubarray() {
+        assertThat(
+                new Solution().zeroFilledSubarray(new int[] {1, 3, 0, 0, 2, 0, 0, 4}), equalTo(6L));
+    }
+
+    @Test
+    void zeroFilledSubarray2() {
+        assertThat(new Solution().zeroFilledSubarray(new int[] {0, 0, 0, 2, 0, 0}), equalTo(9L));
+    }
+
+    @Test
+    void zeroFilledSubarray3() {
+        assertThat(new Solution().zeroFilledSubarray(new int[] {2, 10, 2019}), equalTo(0L));
+    }
+}

src/test/java/g2301_2400/s2349_design_a_number_container_system/NumberContainersTest.java

@@ -0,0 +1,32 @@
+package g2301_2400.s2349_design_a_number_container_system;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class NumberContainersTest {
+    @Test
+    void numberContainers() {
+        NumberContainers nc = new NumberContainers();
+        // There is no index that is filled with number 10. Therefore, we return -1.
+        assertThat(nc.find(10), equalTo(-1));
+        // Your container at index 2 will be filled with number 10.
+        nc.change(2, 10);
+        // Your container at index 1 will be filled with number 10.
+        nc.change(1, 10);
+        // Your container at index 3 will be filled with number 10.
+        nc.change(3, 10);
+        // Your container at index 5 will be filled with number 10.
+        nc.change(5, 10);
+        // Number 10 is at the indices 1, 2, 3, and 5. Since the smallest index that is filled with
+        // 10 is 1, we return 1.
+        assertThat(nc.find(10), equalTo(1));
+        // Your container at index 1 will be filled with number 20. Note that index 1 was filled
+        // with 10 and then replaced with 20.
+        nc.change(1, 20);
+        // Number 10 is at the indices 2, 3, and 5. The smallest index that is filled with 10 is 2.
+        // Therefore, we return 2.
+        assertThat(nc.find(10), equalTo(2));
+    }
+}

src/test/java/g2301_2400/s2350_shortest_impossible_sequence_of_rolls/SolutionTest.java

@@ -0,0 +1,26 @@
+package g2301_2400.s2350_shortest_impossible_sequence_of_rolls;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void shortestSequence() {
+        assertThat(
+                new Solution().shortestSequence(new int[] {4, 2, 1, 2, 3, 3, 2, 4, 1}, 4),
+                equalTo(3));
+    }
+
+    @Test
+    void shortestSequence2() {
+        assertThat(new Solution().shortestSequence(new int[] {1, 1, 2, 2}, 2), equalTo(2));
+    }
+
+    @Test
+    void shortestSequence3() {
+        assertThat(
+                new Solution().shortestSequence(new int[] {1, 1, 3, 2, 2, 2, 3, 3}, 4), equalTo(1));
+    }
+}