feat: add solutions to lc problem: No.1662

No.1662.Check If Two String Arrays are Equivalent

Author: YangFong

solution/1600-1699/1662.Check If Two String Arrays are Equivalent/README.md

@@ -184,31 +184,92 @@ func arrayStringsAreEqual(word1 []string, word2 []string) bool {
 }
 ```
 
+### **C**
+
+```c
+bool arrayStringsAreEqual(char **word1, int word1Size, char **word2, int word2Size) {
+    int i = 0;
+    int j = 0;
+    int x = 0;
+    int y = 0;
+    while (i < word1Size && j < word2Size) {
+        if (word1[i][x++] != word2[j][y++]) {
+            return 0;
+        }
+
+        if (word1[i][x] == '\0') {
+            x = 0;
+            i++;
+        }
+        if (word2[j][y] == '\0') {
+            y = 0;
+            j++;
+        }
+    }
+    return i == word1Size && j == word2Size;
+}
+```
+
 ### **TypeScript**
 
 ```ts
 function arrayStringsAreEqual(word1: string[], word2: string[]): boolean {
-    return word1.join('') == word2.join('');
+    return word1.join('') === word2.join('');
 }
 ```
 
 ```ts
 function arrayStringsAreEqual(word1: string[], word2: string[]): boolean {
     let [i, j, x, y] = [0, 0, 0, 0];
     while (i < word1.length && j < word2.length) {
-        if (word1[i][x++] != word2[j][y++]) {
+        if (word1[i][x++] !== word2[j][y++]) {
             return false;
         }
-        if (x == word1[i].length) {
+        if (x === word1[i].length) {
             x = 0;
             ++i;
         }
-        if (y == word2[j].length) {
+        if (y === word2[j].length) {
             y = 0;
             ++j;
         }
     }
-    return i == word1.length && j == word2.length;
+    return i === word1.length && j === word2.length;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn array_strings_are_equal(word1: Vec<String>, word2: Vec<String>) -> bool {
+        word1.join("") == word2.join("")
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn array_strings_are_equal(word1: Vec<String>, word2: Vec<String>) -> bool {
+        let (n, m) = (word1.len(), word2.len());
+        let (mut i, mut j, mut x, mut y) = (0, 0, 0, 0);
+        while i < n && j < m {
+            if word1[i].as_bytes()[x] != word2[j].as_bytes()[y] {
+                return false;
+            }
+            x += 1;
+            y += 1;
+            if x == word1[i].len() {
+                x = 0;
+                i += 1;
+            }
+            if y == word2[j].len() {
+                y = 0;
+                j += 1;
+            }
+        }
+        i == n && j == m
+    }
 }
 ```
 

solution/1600-1699/1662.Check If Two String Arrays are Equivalent/README_EN.md

@@ -156,31 +156,92 @@ func arrayStringsAreEqual(word1 []string, word2 []string) bool {
 }
 ```
 
+### **C**
+
+```c
+bool arrayStringsAreEqual(char **word1, int word1Size, char **word2, int word2Size) {
+    int i = 0;
+    int j = 0;
+    int x = 0;
+    int y = 0;
+    while (i < word1Size && j < word2Size) {
+        if (word1[i][x++] != word2[j][y++]) {
+            return 0;
+        }
+
+        if (word1[i][x] == '\0') {
+            x = 0;
+            i++;
+        }
+        if (word2[j][y] == '\0') {
+            y = 0;
+            j++;
+        }
+    }
+    return i == word1Size && j == word2Size;
+}
+```
+
 ### **TypeScript**
 
 ```ts
 function arrayStringsAreEqual(word1: string[], word2: string[]): boolean {
-    return word1.join('') == word2.join('');
+    return word1.join('') === word2.join('');
 }
 ```
 
 ```ts
 function arrayStringsAreEqual(word1: string[], word2: string[]): boolean {
     let [i, j, x, y] = [0, 0, 0, 0];
     while (i < word1.length && j < word2.length) {
-        if (word1[i][x++] != word2[j][y++]) {
+        if (word1[i][x++] !== word2[j][y++]) {
             return false;
         }
-        if (x == word1[i].length) {
+        if (x === word1[i].length) {
             x = 0;
             ++i;
         }
-        if (y == word2[j].length) {
+        if (y === word2[j].length) {
             y = 0;
             ++j;
         }
     }
-    return i == word1.length && j == word2.length;
+    return i === word1.length && j === word2.length;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn array_strings_are_equal(word1: Vec<String>, word2: Vec<String>) -> bool {
+        word1.join("") == word2.join("")
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn array_strings_are_equal(word1: Vec<String>, word2: Vec<String>) -> bool {
+        let (n, m) = (word1.len(), word2.len());
+        let (mut i, mut j, mut x, mut y) = (0, 0, 0, 0);
+        while i < n && j < m {
+            if word1[i].as_bytes()[x] != word2[j].as_bytes()[y] {
+                return false;
+            }
+            x += 1;
+            y += 1;
+            if x == word1[i].len() {
+                x = 0;
+                i += 1;
+            }
+            if y == word2[j].len() {
+                y = 0;
+                j += 1;
+            }
+        }
+        i == n && j == m
+    }
 }
 ```
 

solution/1600-1699/1662.Check If Two String Arrays are Equivalent/Solution.c

@@ -0,0 +1,21 @@
+bool arrayStringsAreEqual(char **word1, int word1Size, char **word2, int word2Size) {
+    int i = 0;
+    int j = 0;
+    int x = 0;
+    int y = 0;
+    while (i < word1Size && j < word2Size) {
+        if (word1[i][x++] != word2[j][y++]) {
+            return 0;
+        }
+
+        if (word1[i][x] == '\0') {
+            x = 0;
+            i++;
+        }
+        if (word2[j][y] == '\0') {
+            y = 0;
+            j++;
+        }
+    }
+    return i == word1Size && j == word2Size;
+}

solution/1600-1699/1662.Check If Two String Arrays are Equivalent/Solution.rs

@@ -0,0 +1,5 @@
+impl Solution {
+    pub fn array_strings_are_equal(word1: Vec<String>, word2: Vec<String>) -> bool {
+        word1.join("") == word2.join("")
+    }
+}

solution/1600-1699/1662.Check If Two String Arrays are Equivalent/Solution.ts

@@ -1,3 +1,3 @@
 function arrayStringsAreEqual(word1: string[], word2: string[]): boolean {
-    return word1.join('') == word2.join('');
+    return word1.join('') === word2.join('');
 }