Added tasks 2206, 2207.

Author: AryamanMishra

src/main/java/g2201_2300/s2206_divide_array_into_equal_pairs/Solution.java

@@ -0,0 +1,19 @@
+package g2201_2300.s2206_divide_array_into_equal_pairs;
+
+// #Easy #Array #Hash_Table #Bit_Manipulation #Counting
+// #2022_06_11_Time_1_ms_(100.00%)_Space_42.2_MB_(94.00%)
+
+public class Solution {
+ public boolean divideArray(int[] nums) {
+ int[] freq = new int[501];
+ for (int i = 0; i < nums.length; i++) {
+ ++freq[nums[i]];
+ }
+ for (int f : freq) {
+ if (f % 2 != 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+}

src/main/java/g2201_2300/s2206_divide_array_into_equal_pairs/readme.md

@@ -0,0 +1,40 @@
+2206\. Divide Array Into Equal Pairs
+
+Easy
+
+You are given an integer array `nums` consisting of `2 * n` integers.
+
+You need to divide `nums` into `n` pairs such that:
+
+* Each element belongs to **exactly one** pair.
+* The elements present in a pair are **equal**.
+
+Return `true` _if nums can be divided into_ `n` _pairs, otherwise return_ `false`.
+
+**Example 1:**
+
+**Input:** nums = [3,2,3,2,2,2]
+
+**Output:** true
+
+**Explanation:** 
+
+There are 6 elements in nums, so they should be divided into 6 / 2 = 3 pairs. 
+
+If nums is divided into the pairs (2, 2), (3, 3), and (2, 2), it will satisfy all the conditions.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** false
+
+**Explanation:** 
+
+There is no way to divide nums into 4 / 2 = 2 pairs such that the pairs satisfy every condition.
+
+**Constraints:**
+
+* `nums.length == 2 * n`
+* `1 <= n <= 500`
+* `1 <= nums[i] <= 500`

src/main/java/g2201_2300/s2207_maximize_number_of_subsequences_in_a_string/Solution.java

@@ -0,0 +1,31 @@
+package g2201_2300.s2207_maximize_number_of_subsequences_in_a_string;
+
+// #Medium #String #Greedy #Prefix_Sum #2022_06_11_Time_8_ms_(100%)_Space_43.1_MB(81.70%)
+
+public class Solution {
+ public long maximumSubsequenceCount(String text, String pattern) {
+ char first = pattern.charAt(0);
+ char second = pattern.charAt(1);
+ if (first == second) {
+ long res = 0;
+ for (char c : text.toCharArray()) {
+ if (c == first) {
+ res++;
+ }
+ }
+ return (res * (res + 1)) / 2;
+ }
+ long res = 0;
+ int firstCount = 0;
+ int secondCount = 0;
+ for (char c : text.toCharArray()) {
+ if (c == first) {
+ firstCount++;
+ } else if (c == second) {
+ secondCount++;
+ res += firstCount;
+ }
+ }
+ return Math.max(res + secondCount, res + firstCount);
+ }
+}

src/main/java/g2201_2300/s2207_maximize_number_of_subsequences_in_a_string/readme.md

@@ -0,0 +1,43 @@
+2207\. Maximize Number of Subsequences in a String
+
+Medium
+
+You are given a **0-indexed** string `text` and another **0-indexed** string `pattern` of length `2`, both of which consist of only lowercase English letters.
+
+You can add **either** `pattern[0]` **or** `pattern[1]` anywhere in `text` **exactly once**. Note that the character can be added even at the beginning or at the end of `text`.
+
+Return _the **maximum** number of times_ `pattern` _can occur as a **subsequence** of the modified_ `text`.
+
+A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.
+
+**Example 1:**
+
+**Input:** text = "abdcdbc", pattern = "ac"
+
+**Output:** 4
+
+**Explanation:** 
+
+If we add pattern[0] = 'a' in between text[1] and text[2], we get "ab**a**dcdbc". Now, the number of times "ac" occurs as a subsequence is 4.
+
+Some other strings which have 4 subsequences "ac" after adding a character to text are "**a**abdcdbc" and "abd**a**cdbc". 
+
+However, strings such as "abdc**a**dbc", "abd**c**cdbc", and "abdcdbc**c**", although obtainable, have only 3 subsequences "ac" and are thus suboptimal. 
+
+It can be shown that it is not possible to get more than 4 subsequences "ac" by adding only one character. 
+
+**Example 2:**
+
+**Input:** text = "aabb", pattern = "ab"
+
+**Output:** 6
+
+**Explanation:** 
+
+Some of the strings which can be obtained from text and have 6 subsequences "ab" are "**a**aabb", "aa**a**bb", and "aab**b**b". 
+
+**Constraints:**
+
+* <code>1 <= text.length <= 10<sup>5</sup></code>
+* `pattern.length == 2`
+* `text` and `pattern` consist only of lowercase English letters.

src/test/java/g2201_2300/s2206_divide_array_into_equal_pairs/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2201_2300.s2206_divide_array_into_equal_pairs;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void divideArray() {
+ assertThat(new Solution().divideArray(new int[] {3, 2, 3, 2, 2, 2}), equalTo(true));
+ }
+
+ @Test
+ void divideArray2() {
+ assertThat(new Solution().divideArray(new int[] {1, 2, 3, 4}), equalTo(false));
+ }
+}

src/test/java/g2201_2300/s2207_maximize_number_of_subsequences_in_a_string/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2201_2300.s2207_maximize_number_of_subsequences_in_a_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void maximumSubsequenceCount() {
+ assertThat(new Solution().maximumSubsequenceCount("abdcdbc", "ac"), equalTo(4L));
+ }
+
+ @Test
+ void maximumSubsequenceCount2() {
+ assertThat(new Solution().maximumSubsequenceCount("aabb", "ab"), equalTo(6L));
+ }
+
+ @Test
+ void maximumSubsequenceCount3() {
+ assertThat(new Solution().maximumSubsequenceCount("abdcdbc", "aa"), equalTo(1L));
+ }
+}