Write a C# method that merges overlapping time ranges.

Implement MergeRanges(IEnumerable<TimeRange> ranges). A range has Start and End. Merge ranges that overlap or touch, and return sorted merged ranges. Treat End < Start as invalid input.

Input: [09:00-10:00], [09:30-11:00], [12:00-13:00], [11:00-12:00] Output: [09:00-13:00]

• Null input returns an empty list.
• Invalid ranges throw ArgumentException.
• Ranges that touch, such as 10:00-11:00 and 11:00-12:00, merge.
• Output is sorted by start time.

I would validate ranges first, sort by start time, then walk once while tracking the current merged range. If the next range starts before or exactly at the current end, I extend the current end. Otherwise I add the current range to the result and start a new one. I would clarify whether touching ranges merge because that boundary rule changes the condition.

public sealed record TimeRange(DateTime Start, DateTime End);

public static IReadOnlyList<TimeRange> MergeRanges(IEnumerable<TimeRange>? ranges)
{
    if (ranges is null)
    {
        return Array.Empty<TimeRange>();
    }

    var ordered = ranges
        .Select(range =>
        {
            if (range.End < range.Start)
            {
                throw new ArgumentException("Range end cannot be before start.");
            }

            return range;
        })
        .OrderBy(range => range.Start)
        .ToList();

    if (ordered.Count == 0)
    {
        return ordered;
    }

    var result = new List<TimeRange>();
    var current = ordered[0];

    foreach (var next in ordered.Skip(1))
    {
        if (next.Start <= current.End)
        {
            current = current with { End = next.End > current.End ? next.End : current.End };
            continue;
        }

        result.Add(current);
        current = next;
    }

    result.Add(current);
    return result;
}

Sorting costs O(n log n), and the merge pass is O(n). Space is O(n) for the sorted list and result.

• Empty input.
• One range.
• Invalid range where end is before start.
• Ranges that touch exactly.
• Ranges fully contained inside another range.

• Use unsorted input to ensure the method sorts first.
• Use nested ranges such as 09-17 and 10-11.
• Use a touching boundary to verify the chosen rule.

• Only comparing each range with the original previous range instead of the extended current range.
• Forgetting to add the final current range.
• Not defining whether touching ranges merge.
• Accepting invalid ranges silently.