Added tasks 2176-2197.

Author: javadev

README.md

@@ -120,7 +120,7 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0075 |[Sort Colors](src/main/java/g0001_0100/s0075_sort_colors)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers | 1 | 33.23
-| 0056 |[Merge Intervals](src/main/java/g0001_0100/s0056_merge_intervals)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting | 22 | 12.57
+| 0056 |[Merge Intervals](src/main/java/g0001_0100/s0056_merge_intervals)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting | 7 | 97.44
 | 0706 |[Design HashMap](src/main/java/g0701_0800/s0706_design_hashmap)| Easy | Array, Hash_Table, Design, Linked_List, Hash_Function | 13 | 95.71
 
 #### Day 3 Array
@@ -1333,9 +1333,19 @@
 |------|----------------|-------------|-------------|----------|--------
 | 2246 |[Longest Path With Different Adjacent Characters](src/main/java/g2201_2300/s2246_longest_path_with_different_adjacent_characters)| Hard | Array, String, Depth_First_Search, Tree, Graph, Topological_Sort | 75 | 97.79
 | 2200 |[Find All K-Distant Indices in an Array](src/main/java/g2101_2200/s2200_find_all_k_distant_indices_in_an_array)| Easy | Array | 2 | 95.30
+| 2197 |[Replace Non-Coprime Numbers in Array](src/main/java/g2101_2200/s2197_replace_non_coprime_numbers_in_array)| Hard | Array, Math, Stack, Number_Theory | 60 | 85.52
+| 2196 |[Create Binary Tree From Descriptions](src/main/java/g2101_2200/s2196_create_binary_tree_from_descriptions)| Medium | Array, Hash_Table, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 85 | 76.70
+| 2195 |[Append K Integers With Minimal Sum](src/main/java/g2101_2200/s2195_append_k_integers_with_minimal_sum)| Medium | Array, Math, Sorting, Greedy | 19 | 96.88
+| 2194 |[Cells in a Range on an Excel Sheet](src/main/java/g2101_2200/s2194_cells_in_a_range_on_an_excel_sheet)| Easy | String | 1 | 99.92
 | 2193 |[Minimum Number of Moves to Make Palindrome](src/main/java/g2101_2200/s2193_minimum_number_of_moves_to_make_palindrome)| Hard | String, Greedy, Two_Pointers, Binary_Indexed_Tree | 8 | 98.76
+| 2192 |[All Ancestors of a Node in a Directed Acyclic Graph](src/main/java/g2101_2200/s2192_all_ancestors_of_a_node_in_a_directed_acyclic_graph)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 82 | 90.80
+| 2191 |[Sort the Jumbled Numbers](src/main/java/g2101_2200/s2191_sort_the_jumbled_numbers)| Medium | Array, Sorting | 117 | 96.53
+| 2190 |[Most Frequent Number Following Key In an Array](src/main/java/g2101_2200/s2190_most_frequent_number_following_key_in_an_array)| 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)| Hard | Array, Dynamic_Programming | 15 | 93.69
 | 2187 |[Minimum Time to Complete Trips](src/main/java/g2101_2200/s2187_minimum_time_to_complete_trips)| Medium | Array, Binary_Search | 187 | 95.03
 | 2181 |[Merge Nodes in Between Zeros](src/main/java/g2101_2200/s2181_merge_nodes_in_between_zeros)| 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)| 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)| Easy | Array | 4 | 78.29
 | 2172 |[Maximum AND Sum of Array](src/main/java/g2101_2200/s2172_maximum_and_sum_of_array)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Bitmask | 21 | 87.50
 | 2166 |[Design Bitset](src/main/java/g2101_2200/s2166_design_bitset)| Medium | Array, Hash_Table, Design | 81 | 73.38
 | 2165 |[Smallest Value of the Rearranged Number](src/main/java/g2101_2200/s2165_smallest_value_of_the_rearranged_number)| Medium | Math, Sorting | 1 | 100.00
@@ -2986,7 +2996,7 @@
 | 0059 |[Spiral Matrix II](src/main/java/g0001_0100/s0059_spiral_matrix_ii)| Medium | Array, Matrix, Simulation, Data_Structure_II_Day_3_Array | 0 | 100.00
 | 0058 |[Length of Last Word](src/main/java/g0001_0100/s0058_length_of_last_word)| Easy | String, Programming_Skills_II_Day_6 | 0 | 100.00
 | 0057 |[Insert Interval](src/main/java/g0001_0100/s0057_insert_interval)| Medium | Array | 1 | 99.15
-| 0056 |[Merge Intervals](src/main/java/g0001_0100/s0056_merge_intervals)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Data_Structure_II_Day_2_Array | 22 | 12.57
+| 0056 |[Merge Intervals](src/main/java/g0001_0100/s0056_merge_intervals)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Data_Structure_II_Day_2_Array | 7 | 97.44
 | 0055 |[Jump Game](src/main/java/g0001_0100/s0055_jump_game)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Greedy, Algorithm_II_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_4 | 2 | 87.28
 | 0054 |[Spiral Matrix](src/main/java/g0001_0100/s0054_spiral_matrix)| Medium | Top_Interview_Questions, Array, Matrix, Simulation, Programming_Skills_II_Day_8 | 0 | 100.00
 | 0053 |[Maximum Subarray](src/main/java/g0001_0100/s0053_maximum_subarray)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Divide_and_Conquer, Data_Structure_I_Day_1_Array, Dynamic_Programming_I_Day_5 | 1 | 100.00

src/main/java/g0001_0100/s0056_merge_intervals/readme.md

@@ -35,44 +35,19 @@ import java.util.List;
 
 public class Solution {
     public int[][] merge(int[][] intervals) {
-        // sorting
-        // so that we can perform the task linearly
-        Arrays.sort(
-                intervals,
-                (int[] a, int[] b) -> {
-                    if (a[0] == b[0]) {
-                        return Integer.compare(a[1], b[1]);
-                    }
-                    return Integer.compare(a[0], b[0]);
-                });
-
-        List<List<Integer>> list = new ArrayList<>();
-        int i = 0;
-        while (i < intervals.length) {
-            // storing start
-            int start = intervals[i][0];
-            int end = intervals[i][1];
-            i++;
-            while (i < intervals.length && intervals[i][0] <= end) {
-                // making sure range is not shrinking
-                if (intervals[i][1] > end) {
-                    end = intervals[i][1];
-                }
-                i++;
+        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
+        List<int[]> list = new ArrayList<>();
+        int[] current = intervals[0];
+        list.add(current);
+        for (int[] next : intervals) {
+            if (current[1] >= next[0]) {
+                current[1] = Math.max(current[1], next[1]);
+            } else {
+                current = next;
+                list.add(current);
             }
-            List<Integer> temp = new ArrayList<>();
-            temp.add(start);
-            temp.add(end);
-            list.add(temp);
-        }
-        int[][] arr = new int[list.size()][2];
-        i = 0;
-        for (List<Integer> l : list) {
-            arr[i][0] = l.get(0);
-            arr[i][1] = l.get(1);
-            i++;
         }
-        return arr;
+        return list.toArray(new int[list.size()][]);
     }
 }
 ```

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

@@ -0,0 +1,52 @@
+## 2176\. Count Equal and Divisible Pairs in an Array
+
+Easy
+
+Given a **0-indexed** integer array `nums` of length `n` and an integer `k`, return _the **number of pairs**_ `(i, j)` _where_ `0 <= i < j < n`, _such that_ `nums[i] == nums[j]` _and_ `(i * j)` _is divisible by_ `k`.
+
+**Example 1:**
+
+**Input:** nums = [3,1,2,2,2,1,3], k = 2
+
+**Output:** 4
+
+**Explanation:** There are 4 pairs that meet all the requirements: 
+
+- nums[0] == nums[6], and 0 \* 6 == 0, which is divisible by 2. 
+
+- nums[2] == nums[3], and 2 \* 3 == 6, which is divisible by 2. 
+
+- nums[2] == nums[4], and 2 \* 4 == 8, which is divisible by 2. 
+
+- nums[3] == nums[4], and 3 \* 4 == 12, which is divisible by 2. 
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4], k = 1
+
+**Output:** 0
+
+**Explanation:** Since no value in nums is repeated, there are no pairs (i,j) that meet all the requirements. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i], k <= 100`
+
+## Solution
+
+```java
+public class Solution {
+    public int countPairs(int[] nums, int k) {
+        int ans = 0;
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                if (nums[i] == nums[j] && (i * j) % k == 0) {
+                    ++ans;
+                }
+            }
+        }
+        return ans;
+    }
+}
+```

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

@@ -0,0 +1,40 @@
+## 2177\. Find Three Consecutive Integers That Sum to a Given Number
+
+Medium
+
+Given an integer `num`, return _three consecutive integers (as a sorted array)_ _that **sum** to_ `num`. If `num` cannot be expressed as the sum of three consecutive integers, return _an **empty** array._
+
+**Example 1:**
+
+**Input:** num = 33
+
+**Output:** [10,11,12]
+
+**Explanation:** 33 can be expressed as 10 + 11 + 12 = 33. 
+
+10, 11, 12 are 3 consecutive integers, so we return [10, 11, 12]. 
+
+**Example 2:**
+
+**Input:** num = 4
+
+**Output:** []
+
+**Explanation:** There is no way to express 4 as the sum of 3 consecutive integers. 
+
+**Constraints:**
+
+*   <code>0 <= num <= 10<sup>15</sup></code>
+
+## Solution
+
+```java
+public class Solution {
+    public long[] sumOfThree(long num) {
+        if (num % 3 == 0) {
+            return new long[] {num / 3 - 1, num / 3, num / 3 + 1};
+        }
+        return new long[0];
+    }
+}
+```

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

@@ -0,0 +1,116 @@
+## 2188\. Minimum Time to Finish the Race
+
+Hard
+
+You are given a **0-indexed** 2D integer array `tires` where <code>tires[i] = [f<sub>i</sub>, r<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> tire can finish its <code>x<sup>th</sup></code> successive lap in <code>f<sub>i</sub> * r<sub>i</sub><sup>(x-1)</sup></code> seconds.
+
+*   For example, if <code>f<sub>i</sub> = 3</code> and <code>r<sub>i</sub> = 2</code>, then the tire would finish its <code>1<sup>st</sup></code> lap in `3` seconds, its <code>2<sup>nd</sup></code> lap in `3 * 2 = 6` seconds, its <code>3<sup>rd</sup></code> lap in <code>3 * 2<sup>2</sup> = 12</code> seconds, etc.
+
+You are also given an integer `changeTime` and an integer `numLaps`.
+
+The race consists of `numLaps` laps and you may start the race with **any** tire. You have an **unlimited** supply of each tire and after every lap, you may **change** to any given tire (including the current tire type) if you wait `changeTime` seconds.
+
+Return _the **minimum** time to finish the race._
+
+**Example 1:**
+
+**Input:** tires = \[\[2,3],[3,4]], changeTime = 5, numLaps = 4
+
+**Output:** 21
+
+**Explanation:**
+
+Lap 1: Start with tire 0 and finish the lap in 2 seconds.
+
+Lap 2: Continue with tire 0 and finish the lap in 2 \* 3 = 6 seconds.
+
+Lap 3: Change tires to a new tire 0 for 5 seconds and then finish the lap in another 2 seconds.
+
+Lap 4: Continue with tire 0 and finish the lap in 2 \* 3 = 6 seconds.
+
+Total time = 2 + 6 + 5 + 2 + 6 = 21 seconds.
+
+The minimum time to complete the race is 21 seconds. 
+
+**Example 2:**
+
+**Input:** tires = \[\[1,10],[2,2],[3,4]], changeTime = 6, numLaps = 5
+
+**Output:** 25
+
+**Explanation:**
+
+Lap 1: Start with tire 1 and finish the lap in 2 seconds.
+
+Lap 2: Continue with tire 1 and finish the lap in 2 \* 2 = 4 seconds.
+
+Lap 3: Change tires to a new tire 1 for 6 seconds and then finish the lap in another 2 seconds.
+
+Lap 4: Continue with tire 1 and finish the lap in 2 \* 2 = 4 seconds.
+
+Lap 5: Change tires to tire 0 for 6 seconds then finish the lap in another 1 second.
+
+Total time = 2 + 4 + 6 + 2 + 4 + 6 + 1 = 25 seconds.
+
+The minimum time to complete the race is 25 seconds. 
+
+**Constraints:**
+
+*   <code>1 <= tires.length <= 10<sup>5</sup></code>
+*   `tires[i].length == 2`
+*   <code>1 <= f<sub>i</sub>, changeTime <= 10<sup>5</sup></code>
+*   <code>2 <= r<sub>i</sub> <= 10<sup>5</sup></code>
+*   `1 <= numLaps <= 1000`
+
+## Solution
+
+```java
+import java.util.Arrays;
+
+public class Solution {
+    public int minimumFinishTime(int[][] tires, int changeTime, int numLaps) {
+        int minf = Integer.MAX_VALUE;
+        // find the minimum of f, to deal with special case and stronger constraints later.
+        for (int[] tire : tires) {
+            minf = Math.min(minf, tire[0]);
+        }
+        // if min-f >= changeTime, we can return early
+        if (minf >= changeTime) {
+            return minf * numLaps + changeTime * (numLaps - 1);
+        }
+        // shortest[i] record shortest time that one single tire is worth to go the i-th laps
+        // worth to go means the i-th lap time is shorter than changeTime + f
+        int[] shortest = new int[numLaps + 1];
+        Arrays.fill(shortest, Integer.MAX_VALUE);
+        int len = 0;
+        // traverse all tires, and update the shortest[i]
+        // this shortest time is available from [1, len] in the array
+        // len is updated in the traverse
+        for (int[] tire : tires) {
+            int f = tire[0];
+            int r = tire[1];
+            // index start from 1 to be consistent with numLaps
+            int index = 1;
+            int t = f;
+            int sum = t;
+            // use changeTime + minf here, which is a strong constraints than changeTime + f
+            while (t <= changeTime + minf && index <= numLaps) {
+                shortest[index] = Math.min(shortest[index], sum);
+                t = t * r;
+                sum += t;
+                index++;
+            }
+            len = Math.max(len, index - 1);
+        }
+        for (int i = 2; i <= numLaps; i++) {
+            // for j > Math.min(i/2, len), it's simply recombination of the values of shortest
+            // [1:len]
+            // it's ok to go furthur for the loop, just repeat the Math.min computation
+            for (int j = 1; j <= Math.min(i / 2, len); j++) {
+                shortest[i] = Math.min(shortest[i], shortest[j] + shortest[i - j] + changeTime);
+            }
+        }
+        return shortest[numLaps];
+    }
+}
+```

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

@@ -0,0 +1,65 @@
+## 2190\. Most Frequent Number Following Key In an Array
+
+Easy
+
+You are given a **0-indexed** integer array `nums`. You are also given an integer `key`, which is present in `nums`.
+
+For every unique integer `target` in `nums`, **count** the number of times `target` immediately follows an occurrence of `key` in `nums`. In other words, count the number of indices `i` such that:
+
+*   `0 <= i <= nums.length - 2`,
+*   `nums[i] == key` and,
+*   `nums[i + 1] == target`.
+
+Return _the_ `target` _with the **maximum** count_. The test cases will be generated such that the `target` with maximum count is unique.
+
+**Example 1:**
+
+**Input:** nums = [1,100,200,1,100], key = 1
+
+**Output:** 100
+
+**Explanation:** For target = 100, there are 2 occurrences at indices 1 and 4 which follow an occurrence of key.
+
+No other integers follow an occurrence of key, so we return 100. 
+
+**Example 2:**
+
+**Input:** nums = [2,2,2,2,3], key = 2
+
+**Output:** 2
+
+**Explanation:** For target = 2, there are 3 occurrences at indices 1, 2, and 3 which follow an occurrence of key.
+
+For target = 3, there is only one occurrence at index 4 which follows an occurrence of key.
+
+target = 2 has the maximum number of occurrences following an occurrence of key, so we return 2. 
+
+**Constraints:**
+
+*   `2 <= nums.length <= 1000`
+*   `1 <= nums[i] <= 1000`
+*   The test cases will be generated such that the answer is unique.
+
+## Solution
+
+```java
+public class Solution {
+    public int mostFrequent(int[] nums, int key) {
+        int[] store = new int[1001];
+        for (int i = 0; i < nums.length - 1; i++) {
+            if (nums[i] == key) {
+                store[nums[i + 1]]++;
+            }
+        }
+        int res = 0;
+        int count = store[0];
+        for (int i = 1; i < 1001; i++) {
+            if (count < store[i]) {
+                count = store[i];
+                res = i;
+            }
+        }
+        return res;
+    }
+}
+```