# Search in Rotated Sorted Array II Leetcode Solution

In this post, we are going to solve the Search in Rotated Sorted Array II Leetcode SolutionÂ problem of Leetcode. This Leetcode problem is done in many programming languages like C++, Java, and Python.

## Problem

There is an integer arrayÂ `nums`Â sorted in non-decreasing order (not necessarily withÂ distinctÂ values).

Before being passed to your function,Â `nums`Â isÂ rotatedÂ at an unknown pivot indexÂ `k`Â (`0 <= k < nums.length`) such that the resulting array isÂ `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]`Â (0-indexed). For example,Â `[0,1,2,4,4,4,5,6,6,7]`Â might be rotated at pivot indexÂ `5`Â and becomeÂ `[4,5,6,6,7,0,1,2,4,4]`.

Given the arrayÂ `nums`Â afterÂ the rotation and an integerÂ `target`, returnÂ `true`Â ifÂ `target`Â is inÂ `nums`, orÂ `false`Â if it is not inÂ `nums`.

You must decrease the overall operation steps as much as possible.

Example 1:

```Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true
```

Example 2:

```Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false
```

Constraints:

• `1 <= nums.length <= 5000`
• `-104Â <= nums[i] <= 104`
• `nums`Â is guaranteed to be rotated at some pivot.
• `-104Â <= target <= 104`

Now, letâ€™s see the leetcode solution ofÂ Search in Rotated Sorted Array II Leetcode Solution.

### Search in Rotated Sorted Array II Leetcode Solution in Python

```class Solution:
def search(self, nums: List[int], target: int) -> bool:
l = 0
r = len(nums) - 1

while l <= r:
m = (l + r) // 2
if nums[m] == target:
return True
if nums[l] == nums[m] == nums[r]:
l += 1
r -= 1
elif nums[l] <= nums[m]:  # nums[l..m] are sorted
if nums[l] <= target < nums[m]:
r = m - 1
else:
l = m + 1
else:  # nums[m..n - 1] are sorted
if nums[m] < target <= nums[r]:
l = m + 1
else:
r = m - 1

return False
```

### Search in Rotated Sorted Array II Leetcode Solutionin CPP

```class Solution {
public:
bool search(vector<int>& nums, int target) {
int l = 0;
int r = nums.size() - 1;

while (l <= r) {
const int m = (l + r) / 2;
if (nums[m] == target)
return true;
if (nums[l] == nums[m] && nums[m] == nums[r]) {
++l;
--r;
} else if (nums[l] <= nums[m]) {  // nums[l..m] are sorted
if (nums[l] <= target && target < nums[m])
r = m - 1;
else
l = m + 1;
} else {  // nums[m..n - 1] are sorted
if (nums[m] < target && target <= nums[r])
l = m + 1;
else
r = m - 1;
}
}

return false;
}
};
```

### Search in Rotated Sorted Array II Leetcode Solution in Java

```class Solution {
public boolean search(int[] nums, int target) {
int l = 0;
int r = nums.length - 1;

while (l <= r) {
final int m = (l + r) / 2;
if (nums[m] == target)
return true;
if (nums[l] == nums[m] && nums[m] == nums[r]) {
++l;
--r;
} else if (nums[l] <= nums[m]) { // nums[l..m] are sorted
if (nums[l] <= target && target < nums[m])
r = m - 1;
else
l = m + 1;
} else { // nums[m..n - 1] are sorted
if (nums[m] < target && target <= nums[r])
l = m + 1;
else
r = m - 1;
}
}

return false;
}
}
```

Note:Â This problemÂ Search in Rotated Sorted Array II is generated byÂ LeetcodeÂ but the solution is provided byÂ Chase2learn This tutorial is only forÂ EducationalÂ andÂ LearningÂ purposes.

Sharing Is Caring