Merge Overlapping Intervals in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to sort the intervals by their start time.

DSA C#

Array.Sort(intervals, (a, b) => a[[1]].CompareTo(b[0]));

Drag options to blanks, or click blank then click option'

A0

B1

CLength

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using the end time index (1) instead of start time (0).

Using Length or invalid indices.

We sort intervals by their start time, which is at index 0 in each interval array.

2fill in blank

medium

Complete the code to check if the current interval overlaps with the last merged interval.

DSA C#

if (intervals[i][0] [1] merged[merged.Count - 1][1])

Drag options to blanks, or click blank then click option'

A<

B<=

C>=

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using < or > which misses touching intervals.

Using >= which reverses the logic.

If the current interval's start is less than or equal to the last merged interval's end, they overlap.

3fill in blank

hard

Fix the error in updating the end of the last merged interval to the maximum end time.

DSA C#

merged[merged.Count - 1][1] = Math.[1](merged[merged.Count - 1][1], intervals[i][1]);

Drag options to blanks, or click blank then click option'

AMax

BMin

CAbs

DRound

Attempts:

3 left

💡 Hint

Common Mistakes

Using Min which shrinks the interval incorrectly.

Using Abs or Round which are unrelated.

We update the end to the maximum of the two ends to merge intervals correctly.

4fill in blank

hard

Fill both blanks to add a new interval to merged list and continue the loop.

DSA C#

merged.[1](intervals[i]);
i[2];

Drag options to blanks, or click blank then click option'

AAdd

BAppend

C++

D--

Attempts:

3 left

💡 Hint

Common Mistakes

Using Append which is not a List method in C#.

Using -- which decreases the index incorrectly.

Use Add to append to the list and ++ to move to the next index.

5fill in blank

hard

Fill the blanks to convert the merged list to an array and return it.

DSA C#

return merged.[1]();

// merged is List<int[]>
// Convert to [2]

Drag options to blanks, or click blank then click option'

AToList

BArray

Cint[][]

DToArray

Attempts:

3 left

💡 Hint

Common Mistakes

Using ToList() which returns a list, not array.

Returning wrong type like int[] instead of int[][].

Use ToArray() to convert List to array, and specify return type int[][] for intervals.

Practice

1. What is the main purpose of the Merge Overlapping Intervals algorithm?

easy

A. To find the maximum number of intervals

B. To sort intervals by their length

C. To combine all intervals that overlap into a single continuous interval

D. To split intervals into smaller parts

Solution

1. Step 1: Understand the problem goal

   The algorithm aims to merge intervals that share common parts so they become one continuous interval.

2. Step 2: Identify the correct purpose

   Among the options, only combining overlapping intervals matches the goal.

3. Final Answer:

   To combine all intervals that overlap into a single continuous interval -> Option C

4. Quick Check:

   Merge overlapping intervals = combine overlaps [OK]

Hint: Think of joining overlapping time slots into one [OK]

Common Mistakes:

• Confusing merging with sorting
• Thinking it splits intervals instead of combining
• Assuming it counts intervals

2. Which of the following C# code snippets correctly sorts a list of intervals by their start time before merging?

easy

A. intervals.OrderBy(x => x.Length);

B. intervals.OrderByDescending(x => x.End);

C. intervals.Sort((a, b) => b.Start.CompareTo(a.Start));

D. intervals.Sort((a, b) => a.Start.CompareTo(b.Start));

Solution

1. Step 1: Identify sorting by start time

   We need to sort intervals by their start property in ascending order.

2. Step 2: Check each option

   intervals.Sort((a, b) => a.Start.CompareTo(b.Start)); uses Sort with CompareTo on Start ascending, which is correct. Others sort by end descending, start descending, or length, which are incorrect for merging.

3. Final Answer:

   intervals.Sort((a, b) => a.Start.CompareTo(b.Start)); -> Option D

4. Quick Check:

   Sort by start ascending = intervals.Sort((a, b) => a.Start.CompareTo(b.Start)); [OK]

Hint: Sort intervals by start ascending before merging [OK]

Common Mistakes:

• Sorting by end time instead of start
• Sorting descending instead of ascending
• Sorting by interval length

3. What is the output of the following C# code that merges overlapping intervals?

var intervals = new List<(int Start, int End)>{ (1,3), (2,6), (8,10), (15,18) };
intervals.Sort((a,b) => a.Start.CompareTo(b.Start));
var merged = new List<(int, int)>();
foreach(var interval in intervals) {
  if(merged.Count == 0 || merged[^1].End < interval.Start) {
    merged.Add(interval);
  } else {
    var last = merged[^1];
    merged[^1] = (last.Start, Math.Max(last.End, interval.End));
  }
}
foreach(var i in merged) Console.Write($"({i.Start},{i.End}) ");

medium

A. (1,6) (8,10) (15,18)

B. (1,3) (2,6) (8,10) (15,18)

C. (1,10) (15,18)

D. (1,6) (2,10) (15,18)

Solution

1. Step 1: Sort intervals by start

   Sorted intervals: (1,3), (2,6), (8,10), (15,18)

2. Step 2: Merge overlapping intervals

   (1,3) and (2,6) overlap, merged to (1,6). Others do not overlap, so final merged list is (1,6), (8,10), (15,18).

3. Final Answer:

   (1,6) (8,10) (15,18) -> Option A

4. Quick Check:

   Merged intervals = (1,6) (8,10) (15,18) [OK]

Hint: Merge intervals by comparing current start with last merged end [OK]

Common Mistakes:

• Not merging overlapping intervals
• Merging intervals incorrectly by extending start
• Printing original intervals without merging

4. The following code attempts to merge overlapping intervals but has a bug. What is the bug?

var intervals = new List<(int Start, int End)>{ (1,4), (4,5) };
intervals.Sort((a,b) => a.Start.CompareTo(b.Start));
var merged = new List<(int, int)>();
foreach(var interval in intervals) {
  if(merged.Count == 0 || merged[^1].End <= interval.Start) {
    merged.Add(interval);
  } else {
    var last = merged[^1];
    merged[^1] = (last.Start, Math.Max(last.End, interval.End));
  }
}
foreach(var i in merged) Console.Write($"({i.Start},{i.End}) ");

medium

A. The condition should use < instead of <= to merge touching intervals

B. The intervals are not sorted before merging

C. The merged list is not initialized

D. The code does not handle empty input

Solution

1. Step 1: Analyze the merge condition

   The condition uses merged[^1].End <= interval.Start, which treats touching intervals as non-overlapping.

2. Step 2: Identify correct condition for merging

   To merge intervals that touch (like (1,4) and (4,5)), use < instead of <= so they merge into (1,5).

3. Final Answer:

   The condition should use < instead of <= to merge touching intervals -> Option A

4. Quick Check:

   Use < to merge touching intervals [OK]

Hint: Use strict less than to merge intervals that touch [OK]

Common Mistakes:

• Using <= causes touching intervals to not merge
• Forgetting to sort intervals
• Ignoring empty input cases

5. Given a list of intervals [(1,5), (2,3), (4,8), (10,12), (9,10)], what is the merged list after applying the merge overlapping intervals algorithm?

hard

A. [(1,5), (2,3), (4,8), (9,10), (10,12)]

B. [(1,8), (9,12)]

C. [(1,3), (4,8), (9,12)]

D. [(1,8), (10,12)]

Solution

1. Step 1: Sort intervals by start

   Sorted intervals: (1,5), (2,3), (4,8), (9,10), (10,12)

2. Step 2: Merge overlapping intervals step-by-step

   Merge (1,5) and (2,3) -> (1,5); merge (1,5) and (4,8) -> (1,8); merge (9,10) and (10,12) -> (9,12). Final merged intervals: (1,8), (9,12).

3. Final Answer:

   [(1,8), (9,12)] -> Option B

4. Quick Check:

   Merged intervals = [(1,8), (9,12)] [OK]

Hint: Sort then merge overlapping or touching intervals stepwise [OK]

Common Mistakes:

• Not merging intervals that overlap inside others
• Missing to merge touching intervals
• Returning original intervals without merging