Added tasks 1984, 1985, 2001, 2002, 2003.

Author: ThanhNIT

src/main/java/g1901_2000/s1984_minimum_difference_between_highest_and_lowest_of_k_scores/Solution.java

@@ -0,0 +1,16 @@
+package g1901_2000.s1984_minimum_difference_between_highest_and_lowest_of_k_scores;
+
+// #Easy #Array #Sorting #Sliding_Window #2022_05_22_Time_10_ms_(7.97%)_Space_47_MB_(57.18%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int minimumDifference(int[] nums, int k) {
+        Arrays.sort(nums);
+        int minDiff = nums[nums.length - 1];
+        for (int i = 0; i <= nums.length - k; i++) {
+            minDiff = Math.min(minDiff, nums[i + k - 1] - nums[i]);
+        }
+        return minDiff;
+    }
+}

src/main/java/g1901_2000/s1984_minimum_difference_between_highest_and_lowest_of_k_scores/readme.md

@@ -0,0 +1,48 @@
+1984\. Minimum Difference Between Highest and Lowest of K Scores
+
+Easy
+
+You are given a **0-indexed** integer array `nums`, where `nums[i]` represents the score of the <code>i<sup>th</sup></code> student. You are also given an integer `k`.
+
+Pick the scores of any `k` students from the array so that the **difference** between the **highest** and the **lowest** of the `k` scores is **minimized**.
+
+Return _the **minimum** possible difference_.
+
+**Example 1:**
+
+**Input:** nums = [90], k = 1
+
+**Output:** 0
+
+**Explanation:** There is one way to pick score(s) of one student: 
+
+- [**90**]. The difference between the highest and lowest score is 90 - 90 = 0. 
+  
+The minimum possible difference is 0.
+
+**Example 2:**
+
+**Input:** nums = [9,4,1,7], k = 2
+
+**Output:** 2
+
+**Explanation:** There are six ways to pick score(s) of two students: 
+
+- [**9**,**4**,1,7]. The difference between the highest and lowest score is 9 - 4 = 5. 
+
+- [**9**,4,**1**,7]. The difference between the highest and lowest score is 9 - 1 = 8. 
+
+- [**9**,4,1,**7**]. The difference between the highest and lowest score is 9 - 7 = 2. 
+
+- [9,**4**,**1**,7]. The difference between the highest and lowest score is 4 - 1 = 3. 
+
+- [9,**4**,1,**7**]. The difference between the highest and lowest score is 7 - 4 = 3. 
+
+- [9,4,**1**,**7**]. The difference between the highest and lowest score is 7 - 1 = 6. 
+  
+The minimum possible difference is 2.
+
+**Constraints:**
+
+*   `1 <= k <= nums.length <= 1000`
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>

src/main/java/g1901_2000/s1985_find_the_kth_largest_integer_in_the_array/Solution.java

@@ -0,0 +1,29 @@
+package g1901_2000.s1985_find_the_kth_largest_integer_in_the_array;
+
+// #Medium #Array #String #Sorting #Heap_Priority_Queue #Divide_and_Conquer #Quickselect
+// #2022_05_22_Time_34_ms_(77.42%)_Space_65.7_MB_(20.14%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public String kthLargestNumber(String[] nums, int k) {
+        Arrays.sort(nums, (n1, n2) -> compareStringInt(n2, n1));
+        return nums[k - 1];
+    }
+
+    private int compareStringInt(String n1, String n2) {
+        if (n1.length() != n2.length()) {
+            return n1.length() < n2.length() ? -1 : 1;
+        }
+        for (int i = 0; i < n1.length(); i++) {
+            int n1Digit = n1.charAt(i) - '0';
+            int n2Digit = n2.charAt(i) - '0';
+            if (n1Digit > n2Digit) {
+                return 1;
+            } else if (n2Digit > n1Digit) {
+                return -1;
+            }
+        }
+        return 0;
+    }
+}

src/main/java/g1901_2000/s1985_find_the_kth_largest_integer_in_the_array/readme.md

@@ -0,0 +1,52 @@
+1985\. Find the Kth Largest Integer in the Array
+
+Medium
+
+You are given an array of strings `nums` and an integer `k`. Each string in `nums` represents an integer without leading zeros.
+
+Return _the string that represents the_ <code>k<sup>th</sup></code> _**largest integer** in_ `nums`.
+
+**Note**: Duplicate numbers should be counted distinctly. For example, if `nums` is `["1","2","2"]`, `"2"` is the first largest integer, `"2"` is the second-largest integer, and `"1"` is the third-largest integer.
+
+**Example 1:**
+
+**Input:** nums = ["3","6","7","10"], k = 4
+
+**Output:** "3"
+
+**Explanation:** 
+
+The numbers in nums sorted in non-decreasing order are ["3","6","7","10"]. 
+
+The 4<sup>th</sup> largest integer in nums is "3".
+
+**Example 2:**
+
+**Input:** nums = ["2","21","12","1"], k = 3
+
+**Output:** "2"
+
+**Explanation:** 
+
+The numbers in nums sorted in non-decreasing order are ["1","2","12","21"]. 
+
+The 3<sup>rd</sup> largest integer in nums is "2".
+
+**Example 3:**
+
+**Input:** nums = ["0","0"], k = 2
+
+**Output:** "0"
+
+**Explanation:** 
+
+The numbers in nums sorted in non-decreasing order are ["0","0"]. 
+
+The 2<sup>nd</sup> largest integer in nums is "0".
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 10<sup>4</sup></code>
+*   `1 <= nums[i].length <= 100`
+*   `nums[i]` consists of only digits.
+*   `nums[i]` will not have any leading zeros.

src/main/java/g2001_2100/s2001_number_of_pairs_of_interchangeable_rectangles/Solution.java

@@ -0,0 +1,46 @@
+package g2001_2100.s2001_number_of_pairs_of_interchangeable_rectangles;
+
+// #Medium #Array #Hash_Table #Math #Counting #Number_Theory
+// #2022_05_22_Time_34_ms_(99.02%)_Space_121.4_MB_(69.27%)
+
+import java.util.Arrays;
+
+public class Solution {
+    static long factorial(long n) {
+        long m = 0;
+
+        while (n > 0) {
+            m += n;
+            n = n - 1;
+        }
+
+        return m;
+    }
+
+    public long interchangeableRectangles(int[][] rec) {
+
+        double[] ratio = new double[rec.length];
+
+        for (int i = 0; i < rec.length; i++) {
+            ratio[i] = (double) rec[i][0] / rec[i][1];
+        }
+
+        Arrays.sort(ratio);
+
+        long res = 0;
+        int k = 0;
+
+        for (int j = 0; j < ratio.length - 1; j++) {
+            if (ratio[j] == ratio[j + 1]) {
+                k++;
+            }
+
+            if (ratio[j] != ratio[j + 1] || j + 2 == ratio.length) {
+                res += factorial(k);
+                k = 0;
+            }
+        }
+
+        return res;
+    }
+}

src/main/java/g2001_2100/s2001_number_of_pairs_of_interchangeable_rectangles/readme.md

@@ -0,0 +1,44 @@
+2001\. Number of Pairs of Interchangeable Rectangles
+
+Medium
+
+You are given `n` rectangles represented by a **0-indexed** 2D integer array `rectangles`, where <code>rectangles[i] = [width<sub>i</sub>, height<sub>i</sub>]</code> denotes the width and height of the <code>i<sup>th</sup></code> rectangle.
+
+Two rectangles `i` and `j` (`i < j`) are considered **interchangeable** if they have the **same** width-to-height ratio. More formally, two rectangles are **interchangeable** if <code>width<sub>i</sub>/height<sub>i</sub> == width<sub>j</sub>/height<sub>j</sub></code> (using decimal division, not integer division).
+
+Return _the **number** of pairs of **interchangeable** rectangles in_ `rectangles`.
+
+**Example 1:**
+
+**Input:** rectangles = [[4,8],[3,6],[10,20],[15,30]]
+
+**Output:** 6
+
+**Explanation:** The following are the interchangeable pairs of rectangles by index (0-indexed): 
+
+- Rectangle 0 with rectangle 1: 4/8 == 3/6. 
+
+- Rectangle 0 with rectangle 2: 4/8 == 10/20. 
+
+- Rectangle 0 with rectangle 3: 4/8 == 15/30. 
+
+- Rectangle 1 with rectangle 2: 3/6 == 10/20. 
+
+- Rectangle 1 with rectangle 3: 3/6 == 15/30. 
+
+- Rectangle 2 with rectangle 3: 10/20 == 15/30.
+
+**Example 2:**
+
+**Input:** rectangles = [[4,5],[7,8]]
+
+**Output:** 0
+
+**Explanation:** There are no interchangeable pairs of rectangles.
+
+**Constraints:**
+
+*   `n == rectangles.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `rectangles[i].length == 2`
+*   <code>1 <= width<sub>i</sub>, height<sub>i</sub> <= 10<sup>5</sup></code>

src/main/java/g2001_2100/s2002_maximum_product_of_the_length_of_two_palindromic_subsequences/Solution.java

@@ -0,0 +1,94 @@
+package g2001_2100.s2002_maximum_product_of_the_length_of_two_palindromic_subsequences;
+
+// #Medium #String #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask
+// #2022_05_22_Time_69_ms_(89.94%)_Space_53.8_MB_(41.42%)
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Solution {
+    public int maxProduct(String s) {
+        if (s.length() == 2) {
+            return 1;
+        }
+        List<State> list = new ArrayList<>();
+        char[] chars = s.toCharArray();
+        Set<State> visited = new HashSet<>();
+        for (int i = 0; i < chars.length; ++i) {
+            int mask = 1 << i;
+            recur(chars, new State(i, i, 0, mask), list, visited);
+            recur(chars, new State(i, i + 1, 0, mask), list, visited);
+        }
+        list.sort((a, b) -> b.cnt - a.cnt);
+        int res = 1;
+        Set<Integer> explored = new HashSet<>();
+        for (int i = 0; i < list.size() - 1; ++i) {
+            if (explored.contains(i)) {
+                continue;
+            }
+            State cur = list.get(i);
+            if (cur.cnt == 1) {
+                break;
+            }
+
+            for (int j = i + 1; j < list.size(); ++j) {
+                State cand = list.get(j);
+                if ((cur.mask & cand.mask) < 1) {
+                    if (explored.add(j)) {
+                        res = Math.max(res, cur.cnt * cand.cnt);
+                    }
+                    break;
+                }
+            }
+        }
+        return res;
+    }
+
+    private void recur(char[] chars, State s, List<State> list, Set<State> visited) {
+        if (s.i < 0 || s.j >= chars.length) {
+            return;
+        }
+        if (!visited.add(s)) {
+            return;
+        }
+
+        if (chars[s.i] == chars[s.j]) {
+            int m = s.mask | (1 << s.i) | (1 << s.j);
+            int nextCnt = s.cnt + (s.i < s.j ? 2 : 1);
+            list.add(new State(s.i, s.j, nextCnt, m));
+            recur(chars, new State(s.i - 1, s.j + 1, nextCnt, m), list, visited);
+        }
+        recur(chars, new State(s.i - 1, s.j, s.cnt, s.mask), list, visited);
+        recur(chars, new State(s.i, s.j + 1, s.cnt, s.mask), list, visited);
+    }
+
+    private static class State {
+        int i;
+        int j;
+        int cnt;
+        int mask;
+
+        public State(int i, int j, int cnt, int mask) {
+            this.i = i;
+            this.j = j;
+            this.cnt = cnt;
+            this.mask = mask;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || o.getClass() != this.getClass()) {
+                return false;
+            }
+            State s = (State) o;
+            return this.i == s.i && this.j == s.j && this.mask == s.mask;
+        }
+
+        @Override
+        public int hashCode() {
+            return (this.i * 31 + this.j) * 31 + this.mask;
+        }
+    }
+}

src/main/java/g2001_2100/s2002_maximum_product_of_the_length_of_two_palindromic_subsequences/readme.md

@@ -0,0 +1,44 @@
+2001\. Number of Pairs of Interchangeable Rectangles
+
+Medium
+
+You are given `n` rectangles represented by a **0-indexed** 2D integer array `rectangles`, where <code>rectangles[i] = [width<sub>i</sub>, height<sub>i</sub>]</code> denotes the width and height of the <code>i<sup>th</sup></code> rectangle.
+
+Two rectangles `i` and `j` (`i < j`) are considered **interchangeable** if they have the **same** width-to-height ratio. More formally, two rectangles are **interchangeable** if <code>width<sub>i</sub>/height<sub>i</sub> == width<sub>j</sub>/height<sub>j</sub></code> (using decimal division, not integer division).
+
+Return _the **number** of pairs of **interchangeable** rectangles in_ `rectangles`.
+
+**Example 1:**
+
+**Input:** rectangles = [[4,8],[3,6],[10,20],[15,30]]
+
+**Output:** 6
+
+**Explanation:** The following are the interchangeable pairs of rectangles by index (0-indexed): 
+
+- Rectangle 0 with rectangle 1: 4/8 == 3/6. 
+
+- Rectangle 0 with rectangle 2: 4/8 == 10/20. 
+
+- Rectangle 0 with rectangle 3: 4/8 == 15/30. 
+
+- Rectangle 1 with rectangle 2: 3/6 == 10/20. 
+
+- Rectangle 1 with rectangle 3: 3/6 == 15/30. 
+
+- Rectangle 2 with rectangle 3: 10/20 == 15/30.
+
+**Example 2:**
+
+**Input:** rectangles = [[4,5],[7,8]]
+
+**Output:** 0
+
+**Explanation:** There are no interchangeable pairs of rectangles.
+
+**Constraints:**
+
+*   `n == rectangles.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `rectangles[i].length == 2`
+*   <code>1 <= width<sub>i</sub>, height<sub>i</sub> <= 10<sup>5</sup></code>