anthropic/claude-sonnet-4.6 🖼️📝🔢 → 📝

def merge_intervals(intervals):
    """
    Merge all overlapping intervals and return a sorted list of non-overlapping intervals.

    Args:
        intervals (list[list[int]]): A list of [start, end] integer intervals.

    Returns:
        list[list[int]]: Merged, non-overlapping intervals in ascending order.

    Example:
        >>> merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]])
        [[1, 6], [8, 10], [15, 18]]

        >>> merge_intervals([[1, 4], [4, 5]])
        [[1, 5]]

        >>> merge_intervals([])
        []
    """
    if not intervals:
        return []

    # Sort intervals by their start value
    sorted_intervals = sorted(intervals, key=lambda x: x[0])

    merged = [sorted_intervals[0][:]]  # Copy first interval to avoid mutating input

    for current_start, current_end in sorted_intervals[1:]:
        last_merged = merged[-1]

        # Intervals overlap or are contiguous if current start <= last merged end
        if current_start <= last_merged[1]:
            # Extend the last merged interval if necessary
            last_merged[1] = max(last_merged[1], current_end)
        else:
            # No overlap: start a new interval
            merged.append([current_start, current_end])

    return merged


# ---------------------------------------------------------------------------
# Quick self-test
# ---------------------------------------------------------------------------
if __name__ == "__main__":
    test_cases = [
        # (input, expected_output)
        ([[1, 3], [2, 6], [8, 10], [15, 18]], [[1, 6], [8, 10], [15, 18]]),
        ([[1, 4], [4, 5]], [[1, 5]]),
        ([[1, 4], [0, 4]], [[0, 4]]),
        ([[1, 4], [2, 3]], [[1, 4]]),           # One interval fully inside another
        ([[5, 10], [1, 3]], [[1, 3], [5, 10]]), # Unsorted input
        ([[1, 4]], [[1, 4]]),                   # Single interval
        ([], []),                               # Empty input
    ]

    all_passed = True
    for intervals, expected in test_cases:
        result = merge_intervals(intervals)
        status = "PASS" if result == expected else "FAIL"
        if status == "FAIL":
            all_passed = False
        print(f"[{status}] merge_intervals({intervals})")
        if status == "FAIL":
            print(f"       Expected : {expected}")
            print(f"       Got      : {result}")

    print("
All tests passed!" if all_passed else "
Some tests FAILED.")

How it works

Time complexity: O(n log n) — dominated by sorting.
Space complexity: O(n) for the output list.