Summary Ranges

Problem Statement

You are given a sorted unique integer array nums. A range is defined as a contiguous sequence of elements. Return a list of the smallest set of ranges that cover all the numbers in the array exactly. That is, each element in nums is covered by exactly one range, and there is no integer x such that x is in one of the ranges but not in nums.

What to notice first

• The input array is already sorted and contains unique integers.
• You need to identify contiguous sequences (consecutive integers).
• A range with a single element should be represented as just that number, while a range with two or more elements should use the "start->end" format.

Examples

Input	Output	Explanation
[0, 1, 2, 4, 5, 7]	["0->2", "4->5", "7"]	Three ranges: 0-2, 4-5, and single 7
[0, 2, 3, 4, 6, 8, 9]	["0", "2->4", "6", "8->9"]	Four ranges with mixed single and multi
[]	[]	Empty input returns empty output

Constraints

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

Real-World Applications

Where this pattern appears

• IP address range summarization — combining consecutive IP addresses into CIDR blocks.
• Memory allocation tracking — representing allocated/freed memory blocks as ranges.
• Line number formatting — displaying line ranges in error reports (e.g., “lines 5-10, 15, 20-22”).
• Time slot consolidation — merging consecutive time slots in a calendar or scheduling system.

Complexity Comparison

Approach	Time	Space	Notes
Simulation	O(n)	O(1)	Single pass, build result on the fly
Two-Pointer	O(n)	O(1)	Cleaner boundary detection, explicit pointers

Both approaches have optimal time complexity. Choose based on code clarity preference.

Which approach should you learn first?

• Pick Simulation if you want a straightforward, single-loop implementation.
• Pick Two-Pointer if you prefer explicit boundary management.

Most Direct

Simulation

O(n) time · O(1) space

Explicit Boundaries

Two-Pointer

O(n) time · O(1) space

Approach 1: Simulation

★ Recommended

Iterate through the array once. Track the start of the current range. When a gap is found (consecutive check fails), finalize the current range and start a new one.

⏱ Time O(n) Single pass 💾 Space O(1) Only pointers

Step-by-step Example

Input: nums = [0, 1, 2, 4, 5, 7]

Step	i	nums[i]	Current Range	Action
1	-	-	start=0	Initialize with first element
2	1	1	0-1	Consecutive, continue
3	2	2	0-2	Consecutive, continue
4	3	4	-	Gap found! Save “0->2”, start=4
5	4	5	4-5	Consecutive, continue
6	5	7	-	Gap found! Save “4->5”, start=7
7	-	-	-	End of array, save “7”

Pseudocode

function summaryRanges(nums):
    if nums is empty:
        return []

    result = []
    start = nums[0]

    for i from 1 to len(nums) - 1:
        if nums[i] != nums[i-1] + 1:
            // Gap found, finalize range
            if start == nums[i-1]:
                result.append(str(start))
            else:
                result.append(str(start) + "->" + str(nums[i-1]))
            start = nums[i]

    // Add final range
    if start == nums[-1]:
        result.append(str(start))
    else:
        result.append(str(start) + "->" + str(nums[-1]))

    return result

Solution Code

Python

summary_ranges_simulation.py

from typing import List


def summary_ranges(nums: List[int]) -> List[str]:
    """
    Simulation approach: iterate through and build ranges as we go.
    Time: O(n), Space: O(1) excluding output
    """
    if not nums:
        return []

    result = []
    start = nums[0]

    for i in range(1, len(nums)):
        # If current number is not consecutive, finalize the range
        if nums[i] != nums[i - 1] + 1:
            if start == nums[i - 1]:
                result.append(str(start))
            else:
                result.append(f"{start}->{nums[i - 1]}")
            start = nums[i]

    # Add the last range
    if start == nums[-1]:
        result.append(str(start))
    else:
        result.append(f"{start}->{nums[-1]}")

    return result


print(summary_ranges([0, 1, 2, 4, 5, 7]))  # ["0->2","4->5","7"]
print(summary_ranges([0, 2, 3, 4, 6, 8, 9]))  # ["0","2->4","6","8->9"]

C++

summary_ranges_simulation.cpp

// Summary Ranges - SIMULATION
// Problem #228

// Implementation here

Java

Simulation.java

// Summary Ranges - SIMULATION
// Problem #228

// Implementation here

JavaScript

summary_ranges_simulation.js

// Summary Ranges - SIMULATION
// Problem #228

// Implementation here

Rust

summary_ranges_simulation.rs

// Summary Ranges - SIMULATION
// Problem #228

// Implementation here

Go

summary_ranges_simulation.go

// Summary Ranges - SIMULATION
// Problem #228

// Implementation here

Approach 2: Two-Pointer

🎯 Interview Favourite

Maintain explicit left and right pointers. The right pointer advances; when a gap is detected, both pointers define the current range.

⏱ Time O(n) Single pass 💾 Space O(1) Only pointers

Step-by-step Example

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

Step	left	right	nums[left]	nums[right]	Check	Action
1	0	0	0	0	Next (2) != 1	Save “0”, left=1
2	1	1	2	2	Next (3) == 3	Continue
3	1	2	2	3	Next (4) == 4	Continue
4	1	3	2	4	Next (6) != 5	Save “2->4”, left=4
5	4	4	6	6	Next (8) != 7	Save “6”, left=5
6	5	5	8	8	Next (9) == 9	Continue
7	5	6	8	9	End	Save “8->9”

Pseudocode

function summaryRanges(nums):
    if nums is empty:
        return []

    result = []
    left = 0

    for right from 0 to len(nums) - 1:
        // Check if this is the last element or next breaks sequence
        if right == len(nums) - 1 or nums[right + 1] != nums[right] + 1:
            if left == right:
                result.append(str(nums[left]))
            else:
                result.append(str(nums[left]) + "->" + str(nums[right]))
            left = right + 1

    return result

Solution Code

Python

summary_ranges_pointers.py

from typing import List


def summary_ranges(nums: List[int]) -> List[str]:
    """
    Two-pointer approach: explicitly track start and end pointers.
    Time: O(n), Space: O(1) excluding output
    """
    if not nums:
        return []

    result = []
    left = 0

    for right in range(len(nums)):
        # Check if next element breaks the sequence
        if right == len(nums) - 1 or nums[right + 1] != nums[right] + 1:
            if left == right:
                result.append(str(nums[left]))
            else:
                result.append(f"{nums[left]}->{nums[right]}")
            left = right + 1

    return result


print(summary_ranges([0, 1, 2, 4, 5, 7]))  # ["0->2","4->5","7"]
print(summary_ranges([0, 2, 3, 4, 6, 8, 9]))  # ["0","2->4","6","8->9"]

C++

summary_ranges_pointers.cpp

// Summary Ranges - POINTERS
// Problem #228

// Implementation here

Java

Pointers.java

// Summary Ranges - POINTERS
// Problem #228

// Implementation here

JavaScript

summary_ranges_pointers.js

// Summary Ranges - POINTERS
// Problem #228

// Implementation here

Rust

summary_ranges_pointers.rs

// Summary Ranges - POINTERS
// Problem #228

// Implementation here

Go

summary_ranges_pointers.go

// Summary Ranges - POINTERS
// Problem #228

// Implementation here

Approach 3: Optimized Two-Pointer

✓ Simple

A third approach demonstrating an alternative technique for solving this problem. This implementation optimizes either time or space complexity compared to the previous approaches.

⏱ Time O(n) Optimized complexity 💾 Space O(1) Efficient space usage

Pseudocode

function approach3():
    // Implementation approach goes here

Solution Code

Python

summary_ranges_optimized.py

"""
Solution for Summary Ranges
"""

def solve():
    """Implementation for approach 3 of Summary Ranges"""
    pass

if __name__ == "__main__":
    print("Solution ready")

C++

summary_ranges_optimized.cpp

#include <bits/stdc++.h>
using namespace std;

// Solution for Summary Ranges
// Approach 3: Implementation

int main() {{
    // Main implementation goes here
    return 0;
}}

Java

SummaryRangesOptimized.java

/**
 * Solution for Summary Ranges
 * Approach 3
 */
public class SummaryRangesOptimized {{

    public static void main(String[] args) {{
        // Implementation goes here
    }}
}}

JavaScript

summary_ranges_optimized.js

/**
 * Solution for Summary Ranges
 * Approach 3
 */

function solve() {{
    // Implementation goes here
}}

module.exports = solve;

Rust

summary_ranges_optimized.rs

/// Solution for Summary Ranges
/// Approach 3

fn main() {{
    println!("Solution implementation");
}}

Go

summary_ranges_optimized.go

package main

import "fmt"

// Solution for Summary Ranges
// Approach 3

func main() {{
    fmt.Println("Solution implementation")
}}

Common Mistakes

Watch for these pitfalls

• Off-by-one errors when checking if the next element is consecutive.
• Single-element confusion — forgetting that "7" (not "7->7") represents a single-number range.
• Integer overflow — in languages like C++/Java, be careful when calculating nums[i] + 1 for large integers.
• Empty array handling — returning the wrong type or not checking the empty case first.

Related Problems

• Merge Intervals ↗ Medium #56
• Insert Interval ↗ Medium #57
• Minimum Number of Arrows to Burst Balloons ↗ Medium #452

Interview Tips

Key trade-offs to discuss

• Simulation vs Two-Pointer: Both are O(n). Simulation is more implicit about when a range ends; two-pointer is more explicit. Neither has a clear advantage.
• Integer overflow: Mention that checking nums[i + 1] != nums[i] + 1 is safer than converting to long when possible.
• Edge cases to mention: Empty array, single-element array, and large integer values (especially negative numbers).
• Follow-up — Unsorted input: Would require sorting first (O(n log n)), then the same approach.

← Previous
#56 Merge Intervals Next
#56 Merge Intervals →