feat: add solutions to lc problems: No.0242,1356

- No.0242.Valid Anagram
- No.1356.Sort Integers by The Number of 1 Bits

Author: YangFong

solution/0200-0299/0242.Valid Anagram/README.md

@@ -167,6 +167,26 @@ var isAnagram = function (s, t) {
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn is_anagram(s: String, t: String) -> bool {
+        if s.len() != t.len() {
+            return false;
+        }
+        let (s, t) = (s.as_bytes(), t.as_bytes());
+        let mut record = [0; 26];
+        let n = s.len();
+        for i in 0..n {
+            record[(s[i] - b'a') as usize] += 1;
+            record[(t[i] - b'a') as usize] -= 1;
+        }
+        record.iter().all(|&c| c == 0)
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0242.Valid Anagram/README_EN.md

@@ -148,6 +148,26 @@ var isAnagram = function (s, t) {
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn is_anagram(s: String, t: String) -> bool {
+        if s.len() != t.len() {
+            return false;
+        }
+        let (s, t) = (s.as_bytes(), t.as_bytes());
+        let mut record = [0; 26];
+        let n = s.len();
+        for i in 0..n {
+            record[(s[i] - b'a') as usize] += 1;
+            record[(t[i] - b'a') as usize] -= 1;
+        }
+        record.iter().all(|&c| c == 0)
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0200-0299/0242.Valid Anagram/Solution.rs

@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn is_anagram(s: String, t: String) -> bool {
+        if s.len() != t.len() {
+            return false;
+        }
+        let (s, t) = (s.as_bytes(), t.as_bytes());
+        let mut record = [0; 26];
+        let n = s.len();
+        for i in 0..n {
+            record[(s[i] - b'a') as usize] += 1;
+            record[(t[i] - b'a') as usize] -= 1;
+        }
+        record.iter().all(|&c| c == 0)
+    }
+}

solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/README.md

@@ -96,6 +96,45 @@ class Solution {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function sortByBits(arr: number[]): number[] {
+    const countOnes = (num: number) => {
+        let count = 0;
+        while (num !== 0) {
+            num &= num - 1;
+            count++;
+        }
+        return count;
+    };
+    return arr.sort((a, b) => {
+        let res = countOnes(a) - countOnes(b);
+        if (res === 0) {
+            return a - b;
+        }
+        return res;
+    });
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn sort_by_bits(mut arr: Vec<i32>) -> Vec<i32> {
+        arr.sort_unstable_by(|a, b| {
+            let res = a.count_ones().cmp(&b.count_ones());
+            if res == std::cmp::Ordering::Equal {
+                return a.cmp(&b);
+            }
+            res
+        });
+        arr
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/README_EN.md

@@ -68,6 +68,45 @@ class Solution {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function sortByBits(arr: number[]): number[] {
+    const countOnes = (num: number) => {
+        let count = 0;
+        while (num !== 0) {
+            num &= num - 1;
+            count++;
+        }
+        return count;
+    };
+    return arr.sort((a, b) => {
+        let res = countOnes(a) - countOnes(b);
+        if (res === 0) {
+            return a - b;
+        }
+        return res;
+    });
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn sort_by_bits(mut arr: Vec<i32>) -> Vec<i32> {
+        arr.sort_unstable_by(|a, b| {
+            let res = a.count_ones().cmp(&b.count_ones());
+            if res == std::cmp::Ordering::Equal {
+                return a.cmp(&b);
+            }
+            res
+        });
+        arr
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/Solution.rs

@@ -0,0 +1,12 @@
+impl Solution {
+    pub fn sort_by_bits(mut arr: Vec<i32>) -> Vec<i32> {
+        arr.sort_unstable_by(|a, b| {
+            let res = a.count_ones().cmp(&b.count_ones());
+            if res == std::cmp::Ordering::Equal {
+                return a.cmp(&b);
+            }
+            res
+        });
+        arr
+    }
+}

solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/Solution.ts

@@ -0,0 +1,17 @@
+function sortByBits(arr: number[]): number[] {
+    const countOnes = (num: number) => {
+        let count = 0;
+        while (num !== 0) {
+            num &= num - 1;
+            count++;
+        }
+        return count;
+    };
+    return arr.sort((a, b) => {
+        let res = countOnes(a) - countOnes(b);
+        if (res === 0) {
+            return a - b;
+        }
+        return res;
+    });
+}