feat: add solutions to lc problems: No.0438,0713

- No.0438.Find All Anagrams in a String
- No.0713.Subarray Product Less Than K

Author: YangFong

solution/0400-0499/0438.Find All Anagrams in a String/README.md

@@ -216,6 +216,38 @@ func findAnagrams(s string, p string) []int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_anagrams(s: String, p: String) -> Vec<i32> {
+        let (s, p) = (s.as_bytes(), p.as_bytes());
+        let (m, n) = (s.len(), p.len());
+        let mut res = vec![];
+        if n > m {
+            return res;
+        }
+
+        let mut counter = [0; 26];
+        for i in 0..n {
+            counter[(p[i] - b'a') as usize] += 1;
+            counter[(s[i] - b'a') as usize] -= 1;
+        }
+        for i in n..m {
+            if counter.iter().all(|&v| v == 0) {
+                res.push((i - n) as i32);
+            }
+            counter[(s[i] - b'a') as usize] -= 1;
+            counter[(s[i - n] - b'a') as usize] += 1;
+        }
+        if counter.iter().all(|&v| v == 0) {
+            res.push((m - n) as i32);
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0400-0499/0438.Find All Anagrams in a String/README_EN.md

@@ -172,6 +172,38 @@ func findAnagrams(s string, p string) []int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_anagrams(s: String, p: String) -> Vec<i32> {
+        let (s, p) = (s.as_bytes(), p.as_bytes());
+        let (m, n) = (s.len(), p.len());
+        let mut res = vec![];
+        if n > m {
+            return res;
+        }
+
+        let mut counter = [0; 26];
+        for i in 0..n {
+            counter[(p[i] - b'a') as usize] += 1;
+            counter[(s[i] - b'a') as usize] -= 1;
+        }
+        for i in n..m {
+            if counter.iter().all(|&v| v == 0) {
+                res.push((i - n) as i32);
+            }
+            counter[(s[i] - b'a') as usize] -= 1;
+            counter[(s[i - n] - b'a') as usize] += 1;
+        }
+        if counter.iter().all(|&v| v == 0) {
+            res.push((m - n) as i32);
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0400-0499/0438.Find All Anagrams in a String/Solution.rs

@@ -0,0 +1,27 @@
+impl Solution {
+    pub fn find_anagrams(s: String, p: String) -> Vec<i32> {
+        let (s, p) = (s.as_bytes(), p.as_bytes());
+        let (m, n) = (s.len(), p.len());
+        let mut res = vec![];
+        if n > m {
+            return res;
+        }
+
+        let mut counter = [0; 26];
+        for i in 0..n {
+            counter[(p[i] - b'a') as usize] += 1;
+            counter[(s[i] - b'a') as usize] -= 1;
+        }
+        for i in n..m {
+            if counter.iter().all(|&v| v == 0) {
+                res.push((i - n) as i32);
+            }
+            counter[(s[i] - b'a') as usize] -= 1;
+            counter[(s[i - n] - b'a') as usize] += 1;
+        }
+        if counter.iter().all(|&v| v == 0) {
+            res.push((m - n) as i32);
+        }
+        res
+    }
+}

solution/0700-0799/0713.Subarray Product Less Than K/README.md

@@ -82,6 +82,55 @@ public:
 
 ```
 
+### **TypeScript**
+
+```ts
+function numSubarrayProductLessThanK(nums: number[], k: number): number {
+    if (k <= 1) {
+        return 0;
+    }
+
+    const n = nums.length;
+    let res = 0;
+    for (let i = 0; i < n; i++) {
+        let product = 1;
+        for (let j = i; j < n; j++) {
+            product *= nums[j];
+            if (product >= k) {
+                break;
+            }
+            res++;
+        }
+    }
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn num_subarray_product_less_than_k(nums: Vec<i32>, k: i32) -> i32 {
+        if k <= 1 {
+            return 0;
+        }
+
+        let mut res = 0;
+        let mut product = 1;
+        let mut i = 0;
+        nums.iter().enumerate().for_each(|(j, v)| {
+            product *= v;
+            while product >= k {
+                product /= nums[i];
+                i += 1;
+            }
+            res += j - i + 1;
+        });
+        res as i32
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0713.Subarray Product Less Than K/README_EN.md

@@ -74,6 +74,55 @@ public:
 
 ```
 
+### **TypeScript**
+
+```ts
+function numSubarrayProductLessThanK(nums: number[], k: number): number {
+    if (k <= 1) {
+        return 0;
+    }
+
+    const n = nums.length;
+    let res = 0;
+    for (let i = 0; i < n; i++) {
+        let product = 1;
+        for (let j = i; j < n; j++) {
+            product *= nums[j];
+            if (product >= k) {
+                break;
+            }
+            res++;
+        }
+    }
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn num_subarray_product_less_than_k(nums: Vec<i32>, k: i32) -> i32 {
+        if k <= 1 {
+            return 0;
+        }
+
+        let mut res = 0;
+        let mut product = 1;
+        let mut i = 0;
+        nums.iter().enumerate().for_each(|(j, v)| {
+            product *= v;
+            while product >= k {
+                product /= nums[i];
+                i += 1;
+            }
+            res += j - i + 1;
+        });
+        res as i32
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0713.Subarray Product Less Than K/Solution.rs

@@ -0,0 +1,20 @@
+impl Solution {
+    pub fn num_subarray_product_less_than_k(nums: Vec<i32>, k: i32) -> i32 {
+        if k <= 1 {
+            return 0;
+        }
+
+        let mut res = 0;
+        let mut product = 1;
+        let mut i = 0;
+        nums.iter().enumerate().for_each(|(j, v)| {
+            product *= v;
+            while product >= k {
+                product /= nums[i];
+                i += 1;
+            }
+            res += j - i + 1;
+        });
+        res as i32
+    }
+}

solution/0700-0799/0713.Subarray Product Less Than K/Solution.ts

@@ -0,0 +1,19 @@
+function numSubarrayProductLessThanK(nums: number[], k: number): number {
+    if (k <= 1) {
+        return 0;
+    }
+
+    const n = nums.length;
+    let res = 0;
+    for (let i = 0; i < n; i++) {
+        let product = 1;
+        for (let j = i; j < n; j++) {
+            product *= nums[j];
+            if (product >= k) {
+                break;
+            }
+            res++;
+        }
+    }
+    return res;
+}