feat: update solutions to lc/lcof2 problems

* lc No.0346 & lcof2 No.041. Moving Average from Data Stream

Author: yanglbme

lcof2/剑指 Offer II 041. 滑动窗口的平均值/README.md

@@ -50,7 +50,9 @@ movingAverage.next(5); // 返回 6.0 = (10 + 3 + 5) / 3
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“循环数组/队列”实现。
+**方法一：循环数组**
+
+**方法二：队列**
 
 <!-- tabs:start -->
 
@@ -62,21 +64,38 @@ movingAverage.next(5); // 返回 6.0 = (10 + 3 + 5) / 3
 class MovingAverage:
 
     def __init__(self, size: int):
-        """
-        Initialize your data structure here.
-        """
-        self.size = size
-        self.data = [0] * size
-        self.sum = 0
-        self.count = 0
+        self.arr = [0] * size
+        self.s = 0
+        self.cnt = 0
 
     def next(self, val: int) -> float:
-        idx = self.count % self.size
-        old_val = self.data[idx]
-        self.data[idx] = val
-        self.sum += val - old_val
-        self.count += 1
-        return self.sum / min(self.count, self.size)
+        idx = self.cnt % len(self.arr)
+        self.s += val - self.arr[idx]
+        self.arr[idx] = val
+        self.cnt += 1
+        return self.s / min(self.cnt, len(self.arr))
+
+
+# Your MovingAverage object will be instantiated and called as such:
+# obj = MovingAverage(size)
+# param_1 = obj.next(val)
+```
+
+```python
+class MovingAverage:
+
+    def __init__(self, size: int):
+        self.n = size
+        self.s = 0
+        self.q = deque()
+
+    def next(self, val: int) -> float:
+        if len(self.q) == self.n:
+            self.s -= self.q.popleft()
+        self.q.append(val)
+        self.s += val
+        return self.s / len(self.q)
+
 
 # Your MovingAverage object will be instantiated and called as such:
 # obj = MovingAverage(size)
@@ -89,24 +108,47 @@ class MovingAverage:
 
 ```java
 class MovingAverage {
-    private int size;
-    private int[] data;
-    private int sum;
-    private int count;
+    private int[] arr;
+    private int s;
+    private int cnt;
 
-    /** Initialize your data structure here. */
     public MovingAverage(int size) {
-        this.size = size;
-        this.data = new int[size];
+        arr = new int[size];
+    }
+    
+    public double next(int val) {
+        int idx = cnt % arr.length;
+        s += val - arr[idx];
+        arr[idx] = val;
+        ++cnt;
+        return s * 1.0 / Math.min(cnt, arr.length);
     }
+}
+
+/**
+ * Your MovingAverage object will be instantiated and called as such:
+ * MovingAverage obj = new MovingAverage(size);
+ * double param_1 = obj.next(val);
+ */
+```
 
+```java
+class MovingAverage {
+    private Deque<Integer> q = new ArrayDeque<>();
+    private int n;
+    private int s;
+
+    public MovingAverage(int size) {
+        n = size;
+    }
+    
     public double next(int val) {
-        int idx = count % size;
-        int oldVal = data[idx];
-        data[idx] = val;
-        sum += val - oldVal;
-        ++count;
-        return sum * 1.0 / Math.min(count, size);
+        if (q.size() == n) {
+            s -= q.pollFirst();
+        }
+        q.offer(val);
+        s += val;
+        return s * 1.0 / q.size();
     }
 }
 
@@ -122,26 +164,53 @@ class MovingAverage {
 ```cpp
 class MovingAverage {
 public:
-    /** Initialize your data structure here. */
     MovingAverage(int size) {
-        this->size = size;
-        data.resize(size);
+        arr.resize(size);
+    }
+    
+    double next(int val) {
+        int idx = cnt % arr.size();
+        s += val - arr[idx];
+        arr[idx] = val;
+        ++cnt;
+        return (double) s / min(cnt, (int) arr.size());
     }
 
+private:
+    vector<int> arr;
+    int cnt = 0;
+    int s = 0;
+};
+
+/**
+ * Your MovingAverage object will be instantiated and called as such:
+ * MovingAverage* obj = new MovingAverage(size);
+ * double param_1 = obj->next(val);
+ */
+```
+
+```cpp
+class MovingAverage {
+public:
+    MovingAverage(int size) {
+        n = size;
+    }
+    
     double next(int val) {
-        int idx = count % size;
-        int oldVal = data[idx];
-        data[idx] = val;
-        sum += val - oldVal;
-        ++count;
-        return (double) sum / min(count, size);
+        if (q.size() == n)
+        {
+            s -= q.front();
+            q.pop();
+        }
+        q.push(val);
+        s += val;
+        return (double) s / q.size();
     }
 
 private:
-    int size = 0;
-    vector<int> data;
-    int sum = 0;
-    int count = 0;
+    queue<int> q;
+    int s = 0;
+    int n;
 };
 
 /**
@@ -155,29 +224,22 @@ private:
 
 ```go
 type MovingAverage struct {
-	size  int
-	data  []int
-	sum   int
-	count int
+	arr []int
+	cnt int
+	s   int
 }
 
-/** Initialize your data structure here. */
 func Constructor(size int) MovingAverage {
-	return MovingAverage{
-		size:  size,
-		data:  make([]int, size),
-		sum:   0,
-		count: 0,
-	}
+	arr := make([]int, size)
+	return MovingAverage{arr, 0, 0}
 }
 
 func (this *MovingAverage) Next(val int) float64 {
-	idx := this.count % this.size
-	oldVal := this.data[idx]
-	this.data[idx] = val
-	this.sum += val - oldVal
-	this.count++
-	return float64(this.sum) / float64(min(this.count, this.size))
+	idx := this.cnt % len(this.arr)
+	this.s += val - this.arr[idx]
+	this.arr[idx] = val
+	this.cnt++
+	return float64(this.s) / float64(min(this.cnt, len(this.arr)))
 }
 
 func min(a, b int) int {
@@ -194,6 +256,34 @@ func min(a, b int) int {
  */
 ```
 
+```go
+type MovingAverage struct {
+	q []int
+	s int
+	n int
+}
+
+func Constructor(size int) MovingAverage {
+	return MovingAverage{n: size}
+}
+
+func (this *MovingAverage) Next(val int) float64 {
+	if len(this.q) == this.n {
+		this.s -= this.q[0]
+		this.q = this.q[1:]
+	}
+	this.q = append(this.q, val)
+	this.s += val
+	return float64(this.s) / float64(len(this.q))
+}
+
+/**
+ * Your MovingAverage object will be instantiated and called as such:
+ * obj := Constructor(size);
+ * param_1 := obj.Next(val);
+ */
+```
+
 ### **...**
 
 ```

lcof2/剑指 Offer II 041. 滑动窗口的平均值/Solution.cpp

@@ -1,25 +1,21 @@
 class MovingAverage {
 public:
-    /** Initialize your data structure here. */
     MovingAverage(int size) {
-        this->size = size;
-        data.resize(size);
+        arr.resize(size);
     }
 
     double next(int val) {
-        int idx = count % size;
-        int oldVal = data[idx];
-        data[idx] = val;
-        sum += val - oldVal;
-        ++count;
-        return (double) sum / min(count, size);
+        int idx = cnt % arr.size();
+        s += val - arr[idx];
+        arr[idx] = val;
+        ++cnt;
+        return (double) s / min(cnt, (int) arr.size());
     }
 
 private:
-    int size = 0;
-    vector<int> data;
-    int sum = 0;
-    int count = 0;
+    vector<int> arr;
+    int cnt = 0;
+    int s = 0;
 };
 
 /**

lcof2/剑指 Offer II 041. 滑动窗口的平均值/Solution.go

@@ -1,27 +1,20 @@
 type MovingAverage struct {
-	size  int
-	data  []int
-	sum   int
-	count int
+	arr []int
+	cnt int
+	s   int
 }
 
-/** Initialize your data structure here. */
 func Constructor(size int) MovingAverage {
-	return MovingAverage{
-		size:  size,
-		data:  make([]int, size),
-		sum:   0,
-		count: 0,
-	}
+	arr := make([]int, size)
+	return MovingAverage{arr, 0, 0}
 }
 
 func (this *MovingAverage) Next(val int) float64 {
-	idx := this.count % this.size
-	oldVal := this.data[idx]
-	this.data[idx] = val
-	this.sum += val - oldVal
-	this.count++
-	return float64(this.sum) / float64(min(this.count, this.size))
+	idx := this.cnt % len(this.arr)
+	this.s += val - this.arr[idx]
+	this.arr[idx] = val
+	this.cnt++
+	return float64(this.s) / float64(min(this.cnt, len(this.arr)))
 }
 
 func min(a, b int) int {

lcof2/剑指 Offer II 041. 滑动窗口的平均值/Solution.java

@@ -1,22 +1,18 @@
 class MovingAverage {
-    private int size;
-    private int[] data;
-    private int sum;
-    private int count;
+    private int[] arr;
+    private int s;
+    private int cnt;
 
-    /** Initialize your data structure here. */
     public MovingAverage(int size) {
-        this.size = size;
-        this.data = new int[size];
+        arr = new int[size];
     }
 
     public double next(int val) {
-        int idx = count % size;
-        int oldVal = data[idx];
-        data[idx] = val;
-        sum += val - oldVal;
-        ++count;
-        return sum * 1.0 / Math.min(count, size);
+        int idx = cnt % arr.length;
+        s += val - arr[idx];
+        arr[idx] = val;
+        ++cnt;
+        return s * 1.0 / Math.min(cnt, arr.length);
     }
 }