From 6f0ae3fea77636857dfa715adf47e49292d2fd4a Mon Sep 17 00:00:00 2001
From: yanglbme <szuyanglb@outlook.com>
Date: Fri, 22 Sep 2023 10:40:06 +0800
Subject: [PATCH] feat: add solutions to lc/lcci problems

* lc No.0081.Search in Rotated Sorted Array II
* lcci No.10.03.Search Rotate Array
---
 lcci/10.03.Search Rotate Array/README.md      | 165 +++++++++++++++++-
 lcci/10.03.Search Rotate Array/README_EN.md   | 143 ++++++++++++++-
 lcci/10.03.Search Rotate Array/Solution.cpp   |  28 +++
 lcci/10.03.Search Rotate Array/Solution.go    |  28 +++
 lcci/10.03.Search Rotate Array/Solution.java  |  27 +++
 lcci/10.03.Search Rotate Array/Solution.py    |  20 +++
 lcci/10.03.Search Rotate Array/Solution.ts    |  25 +++
 .../README.md                                 | 151 +++++++++++-----
 .../README_EN.md                              | 139 ++++++++++-----
 .../Solution.cpp                              |  46 ++---
 .../Solution.go                               |  22 +++
 .../Solution.java                             |  44 ++---
 .../Solution.py                               |  39 ++---
 .../Solution.ts                               |  22 +++
 14 files changed, 750 insertions(+), 149 deletions(-)
 create mode 100644 lcci/10.03.Search Rotate Array/Solution.cpp
 create mode 100644 lcci/10.03.Search Rotate Array/Solution.go
 create mode 100644 lcci/10.03.Search Rotate Array/Solution.java
 create mode 100644 lcci/10.03.Search Rotate Array/Solution.py
 create mode 100644 lcci/10.03.Search Rotate Array/Solution.ts
 create mode 100644 solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.go
 create mode 100644 solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.ts

diff --git a/lcci/10.03.Search Rotate Array/README.md b/lcci/10.03.Search Rotate Array/README.md
index ad7fbae748066..0209693b13f13 100644
--- a/lcci/10.03.Search Rotate Array/README.md	
+++ b/lcci/10.03.Search Rotate Array/README.md	
@@ -5,6 +5,7 @@
 ## 题目描述
 
 <!-- 这里写题目描述 -->
+
 <p>搜索旋转数组。给定一个排序后的数组，包含n个整数，但这个数组已被旋转过很多次了，次数不详。请编写代码找出数组中的某个元素，假设数组元素原先是按升序排列的。若有多个相同元素，返回索引值最小的一个。</p>
 <p><strong>示例1:</strong></p>
 <pre><strong> 输入</strong>: arr = [15, 16, 19, 20, 25, 1, 3, 4, 5, 7, 10, 14], target = 5
@@ -22,6 +23,27 @@
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
+
+**方法一：二分查找**
+
+我们定义二分查找的左边界 $l=0$，右边界 $r=n-1$，其中 $n$ 为数组的长度。
+
+每次在二分查找的过程中，我们会得到当前的中点 $mid=(l+r)/2$。
+
+-   如果 $nums[mid] \gt nums[r]$，说明 $[l,mid]$ 是有序的，此时如果 $nums[l] \le target \le nums[mid]$，说明 $target$ 位于 $[l,mid]$，否则 $target$ 位于 $[mid+1,r]$。
+-   如果 $nums[mid] \lt nums[r]$，说明 $[mid+1,r]$ 是有序的，此时如果 $nums[mid] \lt target \le nums[r]$，说明 $target$ 位于 $[mid+1,r]$，否则 $target$ 位于 $[l,mid]$。
+-   如果 $nums[mid] = nums[r]$，说明元素 $nums[mid]$ 和 $nums[r]$ 相等，此时无法判断 $target$ 位于哪个区间，我们只能将 $r$ 减少 $1$。
+
+二分查找结束后，如果 $nums[l] = target$，则说明数组中存在目标值 $target$，否则说明不存在。
+
+注意，如果一开始 $nums[l] = nums[r]$，我们循环将 $r$ 减少 $1$，直到 $nums[l] \ne nums[r]$。
+
+时间复杂度近似 $O(\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组的长度。
+
+相似题目：
+
+-   [81. 搜索旋转排序数组 II](/solution/0000-0099/0081.Search%20in%20Rotated%20Sorted%20Array%20II/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -29,7 +51,26 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def search(self, arr: List[int], target: int) -> int:
+        l, r = 0, len(arr) - 1
+        while arr[l] == arr[r]:
+            r -= 1
+        while l < r:
+            mid = (l + r) >> 1
+            if arr[mid] > arr[r]:
+                if arr[l] <= target <= arr[mid]:
+                    r = mid
+                else:
+                    l = mid + 1
+            elif arr[mid] < arr[r]:
+                if arr[mid] < target <= arr[r]:
+                    l = mid + 1
+                else:
+                    r = mid
+            else:
+                r -= 1
+        return l if arr[l] == target else -1
 ```
 
 ### **Java**
@@ -37,7 +78,129 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int search(int[] arr, int target) {
+        int l = 0, r = arr.length - 1;
+        while (arr[l] == arr[r]) {
+            --r;
+        }
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (arr[mid] > arr[r]) {
+                if (arr[l] <= target && target <= arr[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (arr[mid] < arr[r]) {
+                if (arr[mid] < target && target <= arr[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return arr[l] == target ? l : -1;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int search(vector<int>& arr, int target) {
+        int l = 0, r = arr.size() - 1;
+        while (arr[l] == arr[r]) {
+            --r;
+        }
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (arr[mid] > arr[r]) {
+                if (arr[l] <= target && target <= arr[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (arr[mid] < arr[r]) {
+                if (arr[mid] < target && target <= arr[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return arr[l] == target ? l : -1;
+    }
+};
+```
+
+### **Go**
+
+```go
+func search(arr []int, target int) int {
+	l, r := 0, len(arr)-1
+	for arr[l] == arr[r] {
+		r--
+	}
+	for l < r {
+		mid := (l + r) >> 1
+		if arr[mid] > arr[r] {
+			if arr[l] <= target && target <= arr[mid] {
+				r = mid
+			} else {
+				l = mid + 1
+			}
+		} else if arr[mid] < arr[r] {
+			if arr[mid] < target && target <= arr[r] {
+				l = mid + 1
+			} else {
+				r = mid
+			}
+		} else {
+			r--
+		}
+	}
+	if arr[l] == target {
+		return l
+	}
+	return -1
+}
+```
 
+### **TypeScript**
+
+```ts
+function search(arr: number[], target: number): number {
+    let [l, r] = [0, arr.length - 1];
+    while (arr[l] === arr[r]) {
+        --r;
+    }
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (arr[mid] > arr[r]) {
+            if (arr[l] <= target && target <= arr[mid]) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        } else if (arr[mid] < arr[r]) {
+            if (arr[mid] < target && target <= arr[r]) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        } else {
+            --r;
+        }
+    }
+    return arr[l] === target ? l : -1;
+}
 ```
 
 ### **...**
diff --git a/lcci/10.03.Search Rotate Array/README_EN.md b/lcci/10.03.Search Rotate Array/README_EN.md
index eb302336ac6c7..f63f2cd018ee7 100644
--- a/lcci/10.03.Search Rotate Array/README_EN.md	
+++ b/lcci/10.03.Search Rotate Array/README_EN.md	
@@ -33,13 +33,154 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def search(self, arr: List[int], target: int) -> int:
+        l, r = 0, len(arr) - 1
+        while arr[l] == arr[r]:
+            r -= 1
+        while l < r:
+            mid = (l + r) >> 1
+            if arr[mid] > arr[r]:
+                if arr[l] <= target <= arr[mid]:
+                    r = mid
+                else:
+                    l = mid + 1
+            elif arr[mid] < arr[r]:
+                if arr[mid] < target <= arr[r]:
+                    l = mid + 1
+                else:
+                    r = mid
+            else:
+                r -= 1
+        return l if arr[l] == target else -1
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int search(int[] arr, int target) {
+        int l = 0, r = arr.length - 1;
+        while (arr[l] == arr[r]) {
+            --r;
+        }
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (arr[mid] > arr[r]) {
+                if (arr[l] <= target && target <= arr[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (arr[mid] < arr[r]) {
+                if (arr[mid] < target && target <= arr[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return arr[l] == target ? l : -1;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int search(vector<int>& arr, int target) {
+        int l = 0, r = arr.size() - 1;
+        while (arr[l] == arr[r]) {
+            --r;
+        }
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (arr[mid] > arr[r]) {
+                if (arr[l] <= target && target <= arr[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (arr[mid] < arr[r]) {
+                if (arr[mid] < target && target <= arr[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return arr[l] == target ? l : -1;
+    }
+};
+```
+
+### **Go**
+
+```go
+func search(arr []int, target int) int {
+	l, r := 0, len(arr)-1
+	for arr[l] == arr[r] {
+		r--
+	}
+	for l < r {
+		mid := (l + r) >> 1
+		if arr[mid] > arr[r] {
+			if arr[l] <= target && target <= arr[mid] {
+				r = mid
+			} else {
+				l = mid + 1
+			}
+		} else if arr[mid] < arr[r] {
+			if arr[mid] < target && target <= arr[r] {
+				l = mid + 1
+			} else {
+				r = mid
+			}
+		} else {
+			r--
+		}
+	}
+	if arr[l] == target {
+		return l
+	}
+	return -1
+}
+```
 
+### **TypeScript**
+
+```ts
+function search(arr: number[], target: number): number {
+    let [l, r] = [0, arr.length - 1];
+    while (arr[l] === arr[r]) {
+        --r;
+    }
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (arr[mid] > arr[r]) {
+            if (arr[l] <= target && target <= arr[mid]) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        } else if (arr[mid] < arr[r]) {
+            if (arr[mid] < target && target <= arr[r]) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        } else {
+            --r;
+        }
+    }
+    return arr[l] === target ? l : -1;
+}
 ```
 
 ### **...**
diff --git a/lcci/10.03.Search Rotate Array/Solution.cpp b/lcci/10.03.Search Rotate Array/Solution.cpp
new file mode 100644
index 0000000000000..7a28ef0a075de
--- /dev/null
+++ b/lcci/10.03.Search Rotate Array/Solution.cpp	
@@ -0,0 +1,28 @@
+class Solution {
+public:
+    int search(vector<int>& arr, int target) {
+        int l = 0, r = arr.size() - 1;
+        while (arr[l] == arr[r]) {
+            --r;
+        }
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (arr[mid] > arr[r]) {
+                if (arr[l] <= target && target <= arr[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (arr[mid] < arr[r]) {
+                if (arr[mid] < target && target <= arr[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return arr[l] == target ? l : -1;
+    }
+};
\ No newline at end of file
diff --git a/lcci/10.03.Search Rotate Array/Solution.go b/lcci/10.03.Search Rotate Array/Solution.go
new file mode 100644
index 0000000000000..8f81fe1c3392b
--- /dev/null
+++ b/lcci/10.03.Search Rotate Array/Solution.go	
@@ -0,0 +1,28 @@
+func search(arr []int, target int) int {
+	l, r := 0, len(arr)-1
+	for arr[l] == arr[r] {
+		r--
+	}
+	for l < r {
+		mid := (l + r) >> 1
+		if arr[mid] > arr[r] {
+			if arr[l] <= target && target <= arr[mid] {
+				r = mid
+			} else {
+				l = mid + 1
+			}
+		} else if arr[mid] < arr[r] {
+			if arr[mid] < target && target <= arr[r] {
+				l = mid + 1
+			} else {
+				r = mid
+			}
+		} else {
+			r--
+		}
+	}
+	if arr[l] == target {
+		return l
+	}
+	return -1
+}
\ No newline at end of file
diff --git a/lcci/10.03.Search Rotate Array/Solution.java b/lcci/10.03.Search Rotate Array/Solution.java
new file mode 100644
index 0000000000000..c1d9089277322
--- /dev/null
+++ b/lcci/10.03.Search Rotate Array/Solution.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int search(int[] arr, int target) {
+        int l = 0, r = arr.length - 1;
+        while (arr[l] == arr[r]) {
+            --r;
+        }
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (arr[mid] > arr[r]) {
+                if (arr[l] <= target && target <= arr[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (arr[mid] < arr[r]) {
+                if (arr[mid] < target && target <= arr[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return arr[l] == target ? l : -1;
+    }
+}
\ No newline at end of file
diff --git a/lcci/10.03.Search Rotate Array/Solution.py b/lcci/10.03.Search Rotate Array/Solution.py
new file mode 100644
index 0000000000000..c88723a3ff098
--- /dev/null
+++ b/lcci/10.03.Search Rotate Array/Solution.py	
@@ -0,0 +1,20 @@
+class Solution:
+    def search(self, arr: List[int], target: int) -> int:
+        l, r = 0, len(arr) - 1
+        while arr[l] == arr[r]:
+            r -= 1
+        while l < r:
+            mid = (l + r) >> 1
+            if arr[mid] > arr[r]:
+                if arr[l] <= target <= arr[mid]:
+                    r = mid
+                else:
+                    l = mid + 1
+            elif arr[mid] < arr[r]:
+                if arr[mid] < target <= arr[r]:
+                    l = mid + 1
+                else:
+                    r = mid
+            else:
+                r -= 1
+        return l if arr[l] == target else -1
diff --git a/lcci/10.03.Search Rotate Array/Solution.ts b/lcci/10.03.Search Rotate Array/Solution.ts
new file mode 100644
index 0000000000000..a507505b225aa
--- /dev/null
+++ b/lcci/10.03.Search Rotate Array/Solution.ts	
@@ -0,0 +1,25 @@
+function search(arr: number[], target: number): number {
+    let [l, r] = [0, arr.length - 1];
+    while (arr[l] === arr[r]) {
+        --r;
+    }
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (arr[mid] > arr[r]) {
+            if (arr[l] <= target && target <= arr[mid]) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        } else if (arr[mid] < arr[r]) {
+            if (arr[mid] < target && target <= arr[r]) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        } else {
+            --r;
+        }
+    }
+    return arr[l] === target ? l : -1;
+}
diff --git a/solution/0000-0099/0081.Search in Rotated Sorted Array II/README.md b/solution/0000-0099/0081.Search in Rotated Sorted Array II/README.md
index 739660f04227e..aab296a90860f 100644
--- a/solution/0000-0099/0081.Search in Rotated Sorted Array II/README.md	
+++ b/solution/0000-0099/0081.Search in Rotated Sorted Array II/README.md	
@@ -57,6 +57,18 @@
 
 **方法一：二分查找**
 
+我们定义二分查找的左边界 $l=0$，右边界 $r=n-1$，其中 $n$ 为数组的长度。
+
+每次在二分查找的过程中，我们会得到当前的中点 $mid=(l+r)/2$。
+
+-   如果 $nums[mid] \gt nums[r]$，说明 $[l,mid]$ 是有序的，此时如果 $nums[l] \le target \le nums[mid]$，说明 $target$ 位于 $[l,mid]$，否则 $target$ 位于 $[mid+1,r]$。
+-   如果 $nums[mid] \lt nums[r]$，说明 $[mid+1,r]$ 是有序的，此时如果 $nums[mid] \lt target \le nums[r]$，说明 $target$ 位于 $[mid+1,r]$，否则 $target$ 位于 $[l,mid]$。
+-   如果 $nums[mid] = nums[r]$，说明元素 $nums[mid]$ 和 $nums[r]$ 相等，此时无法判断 $target$ 位于哪个区间，我们只能将 $r$ 减少 $1$。
+
+二分查找结束后，如果 $nums[l] = target$，则说明数组中存在目标值 $target$，否则说明不存在。
+
+时间复杂度近似 $O(\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -66,24 +78,23 @@
 ```python
 class Solution:
     def search(self, nums: List[int], target: int) -> bool:
-        l, r = 0, len(nums) - 1
-        while l <= r:
+        n = len(nums)
+        l, r = 0, n - 1
+        while l < r:
             mid = (l + r) >> 1
-            if nums[mid] == target:
-                return True
-            if nums[mid] < nums[r] or nums[mid] < nums[l]:
-                if target > nums[mid] and target <= nums[r]:
-                    l = mid + 1
-                else:
-                    r = mid - 1
-            elif nums[mid] > nums[l] or nums[mid] > nums[r]:
-                if target < nums[mid] and target >= nums[l]:
-                    r = mid - 1
+            if nums[mid] > nums[r]:
+                if nums[l] <= target <= nums[mid]:
+                    r = mid
                 else:
                     l = mid + 1
+            elif nums[mid] < nums[r]:
+                if nums[mid] < target <= nums[r]:
+                    l = mid + 1
+                else:
+                    r = mid
             else:
                 r -= 1
-        return False
+        return nums[l] == target
 ```
 
 ### **Java**
@@ -94,57 +105,113 @@ class Solution:
 class Solution {
     public boolean search(int[] nums, int target) {
         int l = 0, r = nums.length - 1;
-        while (l <= r) {
-            int mid = (l + r) >>> 1;
-            if (nums[mid] == target) return true;
-            if (nums[mid] < nums[r] || nums[mid] < nums[l]) {
-                if (target > nums[mid] && target <= nums[r])
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] > nums[r]) {
+                if (nums[l] <= target && target <= nums[mid]) {
+                    r = mid;
+                } else {
                     l = mid + 1;
-                else
-                    r = mid - 1;
-            } else if (nums[mid] > nums[l] || nums[mid] > nums[r]) {
-                if (target < nums[mid] && target >= nums[l])
-                    r = mid - 1;
-                else
+                }
+            } else if (nums[mid] < nums[r]) {
+                if (nums[mid] < target && target <= nums[r]) {
                     l = mid + 1;
-            } else
-                r--;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
         }
-        return false;
+        return nums[l] == target;
     }
 }
 ```
 
 ### **C++**
 
-<!-- 这里可写当前语言的特殊实现逻辑 -->
-
 ```cpp
 class Solution {
 public:
     bool search(vector<int>& nums, int target) {
         int l = 0, r = nums.size() - 1;
-        while (l <= r) {
+        while (l < r) {
             int mid = (l + r) >> 1;
-            if (nums[mid] == target) return true;
-            if (nums[mid] < nums[r] || nums[mid] < nums[l]) {
-                if (target > nums[mid] && target <= nums[r])
+            if (nums[mid] > nums[r]) {
+                if (nums[l] <= target && target <= nums[mid]) {
+                    r = mid;
+                } else {
                     l = mid + 1;
-                else
-                    r = mid - 1;
-            } else if (nums[mid] > nums[l] || nums[mid] > nums[r]) {
-                if (target < nums[mid] && target >= nums[l])
-                    r = mid - 1;
-                else
+                }
+            } else if (nums[mid] < nums[r]) {
+                if (nums[mid] < target && target <= nums[r]) {
                     l = mid + 1;
-            } else
-                r--;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
         }
-        return false;
+        return nums[l] == target;
     }
 };
 ```
 
+### **Go**
+
+```go
+func search(nums []int, target int) bool {
+	l, r := 0, len(nums)-1
+	for l < r {
+		mid := (l + r) >> 1
+		if nums[mid] > nums[r] {
+			if nums[l] <= target && target <= nums[mid] {
+				r = mid
+			} else {
+				l = mid + 1
+			}
+		} else if nums[mid] < nums[r] {
+			if nums[mid] < target && target <= nums[r] {
+				l = mid + 1
+			} else {
+				r = mid
+			}
+		} else {
+			r--
+		}
+	}
+	return nums[l] == target
+}
+```
+
+### **TypeScript**
+
+```ts
+function search(nums: number[], target: number): boolean {
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] > nums[r]) {
+            if (nums[l] <= target && target <= nums[mid]) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        } else if (nums[mid] < nums[r]) {
+            if (nums[mid] < target && target <= nums[r]) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        } else {
+            --r;
+        }
+    }
+    return nums[l] === target;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0000-0099/0081.Search in Rotated Sorted Array II/README_EN.md b/solution/0000-0099/0081.Search in Rotated Sorted Array II/README_EN.md
index 31ba3ce61e1d3..f75208393853c 100644
--- a/solution/0000-0099/0081.Search in Rotated Sorted Array II/README_EN.md	
+++ b/solution/0000-0099/0081.Search in Rotated Sorted Array II/README_EN.md	
@@ -42,24 +42,23 @@
 ```python
 class Solution:
     def search(self, nums: List[int], target: int) -> bool:
-        l, r = 0, len(nums) - 1
-        while l <= r:
+        n = len(nums)
+        l, r = 0, n - 1
+        while l < r:
             mid = (l + r) >> 1
-            if nums[mid] == target:
-                return True
-            if nums[mid] < nums[r] or nums[mid] < nums[l]:
-                if target > nums[mid] and target <= nums[r]:
-                    l = mid + 1
-                else:
-                    r = mid - 1
-            elif nums[mid] > nums[l] or nums[mid] > nums[r]:
-                if target < nums[mid] and target >= nums[l]:
-                    r = mid - 1
+            if nums[mid] > nums[r]:
+                if nums[l] <= target <= nums[mid]:
+                    r = mid
                 else:
                     l = mid + 1
+            elif nums[mid] < nums[r]:
+                if nums[mid] < target <= nums[r]:
+                    l = mid + 1
+                else:
+                    r = mid
             else:
                 r -= 1
-        return False
+        return nums[l] == target
 ```
 
 ### **Java**
@@ -68,57 +67,113 @@ class Solution:
 class Solution {
     public boolean search(int[] nums, int target) {
         int l = 0, r = nums.length - 1;
-        while (l <= r) {
-            int mid = (l + r) >>> 1;
-            if (nums[mid] == target) return true;
-            if (nums[mid] < nums[r] || nums[mid] < nums[l]) {
-                if (target > nums[mid] && target <= nums[r])
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] > nums[r]) {
+                if (nums[l] <= target && target <= nums[mid]) {
+                    r = mid;
+                } else {
                     l = mid + 1;
-                else
-                    r = mid - 1;
-            } else if (nums[mid] > nums[l] || nums[mid] > nums[r]) {
-                if (target < nums[mid] && target >= nums[l])
-                    r = mid - 1;
-                else
+                }
+            } else if (nums[mid] < nums[r]) {
+                if (nums[mid] < target && target <= nums[r]) {
                     l = mid + 1;
-            } else
-                r--;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
         }
-        return false;
+        return nums[l] == target;
     }
 }
 ```
 
 ### **C++**
 
-<!-- 这里可写当前语言的特殊实现逻辑 -->
-
 ```cpp
 class Solution {
 public:
     bool search(vector<int>& nums, int target) {
         int l = 0, r = nums.size() - 1;
-        while (l <= r) {
+        while (l < r) {
             int mid = (l + r) >> 1;
-            if (nums[mid] == target) return true;
-            if (nums[mid] < nums[r] || nums[mid] < nums[l]) {
-                if (target > nums[mid] && target <= nums[r])
+            if (nums[mid] > nums[r]) {
+                if (nums[l] <= target && target <= nums[mid]) {
+                    r = mid;
+                } else {
                     l = mid + 1;
-                else
-                    r = mid - 1;
-            } else if (nums[mid] > nums[l] || nums[mid] > nums[r]) {
-                if (target < nums[mid] && target >= nums[l])
-                    r = mid - 1;
-                else
+                }
+            } else if (nums[mid] < nums[r]) {
+                if (nums[mid] < target && target <= nums[r]) {
                     l = mid + 1;
-            } else
-                r--;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
         }
-        return false;
+        return nums[l] == target;
     }
 };
 ```
 
+### **Go**
+
+```go
+func search(nums []int, target int) bool {
+	l, r := 0, len(nums)-1
+	for l < r {
+		mid := (l + r) >> 1
+		if nums[mid] > nums[r] {
+			if nums[l] <= target && target <= nums[mid] {
+				r = mid
+			} else {
+				l = mid + 1
+			}
+		} else if nums[mid] < nums[r] {
+			if nums[mid] < target && target <= nums[r] {
+				l = mid + 1
+			} else {
+				r = mid
+			}
+		} else {
+			r--
+		}
+	}
+	return nums[l] == target
+}
+```
+
+### **TypeScript**
+
+```ts
+function search(nums: number[], target: number): boolean {
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] > nums[r]) {
+            if (nums[l] <= target && target <= nums[mid]) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        } else if (nums[mid] < nums[r]) {
+            if (nums[mid] < target && target <= nums[r]) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        } else {
+            --r;
+        }
+    }
+    return nums[l] === target;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.cpp b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.cpp
index eefc21a467c33..17f555845eb49 100644
--- a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.cpp	
+++ b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.cpp	
@@ -1,23 +1,25 @@
-class Solution {
-public:
-    bool search(vector<int>& nums, int target) {
-        int l = 0, r = nums.size() - 1;
-        while (l <= r) {
-            int mid = (l + r) >> 1;
-            if (nums[mid] == target) return true;
-            if (nums[mid] < nums[r] || nums[mid] < nums[l]) {
-                if (target > nums[mid] && target <= nums[r])
-                    l = mid + 1;
-                else
-                    r = mid - 1;
-            } else if (nums[mid] > nums[l] || nums[mid] > nums[r]) {
-                if (target < nums[mid] && target >= nums[l])
-                    r = mid - 1;
-                else
-                    l = mid + 1;
-            } else
-                r--;
-        }
-        return false;
-    }
+class Solution {
+public:
+    bool search(vector<int>& nums, int target) {
+        int l = 0, r = nums.size() - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] > nums[r]) {
+                if (nums[l] <= target && target <= nums[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (nums[mid] < nums[r]) {
+                if (nums[mid] < target && target <= nums[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return nums[l] == target;
+    }
 };
\ No newline at end of file
diff --git a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.go b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.go
new file mode 100644
index 0000000000000..52e00131f95b8
--- /dev/null
+++ b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.go	
@@ -0,0 +1,22 @@
+func search(nums []int, target int) bool {
+	l, r := 0, len(nums)-1
+	for l < r {
+		mid := (l + r) >> 1
+		if nums[mid] > nums[r] {
+			if nums[l] <= target && target <= nums[mid] {
+				r = mid
+			} else {
+				l = mid + 1
+			}
+		} else if nums[mid] < nums[r] {
+			if nums[mid] < target && target <= nums[r] {
+				l = mid + 1
+			} else {
+				r = mid
+			}
+		} else {
+			r--
+		}
+	}
+	return nums[l] == target
+}
\ No newline at end of file
diff --git a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.java b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.java
index b07c4a96aff60..c95536a02e9c0 100644
--- a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.java	
+++ b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.java	
@@ -1,22 +1,24 @@
-class Solution {
-    public boolean search(int[] nums, int target) {
-        int l = 0, r = nums.length - 1;
-        while (l <= r) {
-            int mid = (l + r) >>> 1;
-            if (nums[mid] == target) return true;
-            if (nums[mid] < nums[r] || nums[mid] < nums[l]) {
-                if (target > nums[mid] && target <= nums[r])
-                    l = mid + 1;
-                else
-                    r = mid - 1;
-            } else if (nums[mid] > nums[l] || nums[mid] > nums[r]) {
-                if (target < nums[mid] && target >= nums[l])
-                    r = mid - 1;
-                else
-                    l = mid + 1;
-            } else
-                r--;
-        }
-        return false;
-    }
+class Solution {
+    public boolean search(int[] nums, int target) {
+        int l = 0, r = nums.length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] > nums[r]) {
+                if (nums[l] <= target && target <= nums[mid]) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            } else if (nums[mid] < nums[r]) {
+                if (nums[mid] < target && target <= nums[r]) {
+                    l = mid + 1;
+                } else {
+                    r = mid;
+                }
+            } else {
+                --r;
+            }
+        }
+        return nums[l] == target;
+    }
 }
\ No newline at end of file
diff --git a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.py b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.py
index 13297923c7a77..972d774f6c38c 100644
--- a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.py	
+++ b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.py	
@@ -1,20 +1,19 @@
-class Solution:
-    def search(self, nums: List[int], target: int) -> bool:
-        l, r = 0, len(nums) - 1
-        while l <= r:
-            mid = (l + r) >> 1
-            if nums[mid] == target:
-                return True
-            if nums[mid] < nums[r] or nums[mid] < nums[l]:
-                if target > nums[mid] and target <= nums[r]:
-                    l = mid + 1
-                else:
-                    r = mid - 1
-            elif nums[mid] > nums[l] or nums[mid] > nums[r]:
-                if target < nums[mid] and target >= nums[l]:
-                    r = mid - 1
-                else:
-                    l = mid + 1
-            else:
-                r -= 1
-        return False
+class Solution:
+    def search(self, nums: List[int], target: int) -> bool:
+        n = len(nums)
+        l, r = 0, n - 1
+        while l < r:
+            mid = (l + r) >> 1
+            if nums[mid] > nums[r]:
+                if nums[l] <= target <= nums[mid]:
+                    r = mid
+                else:
+                    l = mid + 1
+            elif nums[mid] < nums[r]:
+                if nums[mid] < target <= nums[r]:
+                    l = mid + 1
+                else:
+                    r = mid
+            else:
+                r -= 1
+        return nums[l] == target
diff --git a/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.ts b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.ts
new file mode 100644
index 0000000000000..a1f25dbd0016b
--- /dev/null
+++ b/solution/0000-0099/0081.Search in Rotated Sorted Array II/Solution.ts	
@@ -0,0 +1,22 @@
+function search(nums: number[], target: number): boolean {
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] > nums[r]) {
+            if (nums[l] <= target && target <= nums[mid]) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        } else if (nums[mid] < nums[r]) {
+            if (nums[mid] < target && target <= nums[r]) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        } else {
+            --r;
+        }
+    }
+    return nums[l] === target;
+}