AlgoMaster Logo

Summary Ranges

easyFrequency5 min readUpdated June 23, 2026

Understanding the Problem

We have a sorted array of unique integers, and we need to compress it into a list of ranges. Consecutive numbers get grouped into a single range like "a->b", while isolated numbers stand alone as "a".

Because the array is sorted and contains no duplicates, two values are consecutive integers exactly when one is one more than the other, and consecutive integers always sit next to each other in the array. So nums[i+1] == nums[i] + 1 means nums[i] and nums[i+1] belong to the same range. The first index where that relationship fails marks the end of the current range and the start of the next.

This is a grouping problem: scan through the array, find where each run of consecutive numbers starts and ends, and format each run as a string.

Key Constraints:

  • -2^31 <= nums[i] <= 2^31 - 1 - Values span the full 32-bit signed integer range. The expression nums[i] + 1 only runs when i + 1 < n, which means nums[i] < nums[i+1] <= 2^31 - 1, so nums[i] is at most 2^31 - 2 and the addition never overflows. Comparing endpoints with start == nums[i] is also safe. Avoid a length check like nums[i] - start, which would overflow when a range spans most of the integer axis.
  • nums is sorted and unique - No need to sort or deduplicate. The ordering supports a single linear pass.

Approach 1: Scan and Group with Index Tracking

Intuition

Walk through the array, and each time a break in the consecutive sequence appears, record the range that ended at the previous element.

Remember the value where the current range begins. Then keep advancing as long as the next number is one more than the current. At a gap (or the end of the array), the range from the start value to the current value is complete. Format it and continue from the next element.

Algorithm

  1. Initialize an empty result list.
  2. Set i = 0 as the starting index.
  3. While i < n:
    • Record start = nums[i] as the beginning of a new range.
    • While i + 1 < n and nums[i + 1] == nums[i] + 1, advance i.
    • Now nums[i] is the end of the current range.
    • If start == nums[i], add "start" to the result. Otherwise, add "start->nums[i]".
    • Advance i to the next unprocessed element.
  4. Return the result list.

Example Walkthrough

1Initialize: i=0, start=0
0
0
i / start
1
1
2
2
3
4
4
5
5
7
1/8

Code

The next approach keeps the same linear pass but removes the inner loop, processing each element with a single comparison against the previous one.

Approach 2: Single Pass with Boundary Detection

Intuition

Approach 1 uses two nested loops: an outer loop that opens a range and an inner loop that consumes consecutive elements. The two loops can collapse into one.

Scan the array once with a single index. Hold the start value of the current range. At each element, compare it to the element before it. If the current element is one more than the previous one, the run is still going, so do nothing. If it is not, the previous element closed a range: format that range with the held start value as [start, nums[i-1]], then set the start value to the current element. After the loop, one range is still open (the final run), so format it with the last element as its end.

This avoids the manual index juggling of the inner while loop. Every element is touched once, and the only decision per element is whether it continues the current run or begins a new one.

Algorithm

  1. If the array is empty, return an empty list.
  2. Initialize the result list and set start = nums[0].
  3. For i from 1 to n-1:
    • If nums[i] != nums[i-1] + 1, the run ended at nums[i-1]. Append the range [start, nums[i-1]] (formatted as a single value when start == nums[i-1]), then set start = nums[i].
  4. After the loop, append the final range [start, nums[n-1]] using the same formatting rule.
  5. Return the result.

Example Walkthrough

1Initialize: start=0 (nums[0]). Scan from i=1.
0
start
0
1
2
2
3
3
4
4
6
5
8
6
9
1/8

Code