feat: add solutions to lc problem: No.0290

No.0290.Word Pattern

Author: YangFong

solution/0200-0299/0290.Word Pattern/README.md

@@ -124,6 +124,32 @@ function wordPattern(pattern: string, s: string): boolean {
 }
 ```
 
+```ts
+function wordPattern(pattern: string, s: string): boolean {
+    const n = pattern.length;
+    const cs = s.split(' ');
+    if (n !== cs.length) {
+        return false;
+    }
+    const map1 = new Map<string, number>();
+    const map2 = new Map<string, number>();
+    for (let i = 0; i < n; i++) {
+        const c1 = pattern[i];
+        const c2 = cs[i];
+        if (!map1.has(c1)) {
+            map1.set(c1, i);
+        }
+        if (!map2.has(c2)) {
+            map2.set(c2, i);
+        }
+        if (map1.get(c1) !== map2.get(c2)) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -177,6 +203,39 @@ func wordPattern(pattern string, s string) bool {
 }
 ```
 
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn word_pattern(pattern: String, s: String) -> bool {
+        let cs1: Vec<char> = pattern.chars().collect();
+        let cs2: Vec<&str> = s.split_whitespace().collect();
+        let n = cs1.len();
+        if n != cs2.len() {
+            return false;
+        }
+        let mut map1 = HashMap::new();
+        let mut map2 = HashMap::new();
+        for i in 0..n {
+            let c = cs1[i];
+            let s = cs2[i];
+            if !map1.contains_key(&c) {
+                map1.insert(c, i);
+            }
+            if !map2.contains_key(&s) {
+                map2.insert(s, i);
+            }
+            if map1.get(&c) != map2.get(&s) {
+                return false
+            }
+        }
+        true
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0290.Word Pattern/README_EN.md

@@ -117,6 +117,32 @@ function wordPattern(pattern: string, s: string): boolean {
 }
 ```
 
+```ts
+function wordPattern(pattern: string, s: string): boolean {
+    const n = pattern.length;
+    const cs = s.split(' ');
+    if (n !== cs.length) {
+        return false;
+    }
+    const map1 = new Map<string, number>();
+    const map2 = new Map<string, number>();
+    for (let i = 0; i < n; i++) {
+        const c1 = pattern[i];
+        const c2 = cs[i];
+        if (!map1.has(c1)) {
+            map1.set(c1, i);
+        }
+        if (!map2.has(c2)) {
+            map2.set(c2, i);
+        }
+        if (map1.get(c1) !== map2.get(c2)) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -170,6 +196,39 @@ func wordPattern(pattern string, s string) bool {
 }
 ```
 
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn word_pattern(pattern: String, s: String) -> bool {
+        let cs1: Vec<char> = pattern.chars().collect();
+        let cs2: Vec<&str> = s.split_whitespace().collect();
+        let n = cs1.len();
+        if n != cs2.len() {
+            return false;
+        }
+        let mut map1 = HashMap::new();
+        let mut map2 = HashMap::new();
+        for i in 0..n {
+            let c = cs1[i];
+            let s = cs2[i];
+            if !map1.contains_key(&c) {
+                map1.insert(c, i);
+            }
+            if !map2.contains_key(&s) {
+                map2.insert(s, i);
+            }
+            if map1.get(&c) != map2.get(&s) {
+                return false
+            }
+        }
+        true
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0290.Word Pattern/Solution.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn word_pattern(pattern: String, s: String) -> bool {
+        let cs1: Vec<char> = pattern.chars().collect();
+        let cs2: Vec<&str> = s.split_whitespace().collect();
+        let n = cs1.len();
+        if n != cs2.len() {
+            return false;
+        }
+        let mut map1 = HashMap::new();
+        let mut map2 = HashMap::new();
+        for i in 0..n {
+            let c = cs1[i];
+            let s = cs2[i];
+            if !map1.contains_key(&c) {
+                map1.insert(c, i);
+            }
+            if !map2.contains_key(&s) {
+                map2.insert(s, i);
+            }
+            if map1.get(&c) != map2.get(&s) {
+                return false
+            }
+        }
+        true
+    }
+}