---
title: '153. Find Minimum in Rotated Sorted Array'
description: '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:'
sidebar:
  label: 'Find Minimum in Rotated Sorted Array'
  badge: 'Medium'
---

Array

::::warning
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]].
::::

### 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.

## Approach

```mermaid
flowchart TD
  S(["findMin(nums)"]) --> I["l = 0, r = n-1, lowest_index = -1"]
  I --> W{"l <= r?"}
  W -- no --> E(["return nums[lowest_index]"])
  W -- yes --> M["m = (l + r) // 2"]
  M --> C{"nums[m] <= nums[-1]?"}
  C -- yes --> A["in the right sorted run: record lowest_index = m, r = m - 1"]
  A --> W
  C -- no --> B["still in the left sorted run: l = m + 1"]
  B --> W
```

## Solution

```py
class Solution:
    def findMin(self, nums: List[int]) -> int:
        l, r = 0, len(nums) - 1
        lowest_index = -1

        while l <= r:
            m = (l + r) // 2
            if nums[m] <= nums[-1]:
                lowest_index = m
                r = m - 1
            else:
                l = m + 1

        return nums[lowest_index]
```

## Explanation

[Find Minimum in Rotated Sorted Array - Binary Search - Leetcode 153 - Python](https://www.youtube.com/watch?v=nIVW4P8b1VA)