Added tasks 2182, 2183.

Author: javadev

README.md

@@ -1377,6 +1377,8 @@ implementation 'com.github.javadev:leetcode-in-java:1.10'
 | 2190 |[Most Frequent Number Following Key In an Array](src/main/java/g2101_2200/s2190_most_frequent_number_following_key_in_an_array/Solution.java)| Easy | Array, Hash_Table, Counting | 1 | 100.00
 | 2188 |[Minimum Time to Finish the Race](src/main/java/g2101_2200/s2188_minimum_time_to_finish_the_race/Solution.java)| Hard | Array, Dynamic_Programming | 15 | 93.69
 | 2187 |[Minimum Time to Complete Trips](src/main/java/g2101_2200/s2187_minimum_time_to_complete_trips/Solution.java)| Medium | Array, Binary_Search | 187 | 95.03
+| 2183 |[Count Array Pairs Divisible by K](src/main/java/g2101_2200/s2183_count_array_pairs_divisible_by_k/Solution.java)| Hard | Array, Math, Number_Theory | 849 | 44.54
+| 2182 |[Construct String With Repeat Limit](src/main/java/g2101_2200/s2182_construct_string_with_repeat_limit/Solution.java)| Medium | String, Greedy, Heap_Priority_Queue, Counting | 26 | 96.11
 | 2181 |[Merge Nodes in Between Zeros](src/main/java/g2101_2200/s2181_merge_nodes_in_between_zeros/Solution.java)| Medium | Simulation, Linked_List | 6 | 96.26
 | 2177 |[Find Three Consecutive Integers That Sum to a Given Number](src/main/java/g2101_2200/s2177_find_three_consecutive_integers_that_sum_to_a_given_number/Solution.java)| Medium | Math, Simulation | 1 | 78.46
 | 2176 |[Count Equal and Divisible Pairs in an Array](src/main/java/g2101_2200/s2176_count_equal_and_divisible_pairs_in_an_array/Solution.java)| Easy | Array | 4 | 78.29

src/main/java/g2101_2200/s2182_construct_string_with_repeat_limit/Solution.java

@@ -0,0 +1,45 @@
+package g2101_2200.s2182_construct_string_with_repeat_limit;
+
+// #Medium #String #Greedy #Heap_Priority_Queue #Counting
+// #2022_06_07_Time_26_ms_(96.11%)_Space_63.6_MB_(62.78%)
+
+@SuppressWarnings("java:S135")
+public class Solution {
+    public String repeatLimitedString(String s, int repeatLimit) {
+        char[] result = new char[s.length()];
+        int[] freq = new int[128];
+        int index = 0;
+        for (char c : s.toCharArray()) {
+            freq[c]++;
+        }
+        char max = 'z';
+        char second = 'y';
+        while (true) {
+            while (max >= 'a' && freq[max] == 0) {
+                max--;
+            }
+            if (max < 'a') {
+                break;
+            }
+            second = (char) Math.min(max - 1, second);
+            int count = Math.min(freq[max], repeatLimit);
+            freq[max] -= count;
+            while (count-- > 0) {
+                result[index++] = max;
+            }
+            if (freq[max] == 0) {
+                max = second--;
+                continue;
+            }
+            while (second >= 'a' && freq[second] == 0) {
+                second--;
+            }
+            if (second < 'a') {
+                break;
+            }
+            result[index++] = second;
+            freq[second]--;
+        }
+        return new String(result, 0, index);
+    }
+}

src/main/java/g2101_2200/s2182_construct_string_with_repeat_limit/readme.md

@@ -0,0 +1,50 @@
+2182\. Construct String With Repeat Limit
+
+Medium
+
+You are given a string `s` and an integer `repeatLimit`. Construct a new string `repeatLimitedString` using the characters of `s` such that no letter appears **more than** `repeatLimit` times **in a row**. You do **not** have to use all characters from `s`.
+
+Return _the **lexicographically largest**_ `repeatLimitedString` _possible_.
+
+A string `a` is **lexicographically larger** than a string `b` if in the first position where `a` and `b` differ, string `a` has a letter that appears later in the alphabet than the corresponding letter in `b`. If the first `min(a.length, b.length)` characters do not differ, then the longer string is the lexicographically larger one.
+
+**Example 1:**
+
+**Input:** s = "cczazcc", repeatLimit = 3
+
+**Output:** "zzcccac"
+
+**Explanation:** We use all of the characters from s to construct the repeatLimitedString "zzcccac".
+
+The letter 'a' appears at most 1 time in a row.
+
+The letter 'c' appears at most 3 times in a row.
+
+The letter 'z' appears at most 2 times in a row.
+
+Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
+
+The string is the lexicographically largest repeatLimitedString possible so we return "zzcccac".
+
+Note that the string "zzcccca" is lexicographically larger but the letter 'c' appears more than 3 times in a row, so it is not a valid repeatLimitedString. 
+
+**Example 2:**
+
+**Input:** s = "aababab", repeatLimit = 2
+
+**Output:** "bbabaa"
+
+**Explanation:** We use only some of the characters from s to construct the repeatLimitedString "bbabaa".
+
+The letter 'a' appears at most 2 times in a row. The letter 'b' appears at most 2 times in a row.
+
+Hence, no letter appears more than repeatLimit times in a row and the string is a valid repeatLimitedString.
+
+The string is the lexicographically largest repeatLimitedString possible so we return "bbabaa".
+
+Note that the string "bbabaaa" is lexicographically larger but the letter 'a' appears more than 2 times in a row, so it is not a valid repeatLimitedString. 
+
+**Constraints:**
+
+*   <code>1 <= repeatLimit <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.

src/main/java/g2101_2200/s2183_count_array_pairs_divisible_by_k/Solution.java

@@ -0,0 +1,35 @@
+package g2101_2200.s2183_count_array_pairs_divisible_by_k;
+
+// #Hard #Array #Math #Number_Theory #2022_06_07_Time_849_ms_(44.54%)_Space_120.9_MB_(39.50%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+@SuppressWarnings("java:S2234")
+public class Solution {
+    public long countPairs(int[] nums, int k) {
+        long count = 0L;
+        Map<Integer, Long> map = new HashMap<>();
+        for (int num : nums) {
+            int gd = gcd(num, k);
+            int want = k / gd;
+            for (Map.Entry<Integer, Long> entry : map.entrySet()) {
+                if (entry.getKey() % want == 0) {
+                    count += entry.getValue();
+                }
+            }
+            map.put(gd, map.getOrDefault(gd, 0L) + 1L);
+        }
+        return count;
+    }
+
+    private int gcd(int a, int b) {
+        if (a > b) {
+            return gcd(b, a);
+        }
+        if (a == 0) {
+            return b;
+        }
+        return gcd(a, b % a);
+    }
+}

src/main/java/g2101_2200/s2183_count_array_pairs_divisible_by_k/readme.md

@@ -0,0 +1,37 @@
+2183\. Count Array Pairs Divisible by K
+
+Hard
+
+Given a **0-indexed** integer array `nums` of length `n` and an integer `k`, return _the **number of pairs**_ `(i, j)` _such that:_
+
+*   `0 <= i < j <= n - 1` _and_
+*   `nums[i] * nums[j]` _is divisible by_ `k`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5], k = 2
+
+**Output:** 7
+
+**Explanation:**
+
+The 7 pairs of indices whose corresponding products are divisible by 2 are
+
+(0, 1), (0, 3), (1, 2), (1, 3), (1, 4), (2, 3), and (3, 4).
+
+Their products are 2, 4, 6, 8, 10, 12, and 20 respectively.
+
+Other pairs such as (0, 2) and (2, 4) have products 3 and 15 respectively, which are not divisible by 2. 
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4], k = 5
+
+**Output:** 0
+
+**Explanation:** There does not exist any pair of indices whose corresponding product is divisible by 5. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], k <= 10<sup>5</sup></code>

src/test/java/g2101_2200/s2182_construct_string_with_repeat_limit/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2101_2200.s2182_construct_string_with_repeat_limit;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void repeatLimitedString() {
+        assertThat(new Solution().repeatLimitedString("cczazcc", 3), equalTo("zzcccac"));
+    }
+
+    @Test
+    void repeatLimitedString2() {
+        assertThat(new Solution().repeatLimitedString("aababab", 2), equalTo("bbabaa"));
+    }
+}

src/test/java/g2101_2200/s2183_count_array_pairs_divisible_by_k/SolutionTest.java

@@ -0,0 +1,18 @@
+package g2101_2200.s2183_count_array_pairs_divisible_by_k;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countPairs() {
+        assertThat(new Solution().countPairs(new int[] {1, 2, 3, 4, 5}, 2), equalTo(7L));
+    }
+
+    @Test
+    void countPairs2() {
+        assertThat(new Solution().countPairs(new int[] {1, 2, 3, 4}, 5), equalTo(0L));
+    }
+}