Added tasks 1825-1837

Author: ThanhNIT

README.md

@@ -1874,6 +1874,16 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.13'
 | 1904 |[The Number of Full Rounds You Have Played](src/main/kotlin/g1901_2000/s1904_the_number_of_full_rounds_you_have_played/Solution.kt)| Medium | String, Math | 149 | 100.00
 | 1903 |[Largest Odd Number in String](src/main/kotlin/g1901_2000/s1903_largest_odd_number_in_string/Solution.kt)| Easy | String, Math, Greedy | 256 | 75.00
 | 1901 |[Find a Peak Element II](src/main/kotlin/g1901_2000/s1901_find_a_peak_element_ii/Solution.kt)| Medium | Array, Binary_Search, Matrix, Divide_and_Conquer, Binary_Search_II_Day_17 | 726 | 100.00
+| 1837 |[Sum of Digits in Base K](src/main/kotlin/g1801_1900/s1837_sum_of_digits_in_base_k/Solution.kt)| Easy | Math | 120 | 100.00
+| 1835 |[Find XOR Sum of All Pairs Bitwise AND](src/main/kotlin/g1801_1900/s1835_find_xor_sum_of_all_pairs_bitwise_and/Solution.kt)| Hard | Array, Math, Bit_Manipulation | 604 | 100.00
+| 1834 |[Single-Threaded CPU](src/main/kotlin/g1801_1900/s1834_single_threaded_cpu/Solution.kt)| Medium | Array, Sorting, Heap_Priority_Queue | 1050 | 100.00
+| 1833 |[Maximum Ice Cream Bars](src/main/kotlin/g1801_1900/s1833_maximum_ice_cream_bars/Solution.kt)| Medium | Array, Sorting, Greedy | 439 | 100.00
+| 1832 |[Check if the Sentence Is Pangram](src/main/kotlin/g1801_1900/s1832_check_if_the_sentence_is_pangram/Solution.kt)| Easy | String, Hash_Table | 127 | 98.00
+| 1830 |[Minimum Number of Operations to Make String Sorted](src/main/kotlin/g1801_1900/s1830_minimum_number_of_operations_to_make_string_sorted/Solution.kt)| Hard | String, Math, Combinatorics | 226 | 100.00
+| 1829 |[Maximum XOR for Each Query](src/main/kotlin/g1801_1900/s1829_maximum_xor_for_each_query/Solution.kt)| Medium | Array, Bit_Manipulation, Prefix_Sum | 680 | 100.00
+| 1828 |[Queries on Number of Points Inside a Circle](src/main/kotlin/g1801_1900/s1828_queries_on_number_of_points_inside_a_circle/Solution.kt)| Medium | Array, Math, Geometry | 284 | 100.00
+| 1827 |[Minimum Operations to Make the Array Increasing](src/main/kotlin/g1801_1900/s1827_minimum_operations_to_make_the_array_increasing/Solution.kt)| Easy | Array, Greedy | 208 | 100.00
+| 1825 |[Finding MK Average](src/main/kotlin/g1801_1900/s1825_finding_mk_average/MKAverage.kt)| Hard | Design, Heap_Priority_Queue, Ordered_Set, Queue | 1101 | 100.00
 | 1824 |[Minimum Sideway Jumps](src/main/kotlin/g1801_1900/s1824_minimum_sideway_jumps/Solution.kt)| Medium | Array, Dynamic_Programming, Greedy | 726 | 100.00
 | 1823 |[Find the Winner of the Circular Game](src/main/kotlin/g1801_1900/s1823_find_the_winner_of_the_circular_game/Solution.kt)| Medium | Array, Math, Simulation, Recursion, Queue, Data_Structure_II_Day_14_Stack_Queue | 119 | 87.50
 | 1822 |[Sign of the Product of an Array](src/main/kotlin/g1801_1900/s1822_sign_of_the_product_of_an_array/Solution.kt)| Easy | Array, Math, Programming_Skills_I_Day_4_Loop | 170 | 92.51

src/main/kotlin/g1801_1900/s1825_finding_mk_average/MKAverage.kt

@@ -0,0 +1,129 @@
+package g1801_1900.s1825_finding_mk_average
+
+// #Hard #Design #Heap_Priority_Queue #Ordered_Set #Queue
+// #2023_06_21_Time_1101_ms_(100.00%)_Space_122.8_MB_(100.00%)
+
+import java.util.Deque
+import java.util.LinkedList
+import java.util.TreeMap
+
+@Suppress("NAME_SHADOWING")
+class MKAverage(m: Int, k: Int) {
+    private val m: Double
+    private val k: Double
+    private val c: Double
+    private var avg: Double
+    private val middle: Bst
+    private val min: Bst
+    private val max: Bst
+    private val q: Deque<Int>
+
+    init {
+        this.m = m.toDouble()
+        this.k = k.toDouble()
+        c = (m - k * 2).toDouble()
+        avg = 0.0
+        middle = Bst()
+        min = Bst()
+        max = Bst()
+        q = LinkedList()
+    }
+
+    fun addElement(num: Int) {
+        var num = 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)
+            val `val` = min.removeMax()
+            middle.add(`val`)
+            avg += `val` / c
+        } else if (num > max.firstKey()) {
+            max.add(num)
+            val `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)
+                val `val` = middle.removeMin()
+                avg -= `val` / c
+                min.add(`val`)
+            } else if (max.containsKey(num)) {
+                max.remove(num)
+                val `val` = middle.removeMax()
+                avg -= `val` / c
+                max.add(`val`)
+            }
+        }
+    }
+
+    fun calculateMKAverage(): Int {
+        return if (q.size < m) {
+            -1
+        } else avg.toInt()
+    }
+
+    internal class Bst {
+        var map: TreeMap<Int, Int> = TreeMap()
+        var size: Int = 0
+
+        fun add(num: Int) {
+            val count = map.getOrDefault(num, 0) + 1
+            map[num] = count
+            size++
+        }
+
+        fun remove(num: Int) {
+            val count = map.getOrDefault(num, 1) - 1
+            if (count > 0) {
+                map[num] = count
+            } else {
+                map.remove(num)
+            }
+            size--
+        }
+
+        fun removeMin(): Int {
+            val key = map.firstKey()
+            remove(key)
+            return key
+        }
+
+        fun removeMax(): Int {
+            val key = map.lastKey()
+            remove(key)
+            return key
+        }
+
+        fun containsKey(key: Int): Boolean {
+            return map.containsKey(key)
+        }
+
+        fun firstKey(): Int {
+            return map.firstKey()
+        }
+
+        fun lastKey(): Int {
+            return map.lastKey()
+        }
+    }
+}

src/main/kotlin/g1801_1900/s1825_finding_mk_average/readme.md

@@ -0,0 +1,32 @@
+1825\. Finding MK Average
+
+Hard
+
+You are given two integers, `m` and `k`, and a stream of integers. You are tasked to implement a data structure that calculates the **MKAverage** for the stream.
+
+The **MKAverage** can be calculated using these steps:
+
+1.  If the number of the elements in the stream is less than `m` you should consider the **MKAverage** to be `-1`. Otherwise, copy the last `m` elements of the stream to a separate container.
+2.  Remove the smallest `k` elements and the largest `k` elements from the container.
+3.  Calculate the average value for the rest of the elements **rounded down to the nearest integer**.
+
+Implement the `MKAverage` class:
+
+*   `MKAverage(int m, int k)` Initializes the **MKAverage** object with an empty stream and the two integers `m` and `k`.
+*   `void addElement(int num)` Inserts a new element `num` into the stream.
+*   `int calculateMKAverage()` Calculates and returns the **MKAverage** for the current stream **rounded down to the nearest integer**.
+
+**Example 1:**
+
+**Input** ["MKAverage", "addElement", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage", "addElement", "addElement", "addElement", "calculateMKAverage"] [[3, 1], [3], [1], [], [10], [], [5], [5], [5], []]
+
+**Output:** [null, null, null, -1, null, 3, null, null, null, 5]
+
+**Explanation:** MKAverage obj = new MKAverage(3, 1); obj.addElement(3); // current elements are [3] obj.addElement(1); // current elements are [3,1] obj.calculateMKAverage(); // return -1, because m = 3 and only 2 elements exist. obj.addElement(10); // current elements are [3,1,10] obj.calculateMKAverage(); // The last 3 elements are [3,1,10]. // After removing smallest and largest 1 element the container will be ```[3]. // The average of [3] equals 3/1 = 3, return 3 obj.addElement(5); // current elements are [3,1,10,5] obj.addElement(5); // current elements are [3,1,10,5,5] obj.addElement(5); // current elements are [3,1,10,5,5,5] obj.calculateMKAverage(); // The last 3 elements are [5,5,5]. // After removing smallest and largest 1 element the container will be `[5]. // The average of [5] equals 5/1 = 5, return 5` ```
+
+**Constraints:**
+
+*   <code>3 <= m <= 10<sup>5</sup></code>
+*   `1 <= k*2 < m`
+*   <code>1 <= num <= 10<sup>5</sup></code>
+*   At most <code>10<sup>5</sup></code> calls will be made to `addElement` and `calculateMKAverage`.

src/main/kotlin/g1801_1900/s1827_minimum_operations_to_make_the_array_increasing/Solution.kt

@@ -0,0 +1,16 @@
+package g1801_1900.s1827_minimum_operations_to_make_the_array_increasing
+
+// #Easy #Array #Greedy #2023_06_21_Time_208_ms_(100.00%)_Space_38.9_MB_(77.78%)
+
+class Solution {
+    fun minOperations(nums: IntArray): Int {
+        var minsOps = 0
+        for (i in 1 until nums.size) {
+            if (nums[i] <= nums[i - 1]) {
+                minsOps += nums[i - 1] - nums[i] + 1
+                nums[i] = nums[i - 1] + 1
+            }
+        }
+        return minsOps
+    }
+}

src/main/kotlin/g1801_1900/s1827_minimum_operations_to_make_the_array_increasing/readme.md

@@ -0,0 +1,42 @@
+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/kotlin/g1801_1900/s1828_queries_on_number_of_points_inside_a_circle/Solution.kt

@@ -0,0 +1,22 @@
+package g1801_1900.s1828_queries_on_number_of_points_inside_a_circle
+
+// #Medium #Array #Math #Geometry #2023_06_21_Time_284_ms_(100.00%)_Space_45.8_MB_(100.00%)
+
+class Solution {
+    fun countPoints(points: Array<IntArray>, queries: Array<IntArray>): IntArray {
+        val result = IntArray(queries.size)
+        for ((i, query) in queries.withIndex()) {
+            var pts = 0
+            for (point in points) {
+                if ((point[0] - query[0]) * (point[0] - query[0]) +
+                    (point[1] - query[1]) * (point[1] - query[1])
+                    <= query[2] * query[2]
+                ) {
+                    pts++
+                }
+            }
+            result[i] = pts
+        }
+        return result
+    }
+}

src/main/kotlin/g1801_1900/s1828_queries_on_number_of_points_inside_a_circle/readme.md

@@ -0,0 +1,44 @@
+1828\. Queries on Number of Points Inside a Circle
+
+Medium
+
+You are given an array `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> is the coordinates of the <code>i<sup>th</sup></code> point on a 2D plane. Multiple points can have the **same** coordinates.
+
+You are also given an array `queries` where <code>queries[j] = [x<sub>j</sub>, y<sub>j</sub>, r<sub>j</sub>]</code> describes a circle centered at <code>(x<sub>j</sub>, y<sub>j</sub>)</code> with a radius of <code>r<sub>j</sub></code>.
+
+For each query `queries[j]`, compute the number of points **inside** the <code>j<sup>th</sup></code> circle. Points **on the border** of the circle are considered **inside**.
+
+Return _an array_ `answer`_, where_ `answer[j]` _is the answer to the_ <code>j<sup>th</sup></code> _query_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/25/chrome_2021-03-25_22-34-16.png)
+
+**Input:** points = [[1,3],[3,3],[5,3],[2,2]], queries = [[2,3,1],[4,3,1],[1,1,2]]
+
+**Output:** [3,2,2]
+
+**Explanation:** The points and circles are shown above. queries[0] is the green circle, queries[1] is the red circle, and queries[2] is the blue circle.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/25/chrome_2021-03-25_22-42-07.png)
+
+**Input:** points = [[1,1],[2,2],[3,3],[4,4],[5,5]], queries = [[1,2,2],[2,2,2],[4,3,2],[4,3,3]]
+
+**Output:** [2,3,2,4]
+
+**Explanation:** The points and circles are shown above. queries[0] is green, queries[1] is red, queries[2] is blue, and queries[3] is purple.
+
+**Constraints:**
+
+*   `1 <= points.length <= 500`
+*   `points[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 500</code>
+*   `1 <= queries.length <= 500`
+*   `queries[j].length == 3`
+*   <code>0 <= x<sub>j</sub>, y<sub>j</sub> <= 500</code>
+*   <code>1 <= r<sub>j</sub> <= 500</code>
+*   All coordinates are integers.
+
+**Follow up:** Could you find the answer for each query in better complexity than `O(n)`?

src/main/kotlin/g1801_1900/s1829_maximum_xor_for_each_query/Solution.kt

@@ -0,0 +1,20 @@
+package g1801_1900.s1829_maximum_xor_for_each_query
+
+// #Medium #Array #Bit_Manipulation #Prefix_Sum
+// #2023_06_21_Time_680_ms_(100.00%)_Space_52.8_MB_(100.00%)
+
+class Solution {
+    fun getMaximumXor(nums: IntArray, maximumBit: Int): IntArray {
+        val result = IntArray(nums.size)
+        var `val` = nums[0]
+        val target = (1 shl maximumBit) - 1
+        for (i in 1 until nums.size) {
+            `val` = `val` xor nums[i]
+        }
+        for (i in result.indices) {
+            result[i] = target xor `val`
+            `val` = `val` xor nums[nums.size - i - 1]
+        }
+        return result
+    }
+}

src/main/kotlin/g1801_1900/s1829_maximum_xor_for_each_query/readme.md

@@ -0,0 +1,56 @@
+1829\. Maximum XOR for Each Query
+
+Medium
+
+You are given a **sorted** array `nums` of `n` non-negative integers and an integer `maximumBit`. You want to perform the following query `n` **times**:
+
+1.  Find a non-negative integer <code>k < 2<sup>maximumBit</sup></code> such that `nums[0] XOR nums[1] XOR ... XOR nums[nums.length-1] XOR k` is **maximized**. `k` is the answer to the <code>i<sup>th</sup></code> query.
+2.  Remove the **last** element from the current array `nums`.
+
+Return _an array_ `answer`_, where_ `answer[i]` _is the answer to the_ <code>i<sup>th</sup></code> _query_.
+
+**Example 1:**
+
+**Input:** nums = [0,1,1,3], maximumBit = 2
+
+**Output:** [0,3,2,3]
+
+**Explanation:** The queries are answered as follows: 
+
+1<sup>st</sup> query: nums = [0,1,1,3], k = 0 since 0 XOR 1 XOR 1 XOR 3 XOR 0 = 3. 
+
+2<sup>nd</sup> query: nums = [0,1,1], k = 3 since 0 XOR 1 XOR 1 XOR 3 = 3. 
+
+3<sup>rd</sup> query: nums = [0,1], k = 2 since 0 XOR 1 XOR 2 = 3. 
+
+4<sup>th</sup> query: nums = [0], k = 3 since 0 XOR 3 = 3.
+
+**Example 2:**
+
+**Input:** nums = [2,3,4,7], maximumBit = 3
+
+**Output:** [5,2,6,5]
+
+**Explanation:** The queries are answered as follows: 
+
+1<sup>st</sup> query: nums = [2,3,4,7], k = 5 since 2 XOR 3 XOR 4 XOR 7 XOR 5 = 7. 
+
+2<sup>nd</sup> query: nums = [2,3,4], k = 2 since 2 XOR 3 XOR 4 XOR 2 = 7. 
+
+3<sup>rd</sup> query: nums = [2,3], k = 6 since 2 XOR 3 XOR 6 = 7. 
+
+4<sup>th</sup> query: nums = [2], k = 5 since 2 XOR 5 = 7.
+
+**Example 3:**
+
+**Input:** nums = [0,1,2,2,5,7], maximumBit = 3
+
+**Output:** [4,3,6,4,6,7]
+
+**Constraints:**
+
+*   `nums.length == n`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `1 <= maximumBit <= 20`
+*   <code>0 <= nums[i] < 2<sup>maximumBit</sup></code>
+*   `nums` is sorted in **ascending** order.