+ problem 1825

Author: fruit-in

Problemset/1825-Finding MK Average/README.md

@@ -0,0 +1,101 @@
+# 1825. Finding MK Average
+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:
+<pre>
+<strong>Input:</strong>
+["MKAverage", "addElement", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage", "addElement", "addElement", "addElement", "calculateMKAverage"]
+[[3, 1], [3], [1], [], [10], [], [5], [5], [5], []]
+<strong>Output:</strong>
+[null, null, null, -1, null, 3, null, null, null, 5]
+<strong>Explanation:</strong>
+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
+</pre>
+
+#### 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`.
+
+## Solutions (Python)
+
+### 1. Solution
+```Python
+from sortedcontainers import SortedList
+
+
+class MKAverage:
+
+    def __init__(self, m: int, k: int):
+        self.m = m
+        self.k = k
+        self.sum = 0
+        self.queue = collections.deque()
+        self.container = SortedList()
+
+    def addElement(self, num: int) -> None:
+        if len(self.queue) < self.m:
+            self.queue.append(num)
+            self.container.add(num)
+            if len(self.queue) == self.m:
+                self.sum = sum(self.container[self.k:-self.k])
+            return
+
+        if num < self.container[self.k]:
+            self.sum -= self.container[-self.k - 1]
+            self.container.add(num)
+            self.sum += self.container[self.k]
+        elif num < self.container[-self.k]:
+            self.sum += num
+            self.container.add(num)
+            self.sum -= self.container[-self.k - 1]
+        else:
+            self.container.add(num)
+        self.queue.append(num)
+
+        if self.queue[0] < self.container[self.k]:
+            self.sum += self.container[-self.k - 1]
+            self.sum -= self.container[self.k]
+        elif self.queue[0] < self.container[-self.k - 1]:
+            self.sum += self.container[-self.k - 1]
+            self.sum -= self.queue[0]
+        self.container.discard(self.queue.popleft())
+
+    def calculateMKAverage(self) -> int:
+        if len(self.queue) < self.m:
+            return -1
+
+        return self.sum // (self.m - self.k * 2)
+
+
+# Your MKAverage object will be instantiated and called as such:
+# obj = MKAverage(m, k)
+# obj.addElement(num)
+# param_2 = obj.calculateMKAverage()
+```

Problemset/1825-Finding MK Average/README_CN.md

@@ -0,0 +1,101 @@
+# 1825. 求出 MK 平均值
+给你两个整数 `m` 和 `k` ，以及数据流形式的若干整数。你需要实现一个数据结构，计算这个数据流的 **MK 平均值** 。
+
+**MK 平均值** 按照如下步骤计算：
+
+1. 如果数据流中的整数少于 `m` 个，**MK 平均值** 为 `-1` ，否则将数据流中最后 `m` 个元素拷贝到一个独立的容器中。
+2. 从这个容器中删除最小的 `k` 个数和最大的 `k` 个数。
+3. 计算剩余元素的平均值，并 **向下取整到最近的整数** 。
+
+请你实现 `MKAverage` 类：
+
+* `MKAverage(int m, int k)` 用一个空的数据流和两个整数 `m` 和 `k` 初始化 **MKAverage** 对象。
+* `void addElement(int num)` 往数据流中插入一个新的元素 `num` 。
+* `int calculateMKAverage()` 对当前的数据流计算并返回 **MK 平均数** ，结果需 **向下取整到最近的整数** 。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong>
+["MKAverage", "addElement", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage", "addElement", "addElement", "addElement", "calculateMKAverage"]
+[[3, 1], [3], [1], [], [10], [], [5], [5], [5], []]
+<strong>输出:</strong>
+[null, null, null, -1, null, 3, null, null, null, 5]
+<strong>解释:</strong>
+MKAverage obj = new MKAverage(3, 1);
+obj.addElement(3);        // 当前元素为 [3]
+obj.addElement(1);        // 当前元素为 [3,1]
+obj.calculateMKAverage(); // 返回 -1 ，因为 m = 3 ，但数据流中只有 2 个元素
+obj.addElement(10);       // 当前元素为 [3,1,10]
+obj.calculateMKAverage(); // 最后 3 个元素为 [3,1,10]
+                          // 删除最小以及最大的 1 个元素后，容器为 [3]
+                          // [3] 的平均值等于 3/1 = 3 ，故返回 3
+obj.addElement(5);        // 当前元素为 [3,1,10,5]
+obj.addElement(5);        // 当前元素为 [3,1,10,5,5]
+obj.addElement(5);        // 当前元素为 [3,1,10,5,5,5]
+obj.calculateMKAverage(); // 最后 3 个元素为 [5,5,5]
+                          // 删除最小以及最大的 1 个元素后，容器为 [5]
+                          // [5] 的平均值等于 5/1 = 5 ，故返回 5
+</pre>
+
+#### 提示:
+* <code>3 <= m <= 10<sup>5</sup></code>
+* `1 <= k*2 < m`
+* <code>1 <= num <= 10<sup>5</sup></code>
+* `addElement` 与 `calculateMKAverage` 总操作次数不超过 <code>10<sup>5</sup></code> 次。
+
+## 题解 (Python)
+
+### 1. 题解
+```Python
+from sortedcontainers import SortedList
+
+
+class MKAverage:
+
+    def __init__(self, m: int, k: int):
+        self.m = m
+        self.k = k
+        self.sum = 0
+        self.queue = collections.deque()
+        self.container = SortedList()
+
+    def addElement(self, num: int) -> None:
+        if len(self.queue) < self.m:
+            self.queue.append(num)
+            self.container.add(num)
+            if len(self.queue) == self.m:
+                self.sum = sum(self.container[self.k:-self.k])
+            return
+
+        if num < self.container[self.k]:
+            self.sum -= self.container[-self.k - 1]
+            self.container.add(num)
+            self.sum += self.container[self.k]
+        elif num < self.container[-self.k]:
+            self.sum += num
+            self.container.add(num)
+            self.sum -= self.container[-self.k - 1]
+        else:
+            self.container.add(num)
+        self.queue.append(num)
+
+        if self.queue[0] < self.container[self.k]:
+            self.sum += self.container[-self.k - 1]
+            self.sum -= self.container[self.k]
+        elif self.queue[0] < self.container[-self.k - 1]:
+            self.sum += self.container[-self.k - 1]
+            self.sum -= self.queue[0]
+        self.container.discard(self.queue.popleft())
+
+    def calculateMKAverage(self) -> int:
+        if len(self.queue) < self.m:
+            return -1
+
+        return self.sum // (self.m - self.k * 2)
+
+
+# Your MKAverage object will be instantiated and called as such:
+# obj = MKAverage(m, k)
+# obj.addElement(num)
+# param_2 = obj.calculateMKAverage()
+```

Problemset/1825-Finding MK Average/Solution.py

@@ -0,0 +1,51 @@
+from sortedcontainers import SortedList
+
+
+class MKAverage:
+
+    def __init__(self, m: int, k: int):
+        self.m = m
+        self.k = k
+        self.sum = 0
+        self.queue = collections.deque()
+        self.container = SortedList()
+
+    def addElement(self, num: int) -> None:
+        if len(self.queue) < self.m:
+            self.queue.append(num)
+            self.container.add(num)
+            if len(self.queue) == self.m:
+                self.sum = sum(self.container[self.k:-self.k])
+            return
+
+        if num < self.container[self.k]:
+            self.sum -= self.container[-self.k - 1]
+            self.container.add(num)
+            self.sum += self.container[self.k]
+        elif num < self.container[-self.k]:
+            self.sum += num
+            self.container.add(num)
+            self.sum -= self.container[-self.k - 1]
+        else:
+            self.container.add(num)
+        self.queue.append(num)
+
+        if self.queue[0] < self.container[self.k]:
+            self.sum += self.container[-self.k - 1]
+            self.sum -= self.container[self.k]
+        elif self.queue[0] < self.container[-self.k - 1]:
+            self.sum += self.container[-self.k - 1]
+            self.sum -= self.queue[0]
+        self.container.discard(self.queue.popleft())
+
+    def calculateMKAverage(self) -> int:
+        if len(self.queue) < self.m:
+            return -1
+
+        return self.sum // (self.m - self.k * 2)
+
+
+# Your MKAverage object will be instantiated and called as such:
+# obj = MKAverage(m, k)
+# obj.addElement(num)
+# param_2 = obj.calculateMKAverage()

README.md

@@ -1104,6 +1104,7 @@
 [1822][1822l]|[Sign of the Product of an Array][1822]                                               |![rb]  ![rs]
 [1823][1823l]|[Find the Winner of the Circular Game][1823]                                          |![rs]
 [1824][1824l]|[Minimum Sideway Jumps][1824]                                                         |![rs]
+[1825][1825l]|[Finding MK Average][1825]                                                            |![py]
 [1827][1827l]|[Minimum Operations to Make the Array Increasing][1827]                               |![rb]  ![rs]
 [1828][1828l]|[Queries on Number of Points Inside a Circle][1828]                                   |![py]
 [1829][1829l]|[Maximum XOR for Each Query][1829]                                                    |![rs]
@@ -2616,6 +2617,7 @@
 [1822]:Problemset/1822-Sign%20of%20the%20Product%20of%20an%20Array/README.md#1822-sign-of-the-product-of-an-array
 [1823]:Problemset/1823-Find%20the%20Winner%20of%20the%20Circular%20Game/README.md#1823-find-the-winner-of-the-circular-game
 [1824]:Problemset/1824-Minimum%20Sideway%20Jumps/README.md#1824-minimum-sideway-jumps
+[1825]:Problemset/1825-Finding%20MK%20Average/README.md#1825-finding-mk-average
 [1827]:Problemset/1827-Minimum%20Operations%20to%20Make%20the%20Array%20Increasing/README.md#1827-minimum-operations-to-make-the-array-increasing
 [1828]:Problemset/1828-Queries%20on%20Number%20of%20Points%20Inside%20a%20Circle/README.md#1828-queries-on-number-of-points-inside-a-circle
 [1829]:Problemset/1829-Maximum%20XOR%20for%20Each%20Query/README.md#1829-maximum-xor-for-each-query
@@ -4127,6 +4129,7 @@
 [1822l]:https://leetcode.com/problems/sign-of-the-product-of-an-array/
 [1823l]:https://leetcode.com/problems/find-the-winner-of-the-circular-game/
 [1824l]:https://leetcode.com/problems/minimum-sideway-jumps/
+[1825l]:https://leetcode.com/problems/finding-mk-average/
 [1827l]:https://leetcode.com/problems/minimum-operations-to-make-the-array-increasing/
 [1828l]:https://leetcode.com/problems/queries-on-number-of-points-inside-a-circle/
 [1829l]:https://leetcode.com/problems/maximum-xor-for-each-query/

README_CN.md

@@ -1104,6 +1104,7 @@
 [1822][1822l]|[数组元素积的符号][1822]                                  |![rb]  ![rs]
 [1823][1823l]|[找出游戏的获胜者][1823]                                  |![rs]
 [1824][1824l]|[最少侧跳次数][1824]                                      |![rs]
+[1825][1825l]|[求出 MK 平均值][1825]                                    |![py]
 [1827][1827l]|[最少操作使数组递增][1827]                                |![rb]  ![rs]
 [1828][1828l]|[统计一个圆中点的数目][1828]                              |![py]
 [1829][1829l]|[每个查询的最大异或值][1829]                              |![rs]
@@ -2616,6 +2617,7 @@
 [1822]:Problemset/1822-Sign%20of%20the%20Product%20of%20an%20Array/README_CN.md#1822-数组元素积的符号
 [1823]:Problemset/1823-Find%20the%20Winner%20of%20the%20Circular%20Game/README_CN.md#1823-找出游戏的获胜者
 [1824]:Problemset/1824-Minimum%20Sideway%20Jumps/README_CN.md#1824-最少侧跳次数
+[1825]:Problemset/1825-Finding%20MK%20Average/README_CN.md#1825-求出-mk-平均值
 [1827]:Problemset/1827-Minimum%20Operations%20to%20Make%20the%20Array%20Increasing/README_CN.md#1827-最少操作使数组递增
 [1828]:Problemset/1828-Queries%20on%20Number%20of%20Points%20Inside%20a%20Circle/README_CN.md#1828-统计一个圆中点的数目
 [1829]:Problemset/1829-Maximum%20XOR%20for%20Each%20Query/README_CN.md#1829-每个查询的最大异或值
@@ -4127,6 +4129,7 @@
 [1822l]:https://leetcode.cn/problems/sign-of-the-product-of-an-array/
 [1823l]:https://leetcode.cn/problems/find-the-winner-of-the-circular-game/
 [1824l]:https://leetcode.cn/problems/minimum-sideway-jumps/
+[1825l]:https://leetcode.cn/problems/finding-mk-average/
 [1827l]:https://leetcode.cn/problems/minimum-operations-to-make-the-array-increasing/
 [1828l]:https://leetcode.cn/problems/queries-on-number-of-points-inside-a-circle/
 [1829l]:https://leetcode.cn/problems/maximum-xor-for-each-query/