feat: add solutions to lc problem: No.1093

No.1093.Statistics from a Large Sample

Author: yanglbme

solution/1000-1099/1091.Shortest Path in Binary Matrix/README.md

@@ -229,7 +229,7 @@ function shortestPathBinaryMatrix(grid: number[][]): number {
         q = nq;
     }
     return -1;
-};
+}
 ```
 
 ### **Rust**

solution/1000-1099/1091.Shortest Path in Binary Matrix/README_EN.md

@@ -207,7 +207,7 @@ function shortestPathBinaryMatrix(grid: number[][]): number {
         q = nq;
     }
     return -1;
-};
+}
 ```
 
 ### **Rust**

solution/1000-1099/1093.Statistics from a Large Sample/README.md

@@ -65,22 +65,216 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：模拟**
+
+我们直接根据题目描述模拟即可，定义以下变量：
+
+- 变量 $mi$ 表示最小值；
+- 变量 $mx$ 表示最大值；
+- 变量 $s$ 表示总和；
+- 变量 $cnt$ 表示总个数；
+- 变量 $mode$ 表示众数。
+
+我们遍历数组 $count$，对于当前遍历到的数字 $count[k]$，如果 $count[k] \gt 0$，那么我们做以下更新操作：
+
+- 更新 $mi = \min(mi, k)$；
+- 更新 $mx = \max(mx, k)$；
+- 更新 $s = s + k \times count[k]$；
+- 更新 $cnt = cnt + count[k]$；
+- 如果 $count[k] \gt count[mode]$，那么更新 $mode = k$。
+
+遍历结束后，我们再根据 $cnt$ 的奇偶性来更新中位数 $median$，如果 $cnt$ 是奇数，那么中位数就是第 $\lfloor \frac{cnt}{2} \rfloor + 1$ 个数字，如果 $cnt$ 是偶数，那么中位数就是第 $\lfloor \frac{cnt}{2} \rfloor$ 和第 $\lfloor \frac{cnt}{2} \rfloor + 1$ 个数字的平均值。
+
+最后，我们将 $mi, mx, \frac{s}{cnt}, median, mode$ 放入答案数组中返回即可。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组 $count$ 的长度。空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def sampleStats(self, count: List[int]) -> List[float]:
+        def find(i: int) -> int:
+            t = 0
+            for k, x in enumerate(count):
+                t += x
+                if t >= i:
+                    return k
+
+        mi, mx = inf, -1
+        s = cnt = 0
+        mode = 0
+        for k, x in enumerate(count):
+            if x:
+                mi = min(mi, k)
+                mx = max(mx, k)
+                s += k * x
+                cnt += x
+                if x > count[mode]:
+                    mode = k
 
+        median = (
+            find(cnt // 2 + 1) if cnt & 1 else (find(cnt // 2) + find(cnt // 2 + 1)) / 2
+        )
+        return [mi, mx, s / cnt, median, mode]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[] count;
+
+    public double[] sampleStats(int[] count) {
+        this.count = count;
+        int mi = 1 << 30, mx = -1;
+        long s = 0;
+        int cnt = 0;
+        int mode = 0;
+        for (int k = 0; k < count.length; ++k) {
+            if (count[k] > 0) {
+                mi = Math.min(mi, k);
+                mx = Math.max(mx, k);
+                s += 1L * k * count[k];
+                cnt += count[k];
+                if (count[k] > count[mode]) {
+                    mode = k;
+                }
+            }
+        }
+        double median = cnt % 2 == 1 ? find(cnt / 2 + 1) : (find(cnt / 2) + find(cnt / 2 + 1)) / 2.0;
+        return new double[]{mi, mx, s * 1.0 / cnt, median, mode};
+    }
+
+    private int find(int i) {
+        for (int k = 0, t = 0;; ++k) {
+            t += count[k];
+            if (t >= i) {
+                return k;
+            }
+        }
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<double> sampleStats(vector<int>& count) {
+        auto find = [&](int i) -> int {
+            for (int k = 0, t = 0;; ++k) {
+                t += count[k];
+                if (t >= i) {
+                    return k;
+                }
+            }
+        };
+        int mi = 1 << 30, mx = -1;
+        long long s = 0;
+        int cnt = 0, mode = 0;
+        for (int k = 0; k < count.size(); ++k) {
+            if (count[k]) {
+                mi = min(mi, k);
+                mx = max(mx, k);
+                s += 1LL * k * count[k];
+                cnt += count[k];
+                if (count[k] > count[mode]) {
+                    mode = k;
+                }
+            }
+        }
+        double median = cnt % 2 == 1 ? find(cnt / 2 + 1) : (find(cnt / 2) + find(cnt / 2 + 1)) / 2.0;
+        return vector<double>{(double) mi, (double) mx, s * 1.0 / cnt, median, (double) mode};
+    }
+};
+```
+
+### **Go**
+
+```go
+func sampleStats(count []int) []float64 {
+	find := func(i int) int {
+		for k, t := 0, 0; ; k++ {
+			t += count[k]
+			if t >= i {
+				return k
+			}
+		}
+	}
+	mi, mx := 1<<30, -1
+	s, cnt, mode := 0, 0, 0
+	for k, x := range count {
+		if x > 0 {
+			mi = min(mi, k)
+			mx = max(mx, k)
+			s += k * x
+			cnt += x
+			if x > count[mode] {
+				mode = k
+			}
+		}
+	}
+	var median float64
+	if cnt&1 == 1 {
+		median = float64(find(cnt/2 + 1))
+	} else {
+		median = float64(find(cnt/2)+find(cnt/2+1)) / 2
+	}
+	return []float64{float64(mi), float64(mx), float64(s) / float64(cnt), median, float64(mode)}
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+### **TypeScript**
 
+```ts
+function sampleStats(count: number[]): number[] {
+    const find = (i: number): number => {
+        for (let k = 0, t = 0; ; ++k) {
+            t += count[k];
+            if (t >= i) {
+                return k;
+            }
+        }
+    }
+    let mi = 1 << 30;
+    let mx = -1;
+    let [s, cnt, mode] = [0, 0, 0];
+    for (let k = 0; k < count.length; ++k) {
+        if (count[k] > 0) {
+            mi = Math.min(mi, k);
+            mx = Math.max(mx, k);
+            s += k * count[k];
+            cnt += count[k];
+            if (count[k] > count[mode]) {
+                mode = k;
+            }
+        }
+    }
+    const median = cnt % 2 === 1 ? find((cnt >> 1) + 1) : (find(cnt >> 1) + find((cnt >> 1) + 1)) / 2;
+    return [mi, mx, s / cnt, median, mode];
+};
 ```
 
 ### **...**