How do you approach Summary Ranges?

The array is sorted and unique, so a run of consecutive integers is a stretch where each element is exactly one more than the previous.

What is the time complexity of Summary Ranges?

Time complexity: O(n) - each element visited once. Space complexity: O(1) beyond the output list.

What are common mistakes on Summary Ranges?

Storing the current value before checking for its complement, which lets an element pair with itself. Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n). Using a plain object as the map when keys may be numbers or __proto__; a real hash-map type keeps key identity intact.

gitGood.dev

← Back to problems

Summary Ranges

EasyAlgorithms

Description

You are given a **sorted unique** integer array `nums`. A **range** `[a,b]` is the set of all integers from `a` to `b` (inclusive). Return the **smallest sorted** list of ranges that **cover all the numbers in the array exactly**. That is, each element of `nums` is covered by exactly one of the ranges, and there is no integer `x` such that `x` is in one of the ranges but not in `nums`. 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,2,4,5,7]

Output: ["0->2","4->5","7"]

Explanation: 0,1,2 form one consecutive run; 4,5 form another; 7 stands alone.

Example 2

Input: nums = [0,2,3,4,6,8,9]

Output: ["0","2->4","6","8->9"]

Example 3

Input: nums = []

Output: []

Constraints

- 0 <= nums.length <= 20 - -2^31 <= nums[i] <= 2^31 - 1 - All the values of nums are unique. - nums is sorted in ascending order.

Summary Ranges: approach, complexity and pitfalls

An easy arrays & hashing problem, graded against 7 test cases (4 of them hidden).

The pattern: Arrays & Hashing

Hash maps and sets to trade memory for time - the most common first instinct in interviews.

Reach for it when you see: "Have I seen this before?", counting occurrences, or an O(n²) scan you want to make O(n).

More Arrays & Hashingproblems →

If you are stuck

Show the 3-step hint ladder

The array is sorted and unique, so a run of consecutive integers is a stretch where each element is exactly one more than the previous.
Walk the array with a pointer: remember where the current run started, then extend while nums[i+1] == nums[i] + 1.
When the run ends, emit either 'start' (single element) or 'start->end', then begin the next run.

The optimal approach

Show the approach: Single Scan with Run Detection

Scan left to right. Mark the start of the current run, then keep advancing while the next value is exactly one greater. When the run breaks, format it - a single number as `"a"`, a longer run as `"a->b"` - and start a new run at the next element.

Time: O(n) - each element visited once
Space: O(1) beyond the output list

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Empty input. At least one case passes an empty collection. Make sure your loop bounds and any "first element" read survive a length of zero.
Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Negative numbers. The suite includes negative values. Running-sum, min/max seeding and any "initialise to zero" step need to handle them.
Zero. Zero appears in the input, which is the value most likely to break a truthiness check used in place of an explicit comparison.

Common Arrays & Hashing mistakes

These apply to the pattern as a whole, not just this problem.

Storing the current value before checking for its complement, which lets an element pair with itself.
Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n).
Using a plain object as the map when keys may be numbers or `__proto__`; a real hash-map type keeps key identity intact.