What happens if you not handling single-element ranges correctly?

Output includes 'start->start' instead of just 'start' Fix: Add condition to check if start == end and output accordingly

What happens if you off-by-one errors in loops when detecting consecutive sequences?

Misses last element or causes index out of range errors Fix: Carefully check loop boundaries and conditions

What happens if you not adding the last range after loop ends?

Last consecutive range is omitted from output Fix: Add code after loop to append the final range

What happens if you assuming input array is always non-empty without checking?

Code crashes or returns wrong output on empty input Fix: Add guard clause to handle empty input

Interview Prepknowing-what-to-trackeasyGoogleAmazonFacebook

Summary Ranges

Choose your preparation mode4 modes available

Try It Solution Trace

🎯

Summary Ranges

easyHASH_MAPGoogleAmazonFacebook

Imagine you have a list of days when a user logged into an app, and you want to summarize their activity by grouping consecutive login days into ranges.

💡 This problem is about detecting consecutive sequences in a sorted list and summarizing them compactly. Beginners often struggle with tracking the start and end of runs and handling edge cases like single-element ranges.

📋

Problem Statement

Given a sorted unique integer array nums, 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, and as 'a' if a == b.

1 ≤ nums.length ≤ 10^5-10^9 ≤ nums[i] ≤ 10^9nums is sorted in ascending order and all elements are unique

💡

Example

Input"[0,1,2,4,5,7]"

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

The numbers 0,1,2 form a consecutive range, 4,5 form another, and 7 stands alone.

Input"[0,2,3,4,6,8,9]"

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

0 is alone, 2,3,4 form a range, 6 alone, and 8,9 form a range.

Single element array → output is just that element as a string
All elements are consecutive → one big range
No consecutive elements → all single-element ranges
Negative and positive numbers mixed → ranges still valid

⚠️

Common Mistakes

Not handling single-element ranges correctly

Output includes 'start->start' instead of just 'start'

✅ Add condition to check if start == end and output accordingly

Off-by-one errors in loops when detecting consecutive sequences

Misses last element or causes index out of range errors

✅ Carefully check loop boundaries and conditions

Not adding the last range after loop ends

Last consecutive range is omitted from output

✅ Add code after loop to append the final range

Assuming input array is always non-empty without checking

Code crashes or returns wrong output on empty input

✅ Add guard clause to handle empty input

Using nested loops unnecessarily leading to inefficient solutions

Solution times out on large inputs

✅ Use single pass or two pointers approach for O(n) time

🧠

Brute Force (Nested Loops to Detect Ranges)

💡 Starting with brute force helps understand the problem deeply by explicitly checking every possible consecutive range, even if inefficient.

Intuition

Scan the array from left to right, for each number try to find the longest consecutive range by checking subsequent elements until the sequence breaks.

Algorithm

Initialize an empty list to store ranges.
Use an outer loop to pick the start of a range.
Use an inner loop to move forward while numbers are consecutive.
Add the found range to the result and continue from the next number.

💡 Nested loops make it clear how consecutive sequences are detected but can be inefficient for large inputs.

</>

Code

from typing import List

def summaryRanges(nums: List[int]) -> List[str]:
    ranges = []
    n = len(nums)
    i = 0
    while i < n:
        start = nums[i]
        j = i
        while j + 1 < n and nums[j + 1] == nums[j] + 1:
            j += 1
        end = nums[j]
        if start == end:
            ranges.append(str(start))
        else:
            ranges.append(f"{start}->{end}")
        i = j + 1
    return ranges

# Example usage
if __name__ == "__main__":
    print(summaryRanges([0,1,2,4,5,7]))  # ['0->2', '4->5', '7']

Line Notes

ranges = []Initialize the list to store the final ranges

n = len(nums)Store length of input for loop control

i = 0Initialize index to start scanning from the beginning

while i < n:Outer loop to iterate over all elements

start = nums[i]Mark the start of the current range

j = iInitialize inner loop index to current start

while j + 1 < n and nums[j + 1] == nums[j] + 1:Inner loop to find the end of the consecutive range

j += 1Advance inner loop index while consecutive

end = nums[j]Mark the end of the current consecutive range

if start == end:Check if the range is a single number or multiple

ranges.append(str(start))Add single number as string if no range

ranges.append(f"{start}->{end}")Add range string if multiple numbers

i = j + 1Move to the next new start after the current range

return rangesReturn the list of range strings

import java.util.*;

public class SummaryRanges {
    public static List<String> summaryRanges(int[] nums) {
        List<String> ranges = new ArrayList<>();
        int n = nums.length;
        int i = 0;
        while (i < n) {
            int start = nums[i];
            int j = i;
            while (j + 1 < n && nums[j + 1] == nums[j] + 1) {
                j++;
            }
            int end = nums[j];
            if (start == end) {
                ranges.add(String.valueOf(start));
            } else {
                ranges.add(start + "->" + end);
            }
            i = j + 1;
        }
        return ranges;
    }

    public static void main(String[] args) {
        int[] nums = {0,1,2,4,5,7};
        System.out.println(summaryRanges(nums)); // ["0->2", "4->5", "7"]
    }
}

Line Notes

List<String> ranges = new ArrayList<>();Create list to hold range strings

int n = nums.length;Store length of input array

int i = 0;Initialize index for outer loop

while (i < n) {Outer loop to process all elements

int start = nums[i];Start of current range

int j = i;Initialize inner loop index

while (j + 1 < n && nums[j + 1] == nums[j] + 1) {Find consecutive sequence end

j++;Advance inner loop index while consecutive

int end = nums[j];Mark end of current range

if (start == end) {Check if single number or range

ranges.add(String.valueOf(start));Add single number as string

ranges.add(start + "->" + end);Add range string

i = j + 1;Move index past current range

return ranges;Return list of ranges

#include <iostream>
#include <vector>
#include <string>

using namespace std;

vector<string> summaryRanges(vector<int>& nums) {
    vector<string> ranges;
    int n = nums.size();
    int i = 0;
    while (i < n) {
        int start = nums[i];
        int j = i;
        while (j + 1 < n && nums[j + 1] == nums[j] + 1) {
            j++;
        }
        int end = nums[j];
        if (start == end) {
            ranges.push_back(to_string(start));
        } else {
            ranges.push_back(to_string(start) + "->" + to_string(end));
        }
        i = j + 1;
    }
    return ranges;
}

int main() {
    vector<int> nums = {0,1,2,4,5,7};
    vector<string> res = summaryRanges(nums);
    for (auto &s : res) cout << s << " ";
    cout << endl;
    return 0;
}

Line Notes

vector<string> ranges;Initialize vector to store ranges

int n = nums.size();Get size of input vector

int i = 0;Initialize index for outer loop

while (i < n) {Loop over all elements

int start = nums[i];Mark start of current range

int j = i;Initialize inner loop index

while (j + 1 < n && nums[j + 1] == nums[j] + 1) {Find consecutive sequence end

j++;Advance inner loop index while consecutive

int end = nums[j];Mark end of current range

if (start == end) {Check if single number or range

ranges.push_back(to_string(start));Add single number as string

ranges.push_back(to_string(start) + "->" + to_string(end));Add range string

i = j + 1;Move index past current range

return ranges;Return vector of ranges

function summaryRanges(nums) {
    const ranges = [];
    const n = nums.length;
    let i = 0;
    while (i < n) {
        const start = nums[i];
        let j = i;
        while (j + 1 < n && nums[j + 1] === nums[j] + 1) {
            j++;
        }
        const end = nums[j];
        if (start === end) {
            ranges.push(start.toString());
        } else {
            ranges.push(`${start}->${end}`);
        }
        i = j + 1;
    }
    return ranges;
}

// Example usage
console.log(summaryRanges([0,1,2,4,5,7])); // ['0->2', '4->5', '7']

Line Notes

const ranges = [];Initialize array to hold range strings

const n = nums.length;Store length of input array

let i = 0;Initialize index for outer loop

while (i < n) {Loop through all numbers

const start = nums[i];Start of current consecutive range

let j = i;Initialize inner loop index

while (j + 1 < n && nums[j + 1] === nums[j] + 1) {Find end of consecutive range

j++;Advance inner loop index while consecutive

const end = nums[j];Mark end of current range

if (start === end) {Check if single number or range

ranges.push(start.toString());Add single number as string

ranges.push(`${start}->${end}`);Add range string

i = j + 1;Move index past current range

return ranges;Return array of ranges

⏱

Complexity

TimeO(n)

SpaceO(n)

Although there is a nested loop, the inner loop advances the index j forward without resetting, so each element is visited at most once by the inner loop. Hence total time is linear in n.

💡 Even though it looks like nested loops, the inner loop moves forward through the array without going back, so total operations are proportional to n.

Interview Verdict: Accepted but inefficient for large inputs

This approach works and is easy to understand, but the nested loop structure can be misleading about efficiency. It is acceptable for small inputs but not optimal.

Approach	Time	Space	Stack Risk	Reconstruct	Use In Interview
1. Brute Force	`O(n)`	`O(n)`	No	N/A	Mention only - never code
2. Single Pass Linear Scan	`O(n)`	`O(n)`	No	N/A	Code this approach
3. Two Pointers	`O(n)`	`O(n)`	No	N/A	Optional alternative for clarity

Practice

(1/5)

1. The following code attempts to check if an array can be paired such that sums are divisible by k. Which line contains a subtle bug that causes incorrect results on some inputs?

def canArrange(nums, k):
    if len(nums) % 2 != 0:
        return True
    freq = {}
    for num in nums:
        r = ((num % k) + k) % k
        freq[r] = freq.get(r, 0) + 1
    if freq.get(0, 0) % 2 != 0:
        return False
    for r in freq:
        if r != 0:
            complement = (k - r) % k
            if freq.get(r, 0) != freq.get(complement, 0):
                return False
    if k % 2 == 0 and freq.get(k // 2, 0) % 2 != 0:
        return False
    return True

medium

A. Line 5: computing remainder without adjusting for negative numbers

B. Line 2: returning True when array length is odd

C. Line 8: checking if freq[0] count is even

D. Line 13: checking if freq[k//2] count is even when k is even

Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard

Intuition

Algorithm

Intuition

Algorithm

Intuition

Algorithm

How to Present

Time Allocation

What the Interviewer Tests

Common Follow-ups

When to Use

Signature Phrases

NOT This Pattern When

Similar Problems

Practice

Solution

Step 1: Check array length condition

Step 2: Verify other lines

Final Answer:

Quick Check:

Solution

Step 1: Identify where matches count is updated

Step 2: Locate missing matches adjustment

Final Answer:

Quick Check:

Solution

Step 1: Analyze outer and inner loops

Step 2: Confirm total operations

Final Answer:

Quick Check:

Solution

Step 1: Analyze the main loop and window adjustments

Step 2: Confirm no nested loops causing quadratic time

Final Answer:

Quick Check:

Solution

Step 1: Understand the reuse variant

Step 2: Recognize sliding window limitation

Step 3: Use DP approach

Final Answer:

Quick Check:

Ready to prove it?