Added tasks 2006, 2007, 2008, 2009.

Author: ThanhNIT

src/main/java/g2001_2100/s2006_count_number_of_pairs_with_absolute_difference_k/Solution.java

@@ -0,0 +1,17 @@
+package g2001_2100.s2006_count_number_of_pairs_with_absolute_difference_k;
+
+// #Easy #Array #Hash_Table #Counting #2022_05_23_Time_8_ms_(58.60%)_Space_42.2_MB_(74.50%)
+
+public class Solution {
+    public int countKDifference(int[] nums, int k) {
+        int pairs = 0;
+        for (int i = 0; i < nums.length - 1; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                if (Math.abs(nums[i] - nums[j]) == k) {
+                    pairs++;
+                }
+            }
+        }
+        return pairs;
+    }
+}

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

@@ -0,0 +1,54 @@
+2006\. Count Number of Pairs With Absolute Difference K
+
+Easy
+
+Given an integer array `nums` and an integer `k`, return _the number of pairs_ `(i, j)` _where_ `i < j` _such that_ `|nums[i] - nums[j]| == k`.
+
+The value of `|x|` is defined as:
+
+*   `x` if `x >= 0`.
+*   `-x` if `x < 0`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2,1], k = 1
+
+**Output:** 4
+
+**Explanation:** The pairs with an absolute difference of 1 are: 
+
+- [**1**,**2**,2,1] 
+
+- [**1**,2,**2**,1] 
+
+- [1,**2**,2,**1**] 
+
+- [1,2,**2**,**1**]
+
+**Example 2:**
+
+**Input:** nums = [1,3], k = 3
+
+**Output:** 0
+
+**Explanation:** There are no pairs with an absolute difference of 3.
+
+**Example 3:**
+
+**Input:** nums = [3,2,1,5,4], k = 2
+
+**Output:** 3
+
+**Explanation:** The pairs with an absolute difference of 2 are: 
+
+- [**3**,2,**1**,5,4] 
+
+- [**3**,2,1,**5**,4] 
+
+- [3,**2**,1,5,**4**]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 200`
+*   `1 <= nums[i] <= 100`
+*   `1 <= k <= 99`

src/main/java/g2001_2100/s2007_find_original_array_from_doubled_array/Solution.java

@@ -0,0 +1,51 @@
+package g2001_2100.s2007_find_original_array_from_doubled_array;
+
+// #Medium #Array #Hash_Table #Sorting #Greedy
+// #2022_05_23_Time_41_ms_(96.48%)_Space_134.5_MB_(42.43%)
+
+public class Solution {
+    public int[] findOriginalArray(int[] changed) {
+        if (changed.length % 2 == 1) {
+            return new int[0];
+        }
+        int[] a = new int[100001];
+        for (int j : changed) {
+            a[j]++;
+        }
+        if (a[0] % 2 == 1) {
+            return new int[0];
+        }
+        int[] ans = new int[changed.length / 2];
+        int p = 0;
+        if (a[0] > 0) {
+            a[0] /= 2;
+            while (a[0] > 0) {
+                ans[p++] = 0;
+                a[0]--;
+            }
+        }
+        for (int i = 1; i <= 100001 / 2; i++) {
+            if (a[i] == 0) {
+                continue;
+            }
+            int tmp = i * 2;
+            if (a[tmp] >= a[i]) {
+                a[tmp] = a[tmp] - a[i];
+                while (a[i] > 0) {
+                    ans[p++] = i;
+                    a[i]--;
+                }
+            } else {
+
+                return new int[0];
+            }
+        }
+        for (int i = 1; i < a.length; i++) {
+            if (a[i] != 0) {
+                return new int[0];
+            }
+        }
+
+        return ans;
+    }
+}

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

@@ -0,0 +1,44 @@
+2007\. Find Original Array From Doubled Array
+
+Medium
+
+An integer array `original` is transformed into a **doubled** array `changed` by appending **twice the value** of every element in `original`, and then randomly **shuffling** the resulting array.
+
+Given an array `changed`, return `original` _if_ `changed` _is a **doubled** array. If_ `changed` _is not a **doubled** array, return an empty array. The elements in_ `original` _may be returned in **any** order_.
+
+**Example 1:**
+
+**Input:** changed = [1,3,4,2,6,8]
+
+**Output:** [1,3,4]
+
+**Explanation:** One possible original array could be [1,3,4]: 
+
+- Twice the value of 1 is 1 \* 2 = 2. 
+
+- Twice the value of 3 is 3 \* 2 = 6. 
+
+- Twice the value of 4 is 4 \* 2 = 8. 
+  
+Other original arrays could be [4,3,1] or [3,1,4].
+
+**Example 2:**
+
+**Input:** changed = [6,3,0,1]
+
+**Output:** []
+
+**Explanation:** changed is not a doubled array.
+
+**Example 3:**
+
+**Input:** changed = [1]
+
+**Output:** []
+
+**Explanation:** changed is not a doubled array.
+
+**Constraints:**
+
+*   <code>1 <= changed.length <= 10<sup>5</sup></code>
+*   <code>0 <= changed[i] <= 10<sup>5</sup></code>

src/main/java/g2001_2100/s2008_maximum_earnings_from_taxi/Solution.java

@@ -0,0 +1,44 @@
+package g2001_2100.s2008_maximum_earnings_from_taxi;
+
+// #Medium #Array #Dynamic_Programming #Sorting #Binary_Search
+// #2022_05_23_Time_116_ms_(55.59%)_Space_135.7_MB_(5.00%)
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public long maxTaxiEarnings(int n, int[][] rides) {
+        if (rides.length == 1) {
+            return calculateEarnings(rides[0]);
+        }
+
+        Map<Integer, List<int[]>> map = new HashMap<>();
+        for (int[] ride : rides) {
+            map.compute(ride[1], (k, v) -> (v == null) ? new ArrayList<>() : v).add(ride);
+        }
+
+        long[] maximisedEarnings = new long[n + 1];
+        Arrays.fill(maximisedEarnings, 0);
+        for (int i = 1; i < maximisedEarnings.length; i++) {
+            maximisedEarnings[i] = maximisedEarnings[i - 1];
+            List<int[]> passengers = map.get(i);
+            if (passengers != null) {
+                for (int[] passenger : passengers) {
+                    final int earning = calculateEarnings(passenger);
+                    maximisedEarnings[i] =
+                            Math.max(
+                                    maximisedEarnings[i],
+                                    maximisedEarnings[passenger[0]] + earning);
+                }
+            }
+        }
+        return maximisedEarnings[n];
+    }
+
+    private int calculateEarnings(final int[] currentRide) {
+        return currentRide[1] - currentRide[0] + currentRide[2];
+    }
+}

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

@@ -0,0 +1,45 @@
+2008\. Maximum Earnings From Taxi
+
+Medium
+
+There are `n` points on a road you are driving your taxi on. The `n` points on the road are labeled from `1` to `n` in the direction you are going, and you want to drive from point `1` to point `n` to make money by picking up passengers. You cannot change the direction of the taxi.
+
+The passengers are represented by a **0-indexed** 2D integer array `rides`, where <code>rides[i] = [start<sub>i</sub>, end<sub>i</sub>, tip<sub>i</sub>]</code> denotes the <code>i<sup>th</sup></code> passenger requesting a ride from point <code>start<sub>i</sub></code> to point <code>end<sub>i</sub></code> who is willing to give a <code>tip<sub>i</sub></code> dollar tip.
+
+For **each** passenger `i` you pick up, you **earn** <code>end<sub>i</sub> - start<sub>i</sub> + tip<sub>i</sub></code> dollars. You may only drive **at most one** passenger at a time.
+
+Given `n` and `rides`, return _the **maximum** number of dollars you can earn by picking up the passengers optimally._
+
+**Note:** You may drop off a passenger and pick up a different passenger at the same point.
+
+**Example 1:**
+
+**Input:** n = 5, rides = [[2,5,4],[1,5,1]]
+
+**Output:** 7
+
+**Explanation:** We can pick up passenger 0 to earn 5 - 2 + 4 = 7 dollars.
+
+**Example 2:**
+
+**Input:** n = 20, rides = [[1,6,1],[3,10,2],[10,12,3],[11,12,2],[12,15,2],[13,18,1]]
+
+**Output:** 20
+
+**Explanation:** We will pick up the following passengers: 
+
+- Drive passenger 1 from point 3 to point 10 for a profit of 10 - 3 + 2 = 9 dollars. 
+
+- Drive passenger 2 from point 10 to point 12 for a profit of 12 - 10 + 3 = 5 dollars.
+
+- Drive passenger 5 from point 13 to point 18 for a profit of 18 - 13 + 1 = 6 dollars. 
+  
+We earn 9 + 5 + 6 = 20 dollars in total.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= rides.length <= 3 * 10<sup>4</sup></code>
+*   `rides[i].length == 3`
+*   <code>1 <= start<sub>i</sub> < end<sub>i</sub> <= n</code>
+*   <code>1 <= tip<sub>i</sub> <= 10<sup>5</sup></code>

src/main/java/g2001_2100/s2009_minimum_number_of_operations_to_make_array_continuous/Solution.java

@@ -0,0 +1,30 @@
+package g2001_2100.s2009_minimum_number_of_operations_to_make_array_continuous;
+
+// #Hard #Array #Binary_Search #2022_05_24_Time_57_ms_(72.43%)_Space_78.2_MB_(65.41%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int minOperations(int[] nums) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int duplicates = 0;
+        int maxContinuous = 0;
+        int start = 0;
+        int end = 0;
+        while (end < n) {
+            if (end > 0 && nums[end] == nums[end - 1]) {
+                duplicates++;
+            }
+            while (nums[start] + n <= nums[end]) {
+                start++;
+                if (nums[start] == nums[start - 1]) {
+                    duplicates--;
+                }
+            }
+            maxContinuous = Math.max(maxContinuous, end - start + 1 - duplicates);
+            end++;
+        }
+        return n - maxContinuous;
+    }
+}

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

@@ -0,0 +1,51 @@
+2009\. Minimum Number of Operations to Make Array Continuous
+
+Hard
+
+You are given an integer array `nums`. In one operation, you can replace **any** element in `nums` with **any** integer.
+
+`nums` is considered **continuous** if both of the following conditions are fulfilled:
+
+*   All elements in `nums` are **unique**.
+*   The difference between the **maximum** element and the **minimum** element in `nums` equals `nums.length - 1`.
+
+For example, `nums = [4, 2, 5, 3]` is **continuous**, but `nums = [1, 2, 3, 5, 6]` is **not continuous**.
+
+Return _the **minimum** number of operations to make_ `nums` **_continuous_**.
+
+**Example 1:**
+
+**Input:** nums = [4,2,5,3]
+
+**Output:** 0
+
+**Explanation:** nums is already continuous.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,5,6]
+
+**Output:** 1
+
+**Explanation:** One possible solution is to change the last element to 4. The resulting array is [1,2,3,5,4], which is continuous.
+
+**Example 3:**
+
+**Input:** nums = [1,10,100,1000]
+
+**Output:** 3
+
+**Explanation:** One possible solution is to: 
+
+- Change the second element to 2. 
+
+- Change the third element to 3. 
+
+- Change the fourth element to 4. 
+  
+The resulting array is [1,2,3,4], which is continuous.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/test/java/g2001_2100/s2006_count_number_of_pairs_with_absolute_difference_k/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2001_2100.s2006_count_number_of_pairs_with_absolute_difference_k;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countKDifference() {
+        assertThat(new Solution().countKDifference(new int[] {1, 2, 2, 1}, 1), equalTo(4));
+    }
+
+    @Test
+    void countKDifference2() {
+        assertThat(new Solution().countKDifference(new int[] {1, 3}, 3), equalTo(0));
+    }
+
+    @Test
+    void countKDifference3() {
+        assertThat(new Solution().countKDifference(new int[] {3, 2, 1, 5, 4}, 2), equalTo(3));
+    }
+}

src/test/java/g2001_2100/s2007_find_original_array_from_doubled_array/SolutionTest.java

@@ -0,0 +1,25 @@
+package g2001_2100.s2007_find_original_array_from_doubled_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findOriginalArray() {
+        assertThat(
+                new Solution().findOriginalArray(new int[] {1, 3, 4, 2, 6, 8}),
+                equalTo(new int[] {1, 3, 4}));
+    }
+
+    @Test
+    void findOriginalArray2() {
+        assertThat(new Solution().findOriginalArray(new int[] {6, 3, 0, 1}), equalTo(new int[] {}));
+    }
+
+    @Test
+    void findOriginalArray3() {
+        assertThat(new Solution().findOriginalArray(new int[] {1}), equalTo(new int[] {}));
+    }
+}