feat: add solutions to lc problem: No.1640

No.1640.Check Array Formation Through Concatenation

Author: YangFong

solution/1600-1699/1640.Check Array Formation Through Concatenation/README.md

@@ -188,6 +188,59 @@ var canFormArray = function (arr, pieces) {
 };
 ```
 
+### **TypeScript**
+
+```ts
+function canFormArray(arr: number[], pieces: number[][]): boolean {
+    const n = arr.length;
+    let i = 0;
+    while (i < n) {
+        const target = arr[i];
+        const items = pieces.find(v => v[0] === target);
+        if (items == null) {
+            return false;
+        }
+        for (const item of items) {
+            if (item !== arr[i]) {
+                return false;
+            }
+            i++;
+        }
+    }
+    return true;
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+impl Solution {
+    pub fn can_form_array(arr: Vec<i32>, pieces: Vec<Vec<i32>>) -> bool {
+        let n = arr.len();
+        let mut map = HashMap::new();
+        for (i, v) in pieces.iter().enumerate() {
+            map.insert(v[0], i);
+        }
+        let mut i = 0;
+        while i < n {
+            match map.get(&arr[i]) {
+                None => return false,
+                Some(&j) => {
+                    for &item in pieces[j].iter() {
+                        if item != arr[i] {
+                            return false;
+                        }
+                        i += 1;
+                    }
+                }
+            }
+        }
+        true
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1640.Check Array Formation Through Concatenation/README_EN.md

@@ -169,6 +169,59 @@ var canFormArray = function (arr, pieces) {
 };
 ```
 
+### **TypeScript**
+
+```ts
+function canFormArray(arr: number[], pieces: number[][]): boolean {
+    const n = arr.length;
+    let i = 0;
+    while (i < n) {
+        const target = arr[i];
+        const items = pieces.find(v => v[0] === target);
+        if (items == null) {
+            return false;
+        }
+        for (const item of items) {
+            if (item !== arr[i]) {
+                return false;
+            }
+            i++;
+        }
+    }
+    return true;
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+impl Solution {
+    pub fn can_form_array(arr: Vec<i32>, pieces: Vec<Vec<i32>>) -> bool {
+        let n = arr.len();
+        let mut map = HashMap::new();
+        for (i, v) in pieces.iter().enumerate() {
+            map.insert(v[0], i);
+        }
+        let mut i = 0;
+        while i < n {
+            match map.get(&arr[i]) {
+                None => return false,
+                Some(&j) => {
+                    for &item in pieces[j].iter() {
+                        if item != arr[i] {
+                            return false;
+                        }
+                        i += 1;
+                    }
+                }
+            }
+        }
+        true
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1640.Check Array Formation Through Concatenation/Solution.rs

@@ -0,0 +1,25 @@
+use std::collections::HashMap;
+impl Solution {
+    pub fn can_form_array(arr: Vec<i32>, pieces: Vec<Vec<i32>>) -> bool {
+        let n = arr.len();
+        let mut map = HashMap::new();
+        for (i, v) in pieces.iter().enumerate() {
+            map.insert(v[0], i);
+        }
+        let mut i = 0;
+        while i < n {
+            match map.get(&arr[i]) {
+                None => return false,
+                Some(&j) => {
+                    for &item in pieces[j].iter() {
+                        if item != arr[i] {
+                            return false;
+                        }
+                        i += 1;
+                    }
+                }
+            }
+        }
+        true
+    }
+}

solution/1600-1699/1640.Check Array Formation Through Concatenation/Solution.ts

@@ -0,0 +1,18 @@
+function canFormArray(arr: number[], pieces: number[][]): boolean {
+    const n = arr.length;
+    let i = 0;
+    while (i < n) {
+        const target = arr[i];
+        const items = pieces.find(v => v[0] === target);
+        if (items == null) {
+            return false;
+        }
+        for (const item of items) {
+            if (item !== arr[i]) {
+                return false;
+            }
+            i++;
+        }
+    }
+    return true;
+}