**Physical Address**

304 North Cardinal St.

Dorchester Center, MA 02124

Suppose an array of length `n`

sorted in ascending order is **rotated** between `1`

and `n`

times. For example, the array `nums = [0,1,2,4,5,6,7]`

might become:

`[4,5,6,7,0,1,2]`

if it was rotated`4`

times.`[0,1,2,4,5,6,7]`

if it was rotated`7`

times.

Notice that **rotating** an array `[a[0], a[1], a[2], ..., a[n-1]]`

1 time results in the array `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`

.

Given the sorted rotated array `nums`

of **unique** elements, return *the minimum element of this array*.

You must write an algorithm that runs in `O(log n) time.`

**Example 1:**

```
Input: nums = [3,4,5,1,2]
Output: 1
Explanation: The original array was [1,2,3,4,5] rotated 3 times.
```

**Example 2:**

```
Input: nums = [4,5,6,7,0,1,2]
Output: 0
Explanation: The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
```

**Example 3:**

```
Input: nums = [11,13,15,17]
Output: 11
Explanation: The original array was [11,13,15,17] and it was rotated 4 times.
```

**Constraints:**

`n == nums.length`

`1 <= n <= 5000`

`-5000 <= nums[i] <= 5000`

- All the integers of
`nums`

are**unique**. `nums`

is sorted and rotated between`1`

and`n`

times.

```
int findMin(vector<int> &num) {
int start=0,end=num.size()-1;
while (start<end) {
if (num[start]<num[end])
return num[start];
int mid = (start+end)/2;
if (num[mid]>=num[start]) {
start = mid+1;
} else {
end = mid;
}
}
return num[start];
}
```

```
public class Solution {
public int findMin(int[] num) {
if (num == null || num.length == 0) {
return 0;
}
if (num.length == 1) {
return num[0];
}
int start = 0, end = num.length - 1;
while (start < end) {
int mid = (start + end) / 2;
if (mid > 0 && num[mid] < num[mid - 1]) {
return num[mid];
}
if (num[start] <= num[mid] && num[mid] > num[end]) {
start = mid + 1;
} else {
end = mid - 1;
}
}
return num[start];
}
}
```

```
class Solution:
def findMin(self, nums: List[int]) -> int:
if len(nums) == 1 or nums[0] < nums[-1]:
return nums[0]
left, right = 0, len(nums) - 1
while left <= right:
mid = left + (right - left) // 2
if mid > 0 and nums[mid - 1] > nums[mid]: # The nums[mid] is the minimum number
return nums[mid]
if nums[mid] > nums[right]: # search on the right side, because smaller elements are in the right side
left = mid + 1
else:
right = mid - 1 # search the minimum in the left side
```

In our experience, we suggest you solve this Find Minimum in Rotated Sorted Array LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Find Minimum in Rotated Sorted Array LeetCode Solution

I hope this Find Minimum in Rotated Sorted Array LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

**More Coding Solutions >>**