> For the complete documentation index, see [llms.txt](https://jaywin.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jaywin.gitbook.io/leetcode/solutions/0163-missing-ranges.md).

# 0163. Missing Ranges

<https://leetcode.com/problems/missing-ranges>

## Description

You are given an inclusive range `[lower, upper]` and a **sorted unique** integer array `nums`, where all elements are in the inclusive range.

A number `x` is considered **missing** if `x` is in the range `[lower, upper]` and `x` is not in `nums`.

Return *the **smallest sorted** list of ranges that **cover every missing number exactly***. That is, no element of `nums` is in any of the ranges, and each missing number is in one of the ranges.

Each range `[a,b]` in the list should be output as:

* `"a->b"` if `a != b`
* `"a"` if `a == b`

**Example 1:**

```
**Input:** nums = [0,1,3,50,75], lower = 0, upper = 99
**Output:** ["2","4->49","51->74","76->99"]
**Explanation:** The ranges are:
[2,2] --> "2"
[4,49] --> "4->49"
[51,74] --> "51->74"
[76,99] --> "76->99"
```

**Example 2:**

```
**Input:** nums = [], lower = 1, upper = 1
**Output:** ["1"]
**Explanation:** The only missing range is [1,1], which becomes "1".
```

**Example 3:**

```
**Input:** nums = [], lower = -3, upper = -1
**Output:** ["-3->-1"]
**Explanation:** The only missing range is [-3,-1], which becomes "-3->-1".
```

**Example 4:**

```
**Input:** nums = [-1], lower = -1, upper = -1
**Output:** []
**Explanation:** There are no missing ranges since there are no missing numbers.
```

**Example 5:**

```
**Input:** nums = [-1], lower = -2, upper = -1
**Output:** ["-2"]
```

**Constraints:**

* `-109 <= lower <= upper <= 109`
* `0 <= nums.length <= 100`
* `lower <= nums[i] <= upper`
* All the values of `nums` are **unique**.

## ac

```java
class Solution {
    public List<String> findMissingRanges(int[] nums, int lower, int upper) {
        // two pointers,i & j, for loop j (check nums.length > 2), if [j] == [j-1]+1 continue, else handle
        // left, right, if l == r, add only l. else add l->r.
        // handle first and last.

        List<String> res = new ArrayList<String>();
        int n = nums.length;
        // edge cases
        if (n == 0) {
            addRange(res, lower, upper);
            return res;
        }

        // first one
        if (lower < nums[0]) {
            addRange(res, lower, nums[0]-1);
        }

        // body
        if (n >= 2) {
            for (int i = 1; i < n; i++) {
                long diff = (long)nums[i] - (long)nums[i-1];
                if (diff == 1) continue;
                // stop, check value
                if (diff >= 2) {
                    addRange(res, nums[i-1]+1, nums[i]-1);
                } 
            }
        }

        // last
        if (nums[n-1] < upper) {
            addRange(res, nums[n-1]+1, upper);
        }

        return res;
    }
    private void addRange(List<String> res, int l, int r) {
        if (l == r) {
            res.add(l+"");
        } else if (l < r) {
            res.add(l+"->"+r);
        }
    }
}
```