Added tasks 2341, 2342.

Author: javadev

README.md

@@ -1848,6 +1848,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.11'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2342 |[Max Sum of a Pair With Equal Sum of Digits](src/main/java/g2301_2400/s2342_max_sum_of_a_pair_with_equal_sum_of_digits/Solution.java)| Medium || 99 | 100.00
+| 2341 |[Maximum Number of Pairs in Array](src/main/java/g2301_2400/s2341_maximum_number_of_pairs_in_array/Solution.java)| Easy || 2 | 80.00
 | 2338 |[Count the Number of Ideal Arrays](src/main/java/g2301_2400/s2338_count_the_number_of_ideal_arrays/Solution.java)| Hard | Math, Dynamic_Programming, Combinatorics, Number_Theory | 21 | 99.04
 | 2337 |[Move Pieces to Obtain a String](src/main/java/g2301_2400/s2337_move_pieces_to_obtain_a_string/Solution.java)| Medium | Two_Pointers, String | 23 | 82.39
 | 2336 |[Smallest Number in Infinite Set](src/main/java/g2301_2400/s2336_smallest_number_in_infinite_set/SmallestInfiniteSet.java)| Medium | Hash_Table, Design, Heap_Priority_Queue | 12 | 96.69

src/main/java/g2301_2400/s2341_maximum_number_of_pairs_in_array/Solution.java

@@ -0,0 +1,20 @@
+package g2301_2400.s2341_maximum_number_of_pairs_in_array;
+
+// #Easy #2022_07_18_Time_2_ms_(80.00%)_Space_42.3_MB_(80.00%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[] numberOfPairs(int[] nums) {
+        Arrays.sort(nums);
+        int pairs = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                nums[i] = -1;
+                nums[i - 1] = -1;
+                pairs++;
+            }
+        }
+        return new int[] {pairs, nums.length - (2 * pairs)};
+    }
+}

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

@@ -0,0 +1,51 @@
+2341\. Maximum Number of Pairs in Array
+
+Easy
+
+You are given a **0-indexed** integer array `nums`. In one operation, you may do the following:
+
+*   Choose **two** integers in `nums` that are **equal**.
+*   Remove both integers from `nums`, forming a **pair**.
+
+The operation is done on `nums` as many times as possible.
+
+Return _a **0-indexed** integer array_ `answer` _of size_ `2` _where_ `answer[0]` _is the number of pairs that are formed and_ `answer[1]` _is the number of leftover integers in_ `nums` _after doing the operation as many times as possible_.
+
+**Example 1:**
+
+**Input:** nums = [1,3,2,1,3,2,2]
+
+**Output:** [3,1]
+
+**Explanation:**
+
+Form a pair with nums[0] and nums[3] and remove them from nums. Now, nums = [3,2,3,2,2].
+
+Form a pair with nums[0] and nums[2] and remove them from nums. Now, nums = [2,2,2].
+
+Form a pair with nums[0] and nums[1] and remove them from nums. Now, nums = [2].
+
+No more pairs can be formed. A total of 3 pairs have been formed, and there is 1 number leftover in nums.
+
+**Example 2:**
+
+**Input:** nums = [1,1]
+
+**Output:** [1,0]
+
+**Explanation:** Form a pair with nums[0] and nums[1] and remove them from nums. Now, nums = [].
+
+No more pairs can be formed. A total of 1 pair has been formed, and there are 0 numbers leftover in nums.
+
+**Example 3:**
+
+**Input:** nums = [0]
+
+**Output:** [0,1]
+
+**Explanation:** No pairs can be formed, and there is 1 number leftover in nums. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 100`

src/main/java/g2301_2400/s2342_max_sum_of_a_pair_with_equal_sum_of_digits/Solution.java

@@ -0,0 +1,26 @@
+package g2301_2400.s2342_max_sum_of_a_pair_with_equal_sum_of_digits;
+
+// #Medium #2022_07_18_Time_99_ms_(100.00%)_Space_121.2_MB_(100.00%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int maximumSum(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int res = -1;
+        for (int num : nums) {
+            int s = 0;
+            for (char digit : String.valueOf(num).toCharArray()) {
+                s += Integer.valueOf(digit - '0');
+            }
+            if (!map.containsKey(s)) {
+                map.put(s, num);
+            } else {
+                res = Math.max(res, map.get(s) + num);
+                map.put(s, Math.max(map.get(s), num));
+            }
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,34 @@
+2342\. Max Sum of a Pair With Equal Sum of Digits
+
+Medium
+
+You are given a **0-indexed** array `nums` consisting of **positive** integers. You can choose two indices `i` and `j`, such that `i != j`, and the sum of digits of the number `nums[i]` is equal to that of `nums[j]`.
+
+Return _the **maximum** value of_ `nums[i] + nums[j]` _that you can obtain over all possible indices_ `i` _and_ `j` _that satisfy the conditions._
+
+**Example 1:**
+
+**Input:** nums = [18,43,36,13,7]
+
+**Output:** 54
+
+**Explanation:** The pairs (i, j) that satisfy the conditions are:
+
+- (0, 2), both numbers have a sum of digits equal to 9, and their sum is 18 + 36 = 54.
+
+- (1, 4), both numbers have a sum of digits equal to 7, and their sum is 43 + 7 = 50.
+
+So the maximum sum that we can obtain is 54. 
+
+**Example 2:**
+
+**Input:** nums = [10,12,19,14]
+
+**Output:** -1
+
+**Explanation:** There are no two numbers that satisfy the conditions, so we return -1. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/test/java/g2301_2400/s2341_maximum_number_of_pairs_in_array/SolutionTest.java

@@ -0,0 +1,25 @@
+package g2301_2400.s2341_maximum_number_of_pairs_in_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numberOfPairs() {
+        assertThat(
+                new Solution().numberOfPairs(new int[] {1, 3, 2, 1, 3, 2, 2}),
+                equalTo(new int[] {3, 1}));
+    }
+
+    @Test
+    void numberOfPairs2() {
+        assertThat(new Solution().numberOfPairs(new int[] {1, 1}), equalTo(new int[] {1, 0}));
+    }
+
+    @Test
+    void numberOfPairs3() {
+        assertThat(new Solution().numberOfPairs(new int[] {0}), equalTo(new int[] {0, 1}));
+    }
+}

src/test/java/g2301_2400/s2342_max_sum_of_a_pair_with_equal_sum_of_digits/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2301_2400.s2342_max_sum_of_a_pair_with_equal_sum_of_digits;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maximumSum() {
+        assertThat(new Solution().maximumSum(new int[] {18, 43, 36, 13, 7}), equalTo(54));
+    }
+
+    @Test
+    void maximumSum2() {
+        assertThat(new Solution().maximumSum(new int[] {10, 12, 19, 14}), equalTo(-1));
+    }
+}