Added tasks 1822, 1823, 1824, 1825, 1827.

Author: ThanhNIT

src/main/java/g1801_1900/s1822_sign_of_the_product_of_an_array/Solution.java

@@ -0,0 +1,18 @@
+package g1801_1900.s1822_sign_of_the_product_of_an_array;
+
+// #Easy #Array #Math #Programming_Skills_I_Day_4_Loop
+// #2022_05_06_Time_1_ms_(58.05%)_Space_44.1_MB_(44.59%)
+
+public class Solution {
+    public int arraySign(int[] nums) {
+        int negativeCount = 0;
+        for (int num : nums) {
+            if (num == 0) {
+                return 0;
+            } else if (num < 0) {
+                negativeCount++;
+            }
+        }
+        return negativeCount % 2 == 0 ? 1 : -1;
+    }
+}

src/main/java/g1801_1900/s1822_sign_of_the_product_of_an_array/readme.md

@@ -0,0 +1,42 @@
+1822\. Sign of the Product of an Array
+
+Easy
+
+There is a function `signFunc(x)` that returns:
+
+*   `1` if `x` is positive.
+*   `-1` if `x` is negative.
+*   `0` if `x` is equal to `0`.
+
+You are given an integer array `nums`. Let `product` be the product of all values in the array `nums`.
+
+Return `signFunc(product)`.
+
+**Example 1:**
+
+**Input:** nums = [-1,-2,-3,-4,3,2,1]
+
+**Output:** 1
+
+**Explanation:** The product of all values in the array is 144, and signFunc(144) = 1
+
+**Example 2:**
+
+**Input:** nums = [1,5,0,2,-3]
+
+**Output:** 0
+
+**Explanation:** The product of all values in the array is 0, and signFunc(0) = 0
+
+**Example 3:**
+
+**Input:** nums = [-1,1,-1,1,-1]
+
+**Output:** -1
+
+**Explanation:** The product of all values in the array is -1, and signFunc(-1) = -1
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `-100 <= nums[i] <= 100`

src/main/java/g1801_1900/s1823_find_the_winner_of_the_circular_game/Solution.java

@@ -0,0 +1,23 @@
+package g1801_1900.s1823_find_the_winner_of_the_circular_game;
+
+// #Medium #Array #Math #Simulation #Recursion #Queue #Data_Structure_II_Day_14_Stack_Queue
+// #2022_05_06_Time_3_ms_(64.85%)_Space_41.9_MB_(31.61%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int findTheWinner(int n, int k) {
+        List<Integer> list = new ArrayList<>(n);
+        for (int i = 0; i < n; i++) {
+            list.add(i + 1);
+        }
+        int startIndex = 0;
+        while (list.size() != 1) {
+            int removeIndex = (startIndex + k - 1) % list.size();
+            list.remove(removeIndex);
+            startIndex = removeIndex;
+        }
+        return list.get(0);
+    }
+}

src/main/java/g1801_1900/s1823_find_the_winner_of_the_circular_game/readme.md

@@ -0,0 +1,55 @@
+1823\. Find the Winner of the Circular Game
+
+Medium
+
+There are `n` friends that are playing a game. The friends are sitting in a circle and are numbered from `1` to `n` in **clockwise order**. More formally, moving clockwise from the <code>i<sup>th</sup></code> friend brings you to the <code>(i+1)<sup>th</sup></code> friend for `1 <= i < n`, and moving clockwise from the <code>n<sup>th</sup></code> friend brings you to the <code>1<sup>st</sup></code> friend.
+
+The rules of the game are as follows:
+
+1.  **Start** at the <code>1<sup>st</sup></code> friend.
+2.  Count the next `k` friends in the clockwise direction **including** the friend you started at. The counting wraps around the circle and may count some friends more than once.
+3.  The last friend you counted leaves the circle and loses the game.
+4.  If there is still more than one friend in the circle, go back to step `2` **starting** from the friend **immediately clockwise** of the friend who just lost and repeat.
+5.  Else, the last friend in the circle wins the game.
+
+Given the number of friends, `n`, and an integer `k`, return _the winner of the game_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/25/ic234-q2-ex11.png)
+
+**Input:** n = 5, k = 2
+
+**Output:** 3
+
+**Explanation:** Here are the steps of the game: 
+
+1) Start at friend 1. 
+
+2) Count 2 friends clockwise, which are friends 1 and 2. 
+
+3) Friend 2 leaves the circle. Next start is friend 3. 
+
+4) Count 2 friends clockwise, which are friends 3 and 4. 
+
+5) Friend 4 leaves the circle. Next start is friend 5. 
+
+6) Count 2 friends clockwise, which are friends 5 and 1. 
+
+7) Friend 1 leaves the circle. Next start is friend 3. 
+
+8) Count 2 friends clockwise, which are friends 3 and 5. 
+
+9) Friend 5 leaves the circle. Only friend 3 is left, so they are the winner.
+
+**Example 2:**
+
+**Input:** n = 6, k = 5
+
+**Output:** 1
+
+**Explanation:** The friends leave in this order: 5, 4, 6, 2, 3. The winner is friend 1.
+
+**Constraints:**
+
+*   `1 <= k <= n <= 500`

src/main/java/g1801_1900/s1824_minimum_sideway_jumps/Solution.java

@@ -0,0 +1,46 @@
+package g1801_1900.s1824_minimum_sideway_jumps;
+
+// #Medium #Array #Dynamic_Programming #Greedy
+// #2022_05_06_Time_17_ms_(96.34%)_Space_217.7_MB_(56.10%)
+
+public class Solution {
+    public int minSideJumps(int[] obstacles) {
+        int sideJumps = 0;
+        int currLane = 2;
+        int i = 0;
+        while (i < obstacles.length - 1) {
+            if (obstacles[i + 1] == currLane) {
+                if (obstacles[i] != 0) {
+                    currLane = getNextLane(obstacles[i], obstacles[i + 1]);
+                } else {
+                    int j = i + 2;
+                    while (j < obstacles.length
+                            && (obstacles[j] == 0 || obstacles[j] == obstacles[i + 1])) {
+                        j++;
+                    }
+                    if (j < obstacles.length) {
+                        currLane = getNextLane(obstacles[i + 1], obstacles[j]);
+                    } else {
+                        i = obstacles.length - 1;
+                    }
+                }
+                sideJumps++;
+            }
+            i++;
+        }
+        return sideJumps;
+    }
+
+    private int getNextLane(int nextObstacle, int nextNextObstacle) {
+        if ((nextObstacle == 2 && nextNextObstacle == 3)
+                || (nextObstacle == 3 && nextNextObstacle == 2)) {
+            return 1;
+        }
+        if ((nextObstacle == 1 && nextNextObstacle == 3)
+                || (nextObstacle == 3 && nextNextObstacle == 1)) {
+            return 2;
+        } else {
+            return 3;
+        }
+    }
+}

src/main/java/g1801_1900/s1824_minimum_sideway_jumps/readme.md

@@ -0,0 +1,36 @@
+1827\. Minimum Operations to Make the Array Increasing
+
+Easy
+
+You are given an integer array `nums` (**0-indexed**). In one operation, you can choose an element of the array and increment it by `1`.
+
+*   For example, if `nums = [1,2,3]`, you can choose to increment `nums[1]` to make `nums = [1,**3**,3]`.
+
+Return _the **minimum** number of operations needed to make_ `nums` _**strictly** **increasing**._
+
+An array `nums` is **strictly increasing** if `nums[i] < nums[i+1]` for all `0 <= i < nums.length - 1`. An array of length `1` is trivially strictly increasing.
+
+**Example 1:**
+
+**Input:** nums = [1,1,1]
+
+**Output:** 3
+
+**Explanation:** You can do the following operations: 1) Increment nums[2], so nums becomes [1,1,**2**]. 2) Increment nums[1], so nums becomes [1,**2**,2]. 3) Increment nums[2], so nums becomes [1,2,**3**].
+
+**Example 2:**
+
+**Input:** nums = [1,5,2,4,1]
+
+**Output:** 14
+
+**Example 3:**
+
+**Input:** nums = [8]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= nums.length <= 5000`
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>

src/main/java/g1801_1900/s1825_finding_mk_average/MKAverage.java

@@ -0,0 +1,140 @@
+package g1801_1900.s1825_finding_mk_average;
+
+// #Hard #Design #Heap_Priority_Queue #Ordered_Set #Queue
+// #2022_05_06_Time_83_ms_(60.59%)_Space_96.3_MB_(77.83%)
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.TreeMap;
+
+public class MKAverage {
+    private final double m;
+    private final double k;
+    private final double c;
+    private double avg;
+    private final Bst middle;
+    private final Bst min;
+    private final Bst max;
+    private final Deque<Integer> q;
+
+    public MKAverage(int m, int k) {
+        this.m = m;
+        this.k = k;
+        this.c = m - k * 2;
+        this.avg = 0;
+        this.middle = new Bst();
+        this.min = new Bst();
+        this.max = new Bst();
+        this.q = new ArrayDeque<>();
+    }
+
+    public void addElement(int num) {
+        if (min.size < k) {
+            min.add(num);
+            q.offer(num);
+            return;
+        }
+        if (max.size < k) {
+            min.add(num);
+            max.add(min.removeMax());
+            q.offer(num);
+            return;
+        }
+
+        if (num >= min.lastKey() && num <= max.firstKey()) {
+            middle.add(num);
+            avg += num / c;
+        } else if (num < min.lastKey()) {
+            min.add(num);
+            int val = min.removeMax();
+            middle.add(val);
+            avg += val / c;
+        } else if (num > max.firstKey()) {
+            max.add(num);
+            int val = max.removeMin();
+            middle.add(val);
+            avg += val / c;
+        }
+
+        q.offer(num);
+
+        if (q.size() > m) {
+            num = q.poll();
+            if (middle.containsKey(num)) {
+                avg -= num / c;
+                middle.remove(num);
+            } else if (min.containsKey(num)) {
+                min.remove(num);
+                int val = middle.removeMin();
+                avg -= val / c;
+                min.add(val);
+            } else if (max.containsKey(num)) {
+                max.remove(num);
+                int val = middle.removeMax();
+                avg -= val / c;
+                max.add(val);
+            }
+        }
+    }
+
+    public int calculateMKAverage() {
+        if (q.size() < m) {
+            return -1;
+        }
+        return (int) avg;
+    }
+
+    static class Bst {
+        TreeMap<Integer, Integer> map;
+        int size;
+
+        public Bst() {
+            this.map = new TreeMap<>();
+            this.size = 0;
+        }
+
+        void add(int num) {
+            int count = map.getOrDefault(num, 0) + 1;
+            map.put(num, count);
+            size++;
+        }
+
+        void remove(int num) {
+            int count = map.getOrDefault(num, 1) - 1;
+            if (count > 0) {
+                map.put(num, count);
+            } else {
+                map.remove(num);
+            }
+            size--;
+        }
+
+        int removeMin() {
+            int key = map.firstKey();
+
+            remove(key);
+
+            return key;
+        }
+
+        int removeMax() {
+            int key = map.lastKey();
+
+            remove(key);
+
+            return key;
+        }
+
+        boolean containsKey(int key) {
+            return map.containsKey(key);
+        }
+
+        int firstKey() {
+            return map.firstKey();
+        }
+
+        int lastKey() {
+            return map.lastKey();
+        }
+    }
+}