feat: add solutions to lc problem: No.1656

No.1656.Design an Ordered Stream

Author: YangFong

solution/1600-1699/1656.Design an Ordered Stream/README.md

@@ -177,6 +177,75 @@ func (this *OrderedStream) Insert(idKey int, value string) []string {
  */
 ```
 
+### **TypeScript**
+
+```ts
+class OrderedStream {
+    private ptr: number;
+    private vals: string[];
+
+    constructor(n: number) {
+        this.ptr = 0;
+        this.vals = new Array(n);
+    }
+
+    insert(idKey: number, value: string): string[] {
+        this.vals[idKey - 1] = value;
+        const res = [];
+        while (this.vals[this.ptr] != null) {
+            res.push(this.vals[this.ptr]);
+            this.ptr++;
+        }
+        return res;
+    }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * var obj = new OrderedStream(n)
+ * var param_1 = obj.insert(idKey,value)
+ */
+```
+
+### **Rust**
+
+```rust
+struct OrderedStream {
+    ptr: usize,
+    vals: Vec<Option<String>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl OrderedStream {
+    fn new(n: i32) -> Self {
+        Self { ptr: 0, vals: vec![None; n as usize] }
+    }
+
+    fn insert(&mut self, id_key: i32, value: String) -> Vec<String> {
+        self.vals[(id_key - 1) as usize] = Some(value);
+        let mut res = Vec::new();
+        while self.ptr < self.vals.len() {
+            if let Some(s) = &self.vals[self.ptr] {
+                res.push(s.clone());
+                self.ptr += 1;
+            } else {
+                break;
+            }
+        }
+        res
+    }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * let obj = OrderedStream::new(n);
+ * let ret_1: Vec<String> = obj.insert(idKey, value);
+ */
+```
+
 ### **...**
 
 ```

solution/1600-1699/1656.Design an Ordered Stream/README_EN.md

@@ -164,6 +164,75 @@ func (this *OrderedStream) Insert(idKey int, value string) []string {
  */
 ```
 
+### **TypeScript**
+
+```ts
+class OrderedStream {
+    private ptr: number;
+    private vals: string[];
+
+    constructor(n: number) {
+        this.ptr = 0;
+        this.vals = new Array(n);
+    }
+
+    insert(idKey: number, value: string): string[] {
+        this.vals[idKey - 1] = value;
+        const res = [];
+        while (this.vals[this.ptr] != null) {
+            res.push(this.vals[this.ptr]);
+            this.ptr++;
+        }
+        return res;
+    }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * var obj = new OrderedStream(n)
+ * var param_1 = obj.insert(idKey,value)
+ */
+```
+
+### **Rust**
+
+```rust
+struct OrderedStream {
+    ptr: usize,
+    vals: Vec<Option<String>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl OrderedStream {
+    fn new(n: i32) -> Self {
+        Self { ptr: 0, vals: vec![None; n as usize] }
+    }
+
+    fn insert(&mut self, id_key: i32, value: String) -> Vec<String> {
+        self.vals[(id_key - 1) as usize] = Some(value);
+        let mut res = Vec::new();
+        while self.ptr < self.vals.len() {
+            if let Some(s) = &self.vals[self.ptr] {
+                res.push(s.clone());
+                self.ptr += 1;
+            } else {
+                break;
+            }
+        }
+        res
+    }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * let obj = OrderedStream::new(n);
+ * let ret_1: Vec<String> = obj.insert(idKey, value);
+ */
+```
+
 ### **...**
 
 ```

solution/1600-1699/1656.Design an Ordered Stream/Solution.rs

@@ -0,0 +1,34 @@
+struct OrderedStream {
+    ptr: usize,
+    vals: Vec<Option<String>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl OrderedStream {
+    fn new(n: i32) -> Self {
+        Self { ptr: 0, vals: vec![None; n as usize] }
+    }
+
+    fn insert(&mut self, id_key: i32, value: String) -> Vec<String> {
+        self.vals[(id_key - 1) as usize] = Some(value);
+        let mut res = Vec::new();
+        while self.ptr < self.vals.len() {
+            if let Some(s) = &self.vals[self.ptr] {
+                res.push(s.clone());
+                self.ptr += 1;
+            } else {
+                break;
+            }
+        }
+        res
+    }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * let obj = OrderedStream::new(n);
+ * let ret_1: Vec<String> = obj.insert(idKey, value);
+ */

solution/1600-1699/1656.Design an Ordered Stream/Solution.ts

@@ -0,0 +1,25 @@
+class OrderedStream {
+    private ptr: number;
+    private vals: string[];
+
+    constructor(n: number) {
+        this.ptr = 0;
+        this.vals = new Array(n);
+    }
+
+    insert(idKey: number, value: string): string[] {
+        this.vals[idKey - 1] = value;
+        const res = [];
+        while (this.vals[this.ptr] != null) {
+            res.push(this.vals[this.ptr]);
+            this.ptr++;
+        }
+        return res;
+    }
+}
+
+/**
+ * Your OrderedStream object will be instantiated and called as such:
+ * var obj = new OrderedStream(n)
+ * var param_1 = obj.insert(idKey,value)
+ */