Added tasks 2444, 2446, 2447, 2448, 2449.

Author: ThanhNIT

src/main/java/g2401_2500/s2444_count_subarrays_with_fixed_bounds/Solution.java

@@ -0,0 +1,48 @@
+package g2401_2500.s2444_count_subarrays_with_fixed_bounds;
+
+// #Hard #Array #Sliding_Window #Queue #Monotonic_Queue
+// #2022_12_14_Time_9_ms_(83.94%)_Space_56.5_MB_(97.01%)
+
+public class Solution {
+    public long countSubarrays(int[] nums, int minK, int maxK) {
+        long ans = 0;
+        int i = 0;
+        while ( i < nums.length) {
+            if (nums[i] >= minK && nums[i] <= maxK) {
+                int a = i;
+                int b = i;
+                int mini = 0;
+                int maxi = 0;
+                while (i != nums.length && (nums[i] >= minK && nums[i] <= maxK)) {
+                    i++;
+                }
+                while (true) {
+                    for (; b != i && (mini == 0 || maxi == 0); b++) {
+                        if (nums[b] == minK) {
+                            mini++;
+                        }
+                        if (nums[b] == maxK) {
+                            maxi++;
+                        }
+                    }
+
+                    if (mini == 0 || maxi == 0) {
+                        break;
+                    }
+
+                    for (; mini != 0 && maxi != 0; ans += 1 + (i - b), a++) {
+                        if (nums[a] == minK) {
+                            mini--;
+                        }
+                        if (nums[a] == maxK) {
+                            maxi--;
+                        }
+                    }
+                }
+            }
+            i++;
+        }
+
+        return ans;
+    }
+}

src/main/java/g2401_2500/s2444_count_subarrays_with_fixed_bounds/readme.md

@@ -0,0 +1,35 @@
+2444\. Count Subarrays With Fixed Bounds
+
+Hard
+
+You are given an integer array `nums` and two integers `minK` and `maxK`.
+
+A **fixed-bound subarray** of `nums` is a subarray that satisfies the following conditions:
+
+*   The **minimum** value in the subarray is equal to `minK`.
+*   The **maximum** value in the subarray is equal to `maxK`.
+
+Return _the **number** of fixed-bound subarrays_.
+
+A **subarray** is a **contiguous** part of an array.
+
+**Example 1:**
+
+**Input:** nums = [1,3,5,2,7,5], minK = 1, maxK = 5
+
+**Output:** 2
+
+**Explanation:** The fixed-bound subarrays are [1,3,5] and [1,3,5,2].
+
+**Example 2:**
+
+**Input:** nums = [1,1,1,1], minK = 1, maxK = 1
+
+**Output:** 10
+
+**Explanation:** Every subarray of nums is a fixed-bound subarray. There are 10 possible subarrays.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], minK, maxK <= 10<sup>6</sup></code>

src/main/java/g2401_2500/s2446_determine_if_two_events_have_conflict/Solution.java

@@ -0,0 +1,29 @@
+package g2401_2500.s2446_determine_if_two_events_have_conflict;
+
+// #Easy #Array #String #2022_12_14_Time_0_ms_(100.00%)_Space_40_MB_(87.07%)
+
+public class Solution {
+    public boolean haveConflict(String[] event1, String[] event2) {
+        int aStart = getTimeSerial(event1[0]);
+        int aEnd = getTimeSerial(event1[1]);
+        int bStart = getTimeSerial(event2[0]);
+        int bEnd = getTimeSerial(event2[1]);
+        return (bStart >= aStart && bStart <= aEnd) || (bStart <= aStart && bEnd >= aStart);
+    }
+
+    private int getTimeSerial(String timestamp) {
+        int hours = 0;
+        int minutes = 0;
+        boolean isHours = true;
+        for (int i = 0; i < timestamp.length(); i += 1) {
+            if (timestamp.charAt(i) == ':') {
+                isHours = false;
+            } else if (isHours) {
+                hours = hours * 10 + Character.getNumericValue(timestamp.charAt(i));
+            } else {
+                minutes = minutes * 10 + Character.getNumericValue(timestamp.charAt(i));
+            }
+        }
+        return 60 * hours + minutes;
+    }
+}

src/main/java/g2401_2500/s2446_determine_if_two_events_have_conflict/readme.md

@@ -0,0 +1,46 @@
+2446\. Determine if Two Events Have Conflict
+
+Easy
+
+You are given two arrays of strings that represent two inclusive events that happened **on the same day**, `event1` and `event2`, where:
+
+*   <code>event1 = [startTime<sub>1</sub>, endTime<sub>1</sub>]</code> and
+*   <code>event2 = [startTime<sub>2</sub>, endTime<sub>2</sub>]</code>.
+
+Event times are valid 24 hours format in the form of `HH:MM`.
+
+A **conflict** happens when two events have some non-empty intersection (i.e., some moment is common to both events).
+
+Return `true` _if there is a conflict between two events. Otherwise, return_ `false`.
+
+**Example 1:**
+
+**Input:** event1 = ["01:15","02:00"], event2 = ["02:00","03:00"]
+
+**Output:** true
+
+**Explanation:** The two events intersect at time 2:00.
+
+**Example 2:**
+
+**Input:** event1 = ["01:00","02:00"], event2 = ["01:20","03:00"]
+
+**Output:** true
+
+**Explanation:** The two events intersect starting from 01:20 to 02:00.
+
+**Example 3:**
+
+**Input:** event1 = ["10:00","11:00"], event2 = ["14:00","15:00"]
+
+**Output:** false
+
+**Explanation:** The two events do not intersect.
+
+**Constraints:**
+
+*   `evnet1.length == event2.length == 2.`
+*   `event1[i].length == event2[i].length == 5`
+*   <code>startTime<sub>1</sub> <= endTime<sub>1</sub></code>
+*   <code>startTime<sub>2</sub> <= endTime<sub>2</sub></code>
+*   All the event times follow the `HH:MM` format.

src/main/java/g2401_2500/s2447_number_of_subarrays_with_gcd_equal_to_k/Solution.java

@@ -0,0 +1,30 @@
+package g2401_2500.s2447_number_of_subarrays_with_gcd_equal_to_k;
+
+// #Medium #Array #Math #Number_Theory #2022_12_14_Time_7_ms_(96.60%)_Space_41.9_MB_(82.89%)
+
+public class Solution {
+    private int sol(int a, int b) {
+        if (b == 0) {
+            return a;
+        }
+        return sol(b, a % b);
+    }
+
+    public int subarrayGCD(int[] nums, int k) {
+        int n = nums.length;
+        int cnt = 0;
+        for (int i = 0; i < n; i++) {
+            int gcd = 0;
+            for (int j = i; j < n; j++) {
+                gcd = sol(gcd, nums[j]);
+                if (gcd == k) {
+                    cnt++;
+                }
+                if (gcd < k) {
+                    break;
+                }
+            }
+        }
+        return cnt;
+    }
+}

src/main/java/g2401_2500/s2447_number_of_subarrays_with_gcd_equal_to_k/readme.md

@@ -0,0 +1,38 @@
+2447\. Number of Subarrays With GCD Equal to K
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the number of **subarrays** of_ `nums` _where the greatest common divisor of the subarray's elements is_ `k`.
+
+A **subarray** is a contiguous non-empty sequence of elements within an array.
+
+The **greatest common divisor of an array** is the largest integer that evenly divides all the array elements.
+
+**Example 1:**
+
+**Input:** nums = [9,3,1,2,6,3], k = 3
+
+**Output:** 4
+
+**Explanation:** The subarrays of nums where 3 is the greatest common divisor of all the subarray's elements are:
+
+- [9,<ins>**3**</ins>,1,2,6,3] 
+ 
+- [9,3,1,2,6,<ins>**3**</ins>] 
+ 
+- [<ins>**9,3**</ins>,1,2,6,3] 
+ 
+- [9,3,1,2,<ins>**6,3**</ins>]
+
+**Example 2:**
+
+**Input:** nums = [4], k = 7
+
+**Output:** 0
+
+**Explanation:** There are no subarrays of nums where 7 is the greatest common divisor of all the subarray's elements.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i], k <= 10<sup>9</sup></code>

src/main/java/g2401_2500/s2448_minimum_cost_to_make_array_equal/Solution.java

@@ -0,0 +1,42 @@
+package g2401_2500.s2448_minimum_cost_to_make_array_equal;
+
+// #Hard #Array #Sorting #Binary_Search #Prefix_Sum
+// #2022_12_14_Time_19_ms_(92.19%)_Space_56_MB_(90.89%)
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class Solution {
+    private static class Pair {
+        int e;
+        int c;
+
+        Pair(int e, int c) {
+            this.e = e;
+            this.c = c;
+        }
+    }
+
+    public long minCost(int[] nums, int[] cost) {
+        long sum = 0;
+        List<Pair> al = new ArrayList<>();
+        for (int i = 0; i < nums.length; i++) {
+            al.add(new Pair(nums[i], cost[i]));
+            sum += cost[i];
+        }
+        al.sort(Comparator.comparingInt(a -> a.e));
+        long ans = 0;
+        long mid = (sum + 1) / 2;
+        long s2 = 0;
+        int t = 0;
+        for (int i = 0; i < al.size() && s2 < mid; i++) {
+            s2 += al.get(i).c;
+            t = al.get(i).e;
+        }
+        for (int i = 0; i < al.size(); i++) {
+            ans += Math.abs((long) nums[i] - (long) t) * cost[i];
+        }
+        return ans;
+    }
+}

src/main/java/g2401_2500/s2448_minimum_cost_to_make_array_equal/readme.md

@@ -0,0 +1,43 @@
+2448\. Minimum Cost to Make Array Equal
+
+Hard
+
+You are given two **0-indexed** arrays `nums` and `cost` consisting each of `n` **positive** integers.
+
+You can do the following operation **any** number of times:
+
+*   Increase or decrease **any** element of the array `nums` by `1`.
+
+The cost of doing one operation on the <code>i<sup>th</sup></code> element is `cost[i]`.
+
+Return _the **minimum** total cost such that all the elements of the array_ `nums` _become **equal**_.
+
+**Example 1:**
+
+**Input:** nums = [1,3,5,2], cost = [2,3,1,14]
+
+**Output:** 8
+
+**Explanation:** We can make all the elements equal to 2 in the following way:
+
+- Increase the 0<sup>th</sup> element one time. The cost is 2. 
+
+- Decrease the 1<sup>st</sup> element one time. The cost is 3. 
+
+- Decrease the 2<sup>nd</sup> element three times. The cost is 1 + 1 + 1 = 3. 
+
+- The total cost is 2 + 3 + 3 = 8. It can be shown that we cannot make the array equal with a smaller cost.
+
+**Example 2:**
+
+**Input:** nums = [2,2,2,2,2], cost = [4,2,8,1,3]
+
+**Output:** 0
+
+**Explanation:** All the elements are already equal, so no operations are needed.
+
+**Constraints:**
+
+*   `n == nums.length == cost.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], cost[i] <= 10<sup>6</sup></code>

src/main/java/g2401_2500/s2449_minimum_number_of_operations_to_make_arrays_similar/Solution.java

@@ -0,0 +1,64 @@
+package g2401_2500.s2449_minimum_number_of_operations_to_make_arrays_similar;
+
+// #Hard #Array #Sorting #Greedy #2022_12_14_Time_57_ms_(87.86%)_Space_59.7_MB_(93.46%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Solution {
+    public long makeSimilar(int[] nums, int[] target) {
+        ArrayList<Integer> evenNums = new ArrayList<>();
+        ArrayList<Integer> oddNums = new ArrayList<>();
+        ArrayList<Integer> evenTar = new ArrayList<>();
+        ArrayList<Integer> oddTar = new ArrayList<>();
+        Arrays.sort(nums);
+        Arrays.sort(target);
+
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] % 2 == 0) {
+                evenNums.add(nums[i]);
+            } else {
+                oddNums.add(nums[i]);
+            }
+
+            if (target[i] % 2 == 0) {
+                evenTar.add(target[i]);
+            } else {
+                oddTar.add(target[i]);
+            }
+        }
+
+        long countPositiveIteration = 0;
+        long countNegativeIteration = 0;
+
+        for (int i = 0; i < evenNums.size(); i++) {
+            int num = evenNums.get(i);
+            int tar = evenTar.get(i);
+            long diff = (long) num - tar;
+            long iteration = diff / 2;
+            if (diff > 0) {
+                countNegativeIteration += iteration;
+            } else if (diff < 0) {
+                countPositiveIteration += Math.abs(iteration);
+            }
+        }
+
+        for (int i = 0; i < oddNums.size(); i++) {
+            int num = oddNums.get(i);
+            int tar = oddTar.get(i);
+            long diff = (long) num - tar;
+            long iteration = diff / 2;
+            if (diff > 0) {
+                countNegativeIteration += iteration;
+            } else if (diff < 0) {
+                countPositiveIteration += Math.abs(iteration);
+            }
+        }
+
+        long totalDifference = countPositiveIteration - countNegativeIteration;
+
+        return totalDifference == 0
+                ? countPositiveIteration
+                : countPositiveIteration + Math.abs(totalDifference);
+    }
+}