feat: add solutions to lc problems: No.0153,0890

- No.0153.Find Minimum in Rotated Sorted Array
- No.0890.Find and Replace Pattern

Author: YangFong

solution/0100-0199/0153.Find Minimum in Rotated Sorted Array/README.md

@@ -63,11 +63,15 @@
 
 **方法一：二分查找**
 
-初始，判断数组首尾元素的大小关系，若 `nums[0] <= nums[n - 1]`，说明当前数组已经是递增数组，最小值一定是数组第一个元素，提前返回 `nums[0]`。
+初始，判断数组首尾元素的大小关系，若 `nums[0] <= nums[n - 1]` 条件成立，则说明当前数组已经是递增数组，最小值一定是数组第一个元素，提前返回 `nums[0]`。
 
-否则，进行二分判断。若 `nums[0] <= nums[mid]`，说明 `[left, mid]` 范围内的元素构成递增数组，最小值一定在 mid 的右侧，否则说明 `[mid + 1, right]`范围内的元素构成递增数组，最小值一定在 mid 的左侧。
+否则，进行二分判断。若 `nums[0] <= nums[mid]`，说明 `[left, mid]` 范围内的元素构成递增数组，最小值一定在 `mid` 的右侧，否则说明 `[mid + 1, right]` 范围内的元素构成递增数组，最小值一定在 `mid` 的左侧。
 
-时间复杂度 O(logn)。
+---
+
+除了 `nums[0]`，也可以以 `nums[right]` 作为参照物，若 `nums[mid] < nums[right]` 成立，则最小值存在于 `[left, mid]` 范围当中，否则存在于 `[mid + 1, right]`。
+
+时间复杂度：$O(logN)$
 
 <!-- tabs:start -->
 
@@ -181,17 +185,17 @@ var findMin = function (nums) {
 ```rust
 impl Solution {
     pub fn find_min(nums: Vec<i32>) -> i32 {
-        let mut l = 0;
-        let mut r = nums.len() - 1;
-        while l < r {
-            let mid = l + (r - l) / 2;
-            if nums[mid] > nums[r] {
-                l = mid + 1;
+        let mut left = 0;
+        let mut right = nums.len() - 1;
+        while left < right {
+            let mid = left + (right - left) / 2;
+            if nums[mid] > nums[right] {
+                left = mid + 1;
             } else {
-                r = mid;
+                right = mid;
             }
         }
-        nums[l]
+        nums[left]
     }
 }
 ```
@@ -200,15 +204,11 @@ impl Solution {
 
 ```ts
 function findMin(nums: number[]): number {
-    const n = nums.length;
-    if (nums[0] <= nums[n - 1]) {
-        return nums[0];
-    }
-    let left = 0,
-        right = n - 1;
+    let left = 0;
+    let right = nums.length - 1;
     while (left < right) {
-        const mid = (left + right) >> 1;
-        if (nums[0] <= nums[mid]) {
+        const mid = (left + right) >>> 1;
+        if (nums[mid] > nums[right]) {
             left = mid + 1;
         } else {
             right = mid;

solution/0100-0199/0153.Find Minimum in Rotated Sorted Array/README_EN.md

@@ -163,17 +163,17 @@ var findMin = function (nums) {
 ```rust
 impl Solution {
     pub fn find_min(nums: Vec<i32>) -> i32 {
-        let mut l = 0;
-        let mut r = nums.len() - 1;
-        while l < r {
-            let mid = l + (r - l) / 2;
-            if nums[mid] > nums[r] {
-                l = mid + 1;
+        let mut left = 0;
+        let mut right = nums.len() - 1;
+        while left < right {
+            let mid = left + (right - left) / 2;
+            if nums[mid] > nums[right] {
+                left = mid + 1;
             } else {
-                r = mid;
+                right = mid;
             }
         }
-        nums[l]
+        nums[left]
     }
 }
 ```
@@ -182,15 +182,11 @@ impl Solution {
 
 ```ts
 function findMin(nums: number[]): number {
-    const n = nums.length;
-    if (nums[0] <= nums[n - 1]) {
-        return nums[0];
-    }
-    let left = 0,
-        right = n - 1;
+    let left = 0;
+    let right = nums.length - 1;
     while (left < right) {
-        const mid = (left + right) >> 1;
-        if (nums[0] <= nums[mid]) {
+        const mid = (left + right) >>> 1;
+        if (nums[mid] > nums[right]) {
             left = mid + 1;
         } else {
             right = mid;

solution/0100-0199/0153.Find Minimum in Rotated Sorted Array/Solution.rs

@@ -1,15 +1,15 @@
 impl Solution {
     pub fn find_min(nums: Vec<i32>) -> i32 {
-        let mut l = 0;
-        let mut r = nums.len() - 1;
-        while l < r {
-            let mid = l + (r - l) / 2;
-            if nums[mid] > nums[r] {
-                l = mid + 1;
+        let mut left = 0;
+        let mut right = nums.len() - 1;
+        while left < right {
+            let mid = left + (right - left) / 2;
+            if nums[mid] > nums[right] {
+                left = mid + 1;
             } else {
-                r = mid;
+                right = mid;
             }
         }
-        nums[l]
+        nums[left]
     }
 }

solution/0100-0199/0153.Find Minimum in Rotated Sorted Array/Solution.ts

@@ -1,13 +1,9 @@
 function findMin(nums: number[]): number {
-    const n = nums.length;
-    if (nums[0] <= nums[n - 1]) {
-        return nums[0];
-    }
-    let left = 0,
-        right = n - 1;
+    let left = 0;
+    let right = nums.length - 1;
     while (left < right) {
-        const mid = (left + right) >> 1;
-        if (nums[0] <= nums[mid]) {
+        const mid = (left + right) >>> 1;
+        if (nums[mid] > nums[right]) {
             left = mid + 1;
         } else {
             right = mid;

solution/0800-0899/0890.Find and Replace Pattern/README.md

@@ -146,6 +146,53 @@ func findAndReplacePattern(words []string, pattern string) []string {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findAndReplacePattern(words: string[], pattern: string): string[] {
+    return words.filter(word => {
+        const map1 = new Map<string, number>();
+        const map2 = new Map<string, number>();
+        for (let i = 0; i < word.length; i++) {
+            if (map1.get(word[i]) !== map2.get(pattern[i])) {
+                return false;
+            }
+            map1.set(word[i], i);
+            map2.set(pattern[i], i);
+        }
+        return true;
+    });
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+impl Solution {
+    pub fn find_and_replace_pattern(words: Vec<String>, pattern: String) -> Vec<String> {
+        let pattern = pattern.as_bytes();
+        let n = pattern.len();
+        words
+            .into_iter()
+            .filter(|word| {
+                let word = word.as_bytes();
+                let mut map1 = HashMap::new();
+                let mut map2 = HashMap::new();
+                for i in 0..n {
+                    if map1.get(&word[i]).unwrap_or(&n) != map2.get(&pattern[i]).unwrap_or(&n) {
+                        return false;
+                    }
+                    map1.insert(word[i], i);
+                    map2.insert(pattern[i], i);
+                }
+                true
+            })
+            .collect()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0800-0899/0890.Find and Replace Pattern/README_EN.md

@@ -141,6 +141,53 @@ func findAndReplacePattern(words []string, pattern string) []string {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findAndReplacePattern(words: string[], pattern: string): string[] {
+    return words.filter(word => {
+        const map1 = new Map<string, number>();
+        const map2 = new Map<string, number>();
+        for (let i = 0; i < word.length; i++) {
+            if (map1.get(word[i]) !== map2.get(pattern[i])) {
+                return false;
+            }
+            map1.set(word[i], i);
+            map2.set(pattern[i], i);
+        }
+        return true;
+    });
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::HashMap;
+impl Solution {
+    pub fn find_and_replace_pattern(words: Vec<String>, pattern: String) -> Vec<String> {
+        let pattern = pattern.as_bytes();
+        let n = pattern.len();
+        words
+            .into_iter()
+            .filter(|word| {
+                let word = word.as_bytes();
+                let mut map1 = HashMap::new();
+                let mut map2 = HashMap::new();
+                for i in 0..n {
+                    if map1.get(&word[i]).unwrap_or(&n) != map2.get(&pattern[i]).unwrap_or(&n) {
+                        return false;
+                    }
+                    map1.insert(word[i], i);
+                    map2.insert(pattern[i], i);
+                }
+                true
+            })
+            .collect()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0800-0899/0890.Find and Replace Pattern/Solution.rs

@@ -0,0 +1,23 @@
+use std::collections::HashMap;
+impl Solution {
+    pub fn find_and_replace_pattern(words: Vec<String>, pattern: String) -> Vec<String> {
+        let pattern = pattern.as_bytes();
+        let n = pattern.len();
+        words
+            .into_iter()
+            .filter(|word| {
+                let word = word.as_bytes();
+                let mut map1 = HashMap::new();
+                let mut map2 = HashMap::new();
+                for i in 0..n {
+                    if map1.get(&word[i]).unwrap_or(&n) != map2.get(&pattern[i]).unwrap_or(&n) {
+                        return false;
+                    }
+                    map1.insert(word[i], i);
+                    map2.insert(pattern[i], i);
+                }
+                true
+            })
+            .collect()
+    }
+}

solution/0800-0899/0890.Find and Replace Pattern/Solution.ts

@@ -0,0 +1,14 @@
+function findAndReplacePattern(words: string[], pattern: string): string[] {
+    return words.filter(word => {
+        const map1 = new Map<string, number>();
+        const map2 = new Map<string, number>();
+        for (let i = 0; i < word.length; i++) {
+            if (map1.get(word[i]) !== map2.get(pattern[i])) {
+                return false;
+            }
+            map1.set(word[i], i);
+            map2.set(pattern[i], i);
+        }
+        return true;
+    });
+}