Added tasks 2354, 2357.

Author: javadev

README.md

@@ -1848,6 +1848,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.12'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2357 |[Make Array Zero by Subtracting Equal Amounts](src/main/java/g2301_2400/s2357_make_array_zero_by_subtracting_equal_amounts/Solution.java)| Easy | Array, Hash_Table, Sorting, Heap_Priority_Queue, Simulation | 1 | 98.24
+| 2354 |[Number of Excellent Pairs](src/main/java/g2301_2400/s2354_number_of_excellent_pairs/Solution.java)| Hard | Array, Hash_Table, Binary_Search, Bit_Manipulation | 80 | 86.77
 | 2353 |[Design a Food Rating System](src/main/java/g2301_2400/s2353_design_a_food_rating_system/FoodRatings.java)| Medium | Hash_Table, Design, Heap_Priority_Queue, Ordered_Set | 364 | 83.35
 | 2352 |[Equal Row and Column Pairs](src/main/java/g2301_2400/s2352_equal_row_and_column_pairs/Solution.java)| Medium | Array, Hash_Table, Matrix, Simulation | 7 | 98.94
 | 2351 |[First Letter to Appear Twice](src/main/java/g2301_2400/s2351_first_letter_to_appear_twice/Solution.java)| Easy | Hash_Table, String, Counting | 1 | 63.38

src/main/java/g2301_2400/s2354_number_of_excellent_pairs/Solution.java

@@ -0,0 +1,29 @@
+package g2301_2400.s2354_number_of_excellent_pairs;
+
+// #Hard #Array #Hash_Table #Binary_Search #Bit_Manipulation
+// #2022_08_07_Time_80_ms_(86.77%)_Space_109.2_MB_(29.50%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public long countExcellentPairs(int[] nums, int k) {
+        long[] cnt = new long[30];
+        long res = 0L;
+        Set<Integer> set = new HashSet<>();
+        for (int a : nums) {
+            set.add(a);
+        }
+        for (int a : set) {
+            cnt[Integer.bitCount(a)]++;
+        }
+        for (int i = 1; i < 30; ++i) {
+            for (int j = 1; j < 30; ++j) {
+                if (i + j >= k) {
+                    res += cnt[i] * cnt[j];
+                }
+            }
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,46 @@
+2354\. Number of Excellent Pairs
+
+Hard
+
+You are given a **0-indexed** positive integer array `nums` and a positive integer `k`.
+
+A pair of numbers `(num1, num2)` is called **excellent** if the following conditions are satisfied:
+
+*   **Both** the numbers `num1` and `num2` exist in the array `nums`.
+*   The sum of the number of set bits in `num1 OR num2` and `num1 AND num2` is greater than or equal to `k`, where `OR` is the bitwise **OR** operation and `AND` is the bitwise **AND** operation.
+
+Return _the number of **distinct** excellent pairs_.
+
+Two pairs `(a, b)` and `(c, d)` are considered distinct if either `a != c` or `b != d`. For example, `(1, 2)` and `(2, 1)` are distinct.
+
+**Note** that a pair `(num1, num2)` such that `num1 == num2` can also be excellent if you have at least **one** occurrence of `num1` in the array.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,1], k = 3
+
+**Output:** 5
+
+**Explanation:** The excellent pairs are the following:
+
+- (3, 3). (3 AND 3) and (3 OR 3) are both equal to (11) in binary. The total number of set bits is 2 + 2 = 4, which is greater than or equal to k = 3.
+
+- (2, 3) and (3, 2). (2 AND 3) is equal to (10) in binary, and (2 OR 3) is equal to (11) in binary. The total number of set bits is 1 + 2 = 3.
+
+- (1, 3) and (3, 1). (1 AND 3) is equal to (01) in binary, and (1 OR 3) is equal to (11) in binary. The total number of set bits is 1 + 2 = 3.
+
+So the number of excellent pairs is 5.
+
+**Example 2:**
+
+**Input:** nums = [5,1,1], k = 10
+
+**Output:** 0
+
+**Explanation:** There are no excellent pairs for this array. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   `1 <= k <= 60`

src/main/java/g2301_2400/s2357_make_array_zero_by_subtracting_equal_amounts/Solution.java

@@ -0,0 +1,19 @@
+package g2301_2400.s2357_make_array_zero_by_subtracting_equal_amounts;
+
+// #Easy #Array #Hash_Table #Sorting #Heap_Priority_Queue #Simulation
+// #2022_08_07_Time_1_ms_(98.24%)_Space_41.9_MB_(50.08%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public int minimumOperations(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int a : nums) {
+            if (a > 0) {
+                set.add(a);
+            }
+        }
+        return set.size();
+    }
+}

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

@@ -0,0 +1,37 @@
+2357\. Make Array Zero by Subtracting Equal Amounts
+
+Easy
+
+You are given a non-negative integer array `nums`. In one operation, you must:
+
+*   Choose a positive integer `x` such that `x` is less than or equal to the **smallest non-zero** element in `nums`.
+*   Subtract `x` from every **positive** element in `nums`.
+
+Return _the **minimum** number of operations to make every element in_ `nums` _equal to_ `0`.
+
+**Example 1:**
+
+**Input:** nums = [1,5,0,3,5]
+
+**Output:** 3
+
+**Explanation:**
+
+In the first operation, choose x = 1. Now, nums = [0,4,0,2,4].
+
+In the second operation, choose x = 2. Now, nums = [0,2,0,0,2].
+
+In the third operation, choose x = 2. Now, nums = [0,0,0,0,0]. 
+
+**Example 2:**
+
+**Input:** nums = [0]
+
+**Output:** 0
+
+**Explanation:** Each element in nums is already 0 so no operations are needed. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 100`

src/test/java/g2301_2400/s2354_number_of_excellent_pairs/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2354_number_of_excellent_pairs;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countExcellentPairs() {
+        assertThat(new Solution().countExcellentPairs(new int[] {1, 2, 3, 1}, 3), equalTo(5L));
+    }
+
+    @Test
+    void countExcellentPairs2() {
+        assertThat(new Solution().countExcellentPairs(new int[] {5, 1, 1}, 10), equalTo(0L));
+    }
+}

src/test/java/g2301_2400/s2357_make_array_zero_by_subtracting_equal_amounts/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2357_make_array_zero_by_subtracting_equal_amounts;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minimumOperations() {
+        assertThat(new Solution().minimumOperations(new int[] {1, 5, 0, 3, 5}), equalTo(3));
+    }
+
+    @Test
+    void minimumOperations2() {
+        assertThat(new Solution().minimumOperations(new int[] {0}), equalTo(0));
+    }
+}