feat: add solutions to lc problem: No.0346

solution/0300-0399/0346.Moving Average from Data Stream/README.md

@@ -65,23 +65,30 @@ movingAverage.next(5); // 返回 6.0 = (10 + 3 + 5) / 3
 
 ### 方法一：循环数组
 
+我们定义一个变量 $\textit{s}$，用于计算当前最后 $\textit{size}$ 个元素的和，用一个变量 $\textit{cnt}$ 记录当前元素的总数。另外，我们用一个长度为 $\textit{size}$ 的数组 $\textit{data}$ 记录每个位置的元素对应的值。
+
+调用 $\textit{next}$ 函数时，我们先计算出 $\textit{val}$ 要存放的下标 $i$，然后我们更新元素和 $s$，并且将下标 $i$ 处的值设置为 $\textit{val}$，同时将元素的个数加一。最后，我们返回 $\frac{s}{\min(\textit{cnt}, \textit{size})}$ 的值即可。
+
+时间复杂度 $O(1)$，空间复杂度 $O(n)$，其中 $n$ 是题目给定的整数 $\textit{size}$。
+
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
 class MovingAverage:
+
     def __init__(self, size: int):
-        self.arr = [0] * size
         self.s = 0
+        self.data = [0] * size
         self.cnt = 0
 
     def next(self, val: int) -> float:
-        idx = self.cnt % len(self.arr)
-        self.s += val - self.arr[idx]
-        self.arr[idx] = val
+        i = self.cnt % len(self.data)
+        self.s += val - self.data[i]
+        self.data[i] = val
         self.cnt += 1
-        return self.s / min(self.cnt, len(self.arr))
+        return self.s / min(self.cnt, len(self.data))
 
 
 # Your MovingAverage object will be instantiated and called as such:
@@ -93,20 +100,20 @@ class MovingAverage:
 
 ```java
 class MovingAverage {
-    private int[] arr;
     private int s;
     private int cnt;
+    private int[] data;
 
     public MovingAverage(int size) {
-        arr = new int[size];
+        data = new int[size];
     }
 
     public double next(int val) {
-        int idx = cnt % arr.length;
-        s += val - arr[idx];
-        arr[idx] = val;
+        int i = cnt % data.length;
+        s += val - data[i];
+        data[i] = val;
         ++cnt;
-        return s * 1.0 / Math.min(cnt, arr.length);
+        return s * 1.0 / Math.min(cnt, data.length);
     }
 }
 
@@ -123,21 +130,21 @@ class MovingAverage {
 class MovingAverage {
 public:
     MovingAverage(int size) {
-        arr.resize(size);
+        data.resize(size);
     }
 
     double next(int val) {
-        int idx = cnt % arr.size();
-        s += val - arr[idx];
-        arr[idx] = val;
+        int i = cnt % data.size();
+        s += val - data[i];
+        data[i] = val;
         ++cnt;
-        return (double) s / min(cnt, (int) arr.size());
+        return s * 1.0 / min(cnt, (int) data.size());
     }
 
 private:
-    vector<int> arr;
-    int cnt = 0;
     int s = 0;
+    int cnt = 0;
+    vector<int> data;
 };
 
 /**
@@ -151,22 +158,23 @@ private:
 
 ```go
 type MovingAverage struct {
-	arr []int
-	cnt int
-	s   int
+	s    int
+	cnt  int
+	data []int
 }
 
 func Constructor(size int) MovingAverage {
-	arr := make([]int, size)
-	return MovingAverage{arr, 0, 0}
+	return MovingAverage{
+		data: make([]int, size),
+	}
 }
 
 func (this *MovingAverage) Next(val int) float64 {
-	idx := this.cnt % len(this.arr)
-	this.s += val - this.arr[idx]
-	this.arr[idx] = val
+	i := this.cnt % len(this.data)
+	this.s += val - this.data[i]
+	this.data[i] = val
 	this.cnt++
-	return float64(this.s) / float64(min(this.cnt, len(this.arr)))
+	return float64(this.s) / float64(min(this.cnt, len(this.data)))
 }
 
 /**
@@ -176,6 +184,34 @@ func (this *MovingAverage) Next(val int) float64 {
  */
 ```
 
+#### TypeScript
+
+```ts
+class MovingAverage {
+    private s: number = 0;
+    private cnt: number = 0;
+    private data: number[];
+
+    constructor(size: number) {
+        this.data = Array(size).fill(0);
+    }
+
+    next(val: number): number {
+        const i = this.cnt % this.data.length;
+        this.s += val - this.data[i];
+        this.data[i] = val;
+        this.cnt++;
+        return this.s / Math.min(this.cnt, this.data.length);
+    }
+}
+
+/**
+ * Your MovingAverage object will be instantiated and called as such:
+ * var obj = new MovingAverage(size)
+ * var param_1 = obj.next(val)
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
@@ -184,6 +220,12 @@ func (this *MovingAverage) Next(val int) float64 {
 
 ### 方法二：队列
 
+我们可以使用一个队列 $\textit{q}$ 来存储最后 $\textit{size}$ 个元素，同时用一个变量 $\textit{s}$ 来记录这 $\textit{size}$ 个元素的和。
+
+在调用 $\textit{next}$ 函数时，我们首先判断队列 $\textit{q}$ 的长度是否等于 $\textit{size}$，如果等于 $\textit{size}$，则将队列 $\textit{q}$ 的头部元素出队，并且更新 $\textit{s}$ 的值。然后将 $\textit{val}$ 入队，并且更新 $\textit{s}$ 的值。最后返回 $\frac{s}{\text{len}(q)}$ 的值即可。
+
+时间复杂度 $O(1)$，空间复杂度 $O(n)$，其中 $n$ 是题目给定的整数 $\textit{size}$。
+
 <!-- tabs:start -->
 
 #### Python3
@@ -299,6 +341,35 @@ func (this *MovingAverage) Next(val int) float64 {
  */
 ```
 
+#### TypeScript
+
+```ts
+class MovingAverage {
+    private q: number[] = [];
+    private s: number = 0;
+    private n: number;
+
+    constructor(size: number) {
+        this.n = size;
+    }
+
+    next(val: number): number {
+        if (this.q.length === this.n) {
+            this.s -= this.q.shift()!;
+        }
+        this.q.push(val);
+        this.s += val;
+        return this.s / this.q.length;
+    }
+}
+
+/**
+ * Your MovingAverage object will be instantiated and called as such:
+ * var obj = new MovingAverage(size)
+ * var param_1 = obj.next(val)
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->