diff --git a/solution/0100-0199/0125.Valid Palindrome/README.md b/solution/0100-0199/0125.Valid Palindrome/README.md
index df5c35260486a..d9c1db7f8393a 100644
--- a/solution/0100-0199/0125.Valid Palindrome/README.md	
+++ b/solution/0100-0199/0125.Valid Palindrome/README.md	
@@ -118,7 +118,81 @@ private:
 };
 ```
 
-### **tTypeScript**
+### **C#**
+
+```cs
+using System.Linq;
+
+public class Solution {
+    public bool IsPalindrome(string s) {
+        var chars = s.Where(ch => char.IsLetterOrDigit(ch)).Select(char.ToLower).ToList();
+        var i = 0;
+        var j = chars.Count - 1;
+        for (; i < j; ++i, --j)
+        {
+            if (chars[i] != chars[j]) return false;
+        }
+        return true;
+    }
+}
+```
+
+### **JavaScript**
+
+```js
+const isPalindrome1 = function (s) {
+    let arr1 = [],
+        arr2 = [];
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] >= 'A' && s[i] <= 'Z') {
+            arr1.push(s[i].toLowerCase());
+        }
+        if ((s[i] >= '0' && s[i] <= '9') || (s[i] >= 'a' && s[i] <= 'z')) {
+            arr1.push(s[i]);
+        }
+    }
+    arr2 = [...arr1];
+    arr2.reverse();
+    return arr1.join('') === arr2.join('');
+};
+
+const isPalindrome = function (s) {
+    function isNumOrAl(a) {
+        if (
+            (a >= 'A' && a <= 'Z') ||
+            (a >= '0' && a <= '9') ||
+            (a >= 'a' && a <= 'z')
+        ) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    if (s.length === 0) {
+        return true;
+    }
+    let i = 0,
+        j = s.length - 1;
+    while (i < j) {
+        while (i < j && !isNumOrAl(s[i])) {
+            i++;
+        }
+        while (i < j && !isNumOrAl(s[j])) {
+            j--;
+        }
+        if (s[i].toLowerCase() !== s[j].toLowerCase()) {
+            return false;
+        } else {
+            i++;
+            j--;
+        }
+    }
+    return true;
+};
+```
+
+### **TypeScript**
 
 ```ts
 function isPalindrome(s: string): boolean {
@@ -142,6 +216,35 @@ function isPalindrome(s: string): boolean {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn is_palindrome(s: String) -> bool {
+        let s = s.to_lowercase();
+        let s = s.as_bytes();
+        let n = s.len();
+        let (mut l, mut r) = (0, n - 1);
+        while l < r {
+            while l < r && !s[l].is_ascii_alphanumeric() {
+                l += 1;
+            }
+            while l < r && !s[r].is_ascii_alphanumeric() {
+                r -= 1;
+            }
+            if s[l] != s[r] {
+                return false;
+            }
+            l += 1;
+            if r != 0 {
+                r -= 1;
+            }
+        }
+        true
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0100-0199/0125.Valid Palindrome/README_EN.md b/solution/0100-0199/0125.Valid Palindrome/README_EN.md
index 630db18c094cc..6bb2e8cb201da 100644
--- a/solution/0100-0199/0125.Valid Palindrome/README_EN.md	
+++ b/solution/0100-0199/0125.Valid Palindrome/README_EN.md	
@@ -117,6 +117,80 @@ private:
 };
 ```
 
+### **C#**
+
+```cs
+using System.Linq;
+
+public class Solution {
+    public bool IsPalindrome(string s) {
+        var chars = s.Where(ch => char.IsLetterOrDigit(ch)).Select(char.ToLower).ToList();
+        var i = 0;
+        var j = chars.Count - 1;
+        for (; i < j; ++i, --j)
+        {
+            if (chars[i] != chars[j]) return false;
+        }
+        return true;
+    }
+}
+```
+
+### **JavaScript**
+
+```js
+const isPalindrome1 = function (s) {
+    let arr1 = [],
+        arr2 = [];
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] >= 'A' && s[i] <= 'Z') {
+            arr1.push(s[i].toLowerCase());
+        }
+        if ((s[i] >= '0' && s[i] <= '9') || (s[i] >= 'a' && s[i] <= 'z')) {
+            arr1.push(s[i]);
+        }
+    }
+    arr2 = [...arr1];
+    arr2.reverse();
+    return arr1.join('') === arr2.join('');
+};
+
+const isPalindrome = function (s) {
+    function isNumOrAl(a) {
+        if (
+            (a >= 'A' && a <= 'Z') ||
+            (a >= '0' && a <= '9') ||
+            (a >= 'a' && a <= 'z')
+        ) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    if (s.length === 0) {
+        return true;
+    }
+    let i = 0,
+        j = s.length - 1;
+    while (i < j) {
+        while (i < j && !isNumOrAl(s[i])) {
+            i++;
+        }
+        while (i < j && !isNumOrAl(s[j])) {
+            j--;
+        }
+        if (s[i].toLowerCase() !== s[j].toLowerCase()) {
+            return false;
+        } else {
+            i++;
+            j--;
+        }
+    }
+    return true;
+};
+```
+
 ### **TypeScript**
 
 ```ts
@@ -141,6 +215,35 @@ function isPalindrome(s: string): boolean {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn is_palindrome(s: String) -> bool {
+        let s = s.to_lowercase();
+        let s = s.as_bytes();
+        let n = s.len();
+        let (mut l, mut r) = (0, n - 1);
+        while l < r {
+            while l < r && !s[l].is_ascii_alphanumeric() {
+                l += 1;
+            }
+            while l < r && !s[r].is_ascii_alphanumeric() {
+                r -= 1;
+            }
+            if s[l] != s[r] {
+                return false;
+            }
+            l += 1;
+            if r != 0 {
+                r -= 1;
+            }
+        }
+        true
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0100-0199/0125.Valid Palindrome/Solution.rs b/solution/0100-0199/0125.Valid Palindrome/Solution.rs
new file mode 100644
index 0000000000000..43bad4945eb9a
--- /dev/null
+++ b/solution/0100-0199/0125.Valid Palindrome/Solution.rs	
@@ -0,0 +1,24 @@
+impl Solution {
+    pub fn is_palindrome(s: String) -> bool {
+        let s = s.to_lowercase();
+        let s = s.as_bytes();
+        let n = s.len();
+        let (mut l, mut r) = (0, n - 1);
+        while l < r {
+            while l < r && !s[l].is_ascii_alphanumeric() {
+                l += 1;
+            }
+            while l < r && !s[r].is_ascii_alphanumeric() {
+                r -= 1;
+            }
+            if s[l] != s[r] {
+                return false;
+            }
+            l += 1;
+            if r != 0 {
+                r -= 1;
+            }
+        }
+        true
+    }
+}
diff --git a/solution/0400-0499/0498.Diagonal Traverse/README.md b/solution/0400-0499/0498.Diagonal Traverse/README.md
index c0846c6f5276c..6fd05dde03536 100644
--- a/solution/0400-0499/0498.Diagonal Traverse/README.md	
+++ b/solution/0400-0499/0498.Diagonal Traverse/README.md	
@@ -158,6 +158,82 @@ func findDiagonalOrder(mat [][]int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findDiagonalOrder(mat: number[][]): number[] {
+    const res = [];
+    const m = mat.length;
+    const n = mat[0].length;
+    let i = 0;
+    let j = 0;
+    let mark = true;
+    while (res.length !== n * m) {
+        if (mark) {
+            while (i >= 0 && j < n) {
+                res.push(mat[i][j]);
+                i--;
+                j++;
+            }
+            if (j === n) {
+                j--;
+                i++;
+            }
+            i++;
+        } else {
+            while (i < m && j >= 0) {
+                res.push(mat[i][j]);
+                i++;
+                j--;
+            }
+            if (i === m) {
+                i--;
+                j++;
+            }
+            j++;
+        }
+        mark = !mark;
+    }
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_diagonal_order(mat: Vec<Vec<i32>>) -> Vec<i32> {
+        let (m, n) = (mat.len(), mat[0].len());
+        let (mut i, mut j) = (0, 0);
+        (0..m * n)
+            .map(|_| {
+                let res = mat[i][j];
+                if (i + j) % 2 == 0 {
+                    if j == n - 1 {
+                        i += 1;
+                    } else if i == 0 {
+                        j += 1;
+                    } else {
+                        i -= 1;
+                        j += 1;
+                    }
+                } else {
+                    if i == m - 1 {
+                        j += 1;
+                    } else if j == 0 {
+                        i += 1;
+                    } else {
+                        i += 1;
+                        j -= 1;
+                    }
+                }
+                res
+            })
+            .collect()
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0400-0499/0498.Diagonal Traverse/README_EN.md b/solution/0400-0499/0498.Diagonal Traverse/README_EN.md
index ddad99d17574e..47f33ec1fe9cc 100644
--- a/solution/0400-0499/0498.Diagonal Traverse/README_EN.md	
+++ b/solution/0400-0499/0498.Diagonal Traverse/README_EN.md	
@@ -148,6 +148,82 @@ func findDiagonalOrder(mat [][]int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findDiagonalOrder(mat: number[][]): number[] {
+    const res = [];
+    const m = mat.length;
+    const n = mat[0].length;
+    let i = 0;
+    let j = 0;
+    let mark = true;
+    while (res.length !== n * m) {
+        if (mark) {
+            while (i >= 0 && j < n) {
+                res.push(mat[i][j]);
+                i--;
+                j++;
+            }
+            if (j === n) {
+                j--;
+                i++;
+            }
+            i++;
+        } else {
+            while (i < m && j >= 0) {
+                res.push(mat[i][j]);
+                i++;
+                j--;
+            }
+            if (i === m) {
+                i--;
+                j++;
+            }
+            j++;
+        }
+        mark = !mark;
+    }
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_diagonal_order(mat: Vec<Vec<i32>>) -> Vec<i32> {
+        let (m, n) = (mat.len(), mat[0].len());
+        let (mut i, mut j) = (0, 0);
+        (0..m * n)
+            .map(|_| {
+                let res = mat[i][j];
+                if (i + j) % 2 == 0 {
+                    if j == n - 1 {
+                        i += 1;
+                    } else if i == 0 {
+                        j += 1;
+                    } else {
+                        i -= 1;
+                        j += 1;
+                    }
+                } else {
+                    if i == m - 1 {
+                        j += 1;
+                    } else if j == 0 {
+                        i += 1;
+                    } else {
+                        i += 1;
+                        j -= 1;
+                    }
+                }
+                res
+            })
+            .collect()
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0400-0499/0498.Diagonal Traverse/Solution.rs b/solution/0400-0499/0498.Diagonal Traverse/Solution.rs
new file mode 100644
index 0000000000000..1d323b51183ae
--- /dev/null
+++ b/solution/0400-0499/0498.Diagonal Traverse/Solution.rs	
@@ -0,0 +1,31 @@
+impl Solution {
+    pub fn find_diagonal_order(mat: Vec<Vec<i32>>) -> Vec<i32> {
+        let (m, n) = (mat.len(), mat[0].len());
+        let (mut i, mut j) = (0, 0);
+        (0..m * n)
+            .map(|_| {
+                let res = mat[i][j];
+                if (i + j) % 2 == 0 {
+                    if j == n - 1 {
+                        i += 1;
+                    } else if i == 0 {
+                        j += 1;
+                    } else {
+                        i -= 1;
+                        j += 1;
+                    }
+                } else {
+                    if i == m - 1 {
+                        j += 1;
+                    } else if j == 0 {
+                        i += 1;
+                    } else {
+                        i += 1;
+                        j -= 1;
+                    }
+                }
+                res
+            })
+            .collect()
+    }
+}
diff --git a/solution/0400-0499/0498.Diagonal Traverse/Solution.ts b/solution/0400-0499/0498.Diagonal Traverse/Solution.ts
new file mode 100644
index 0000000000000..b8152f46c5cd6
--- /dev/null
+++ b/solution/0400-0499/0498.Diagonal Traverse/Solution.ts	
@@ -0,0 +1,35 @@
+function findDiagonalOrder(mat: number[][]): number[] {
+    const res = [];
+    const m = mat.length;
+    const n = mat[0].length;
+    let i = 0;
+    let j = 0;
+    let mark = true;
+    while (res.length !== n * m) {
+        if (mark) {
+            while (i >= 0 && j < n) {
+                res.push(mat[i][j]);
+                i--;
+                j++;
+            }
+            if (j === n) {
+                j--;
+                i++;
+            }
+            i++;
+        } else {
+            while (i < m && j >= 0) {
+                res.push(mat[i][j]);
+                i++;
+                j--;
+            }
+            if (i === m) {
+                i--;
+                j++;
+            }
+            j++;
+        }
+        mark = !mark;
+    }
+    return res;
+}