Merge Overlapping Intervals in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to sort intervals by their start time.

DSA Typescript

intervals.sort((a, b) => [1]);

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

A-

Ba.start - b.start

Cstart - b.start

D.start - b.start

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'a - b' instead of 'a.start - b.start'.

Forgetting to access the start property.

We sort intervals by their start property using a.start - b.start.

2fill in blank

medium

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

DSA Typescript

if (intervals[i].start [1] merged[merged.length - 1].end) {

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

A>

B>=

C<

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using > instead of <= causes missing overlaps.

Using < excludes touching intervals.

If current start is less than or equal to last merged end, intervals overlap.

3fill in blank

hard

Fix the error in updating the end of the last merged interval.

DSA Typescript

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

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

Amin

Babs

Cmax

Dround

Attempts:

3 left

💡 Hint

Common Mistakes

Using Math.min causes incorrect merging.

Using Math.abs or Math.round is irrelevant here.

We take the maximum end to merge overlapping intervals correctly.

4fill in blank

hard

Fill both blanks to add a non-overlapping interval to merged list.

DSA Typescript

else {
  merged.[1](intervals[[2]]);
}

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

Apush

Bpop

Ci

Dj

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop removes last element instead of adding.

Using j instead of i.

We push the current interval at index i to merged when no overlap.

5fill in blank

hard

Fill all three blanks to complete the mergeIntervals function.

DSA Typescript

function mergeIntervals(intervals: {start: number, end: number}[]): {start: number, end: number}[] {
  if (intervals.length === 0) return [];
  intervals.sort((a, b) => a.[1] - b.[2]);
  const merged = [intervals[0]];
  for (let [3] = 1; [3] < intervals.length; [3]++) {
    if (intervals[[3]].start <= merged[merged.length - 1].end) {
      merged[merged.length - 1].end = Math.max(merged[merged.length - 1].end, intervals[[3]].end);
    } else {
      merged.push(intervals[[3]]);
    }
  }
  return merged;
}

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

Astart

Bend

Ci

Dj

Attempts:

3 left

💡 Hint

Common Mistakes

Sorting by end instead of start.

Using wrong loop variable or missing loop increment.

Sort by start (A and A), loop with i (C), and access start property correctly.

Practice

1. What is the main purpose of merging overlapping intervals in a list of intervals?

easy

A. To split intervals into smaller parts

B. To sort intervals by their end times only

C. To remove all intervals that have the same start time

D. To combine intervals that overlap into a single continuous interval

Solution

1. Step 1: Understand overlapping intervals

   Overlapping intervals share some common range, so merging combines them into one continuous interval.

2. Step 2: Purpose of merging

   Merging removes overlaps by creating a single interval covering all overlapping parts.

3. Final Answer:

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

4. Quick Check:

   Merging = Combine overlaps [OK]

Hint: Merge means combine overlapping parts into one [OK]

Common Mistakes:

• Thinking merging sorts intervals only
• Confusing merging with removing duplicates
• Believing merging splits intervals

2. Which of the following TypeScript code snippets correctly sorts an array of intervals by their start time?

easy

A. intervals.sort((a, b) => a[0] - b[0]);

B. intervals.sort((a, b) => b[1] - a[1]);

C. intervals.sort((a, b) => a[1] + b[0]);

D. intervals.sort((a, b) => a[0] + b[1]);

Solution

1. Step 1: Identify sorting by start time

   Sorting by start time means comparing the first element of each interval (a[0] and b[0]).

2. Step 2: Check correct comparison function

   Subtracting a[0] - b[0] sorts ascending by start time, which is correct.

3. Final Answer:

   intervals.sort((a, b) => a[0] - b[0]); -> Option A

4. Quick Check:

   Sort by start = a[0] - b[0] [OK]

Hint: Sort intervals by start using a[0] - b[0] [OK]

Common Mistakes:

• Sorting by end time instead of start time
• Adding values instead of subtracting in sort
• Using wrong indices for comparison

3. What is the output of the following TypeScript code?

function mergeIntervals(intervals: number[][]): number[][] {
  intervals.sort((a, b) => a[0] - b[0]);
  const merged: number[][] = [];
  for (const interval of intervals) {
    if (!merged.length || merged[merged.length - 1][1] < interval[0]) {
      merged.push(interval);
    } else {
      merged[merged.length - 1][1] = Math.max(merged[merged.length - 1][1], interval[1]);
    }
  }
  return merged;
}

console.log(mergeIntervals([[1,3],[2,6],[8,10],[15,18]]));

medium

A. [[1,3],[2,6],[8,10],[15,18]]

B. [[1,10],[15,18]]

C. [[1,6],[8,10],[15,18]]

D. [[2,6],[8,10],[15,18]]

Solution

1. Step 1: Sort intervals by start

   Sorted intervals: [[1,3],[2,6],[8,10],[15,18]] (already sorted)

2. Step 2: Merge overlapping intervals

   First interval [1,3] added.
   Second interval [2,6] overlaps with [1,3], merge to [1,6].
   Third interval [8,10] no overlap, add.
   Fourth interval [15,18] no overlap, add.

3. Final Answer:

   [[1,6],[8,10],[15,18]] -> Option C

4. Quick Check:

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

Hint: Sort first, then merge overlapping intervals step-by-step [OK]

Common Mistakes:

• Not sorting intervals before merging
• Overwriting intervals incorrectly
• Missing to merge overlapping intervals

4. The following TypeScript function is intended to merge overlapping intervals but has a bug. What is the bug?

function merge(intervals: number[][]): number[][] {
  intervals.sort((a, b) => a[0] - b[0]);
  const result: number[][] = [];
  for (let i = 0; i < intervals.length; i++) {
    if (result.length === 0 || result[result.length - 1][1] <= intervals[i][0]) {
      result.push(intervals[i]);
    } else {
      result[result.length - 1][1] = Math.max(result[result.length - 1][1], intervals[i][1]);
    }
  }
  return result;
}

medium

A. The max function is used incorrectly

B. The condition should use '<' instead of '<=' to detect overlap

C. The function does not handle empty input

D. The intervals are not sorted before merging

Solution

1. Step 1: Analyze overlap condition

   Condition uses '<=' which treats touching intervals as non-overlapping.

2. Step 2: Correct overlap detection

   Correct condition uses '<' so that when last_end == current_start (touching), it merges since the if condition fails and goes to else. Current '<=' incorrectly pushes new for touching intervals.

3. Final Answer:

   The condition should use '<' instead of '<=' to detect overlap -> Option B

4. Quick Check:

   Overlap check needs '<' not '<=' [OK]

Hint: Use '<' to detect overlap, not '<=' [OK]

Common Mistakes:

• Using '<=' causes missing merges on touching intervals
• Ignoring sorting requirement
• Not checking empty input but that is not the bug here

5. Given a list of intervals, how would you modify the merge overlapping intervals algorithm to also count how many original intervals were merged into each resulting interval?
Choose the best approach.

hard

A. Keep a count alongside each merged interval and increment it when merging overlaps

B. Sort intervals by end time instead of start time

C. Use a separate array to store counts and update only after merging all intervals

D. Merge intervals normally and count the total number of intervals merged at the end

Solution

1. Step 1: Track counts during merging

   When merging intervals, keep a count for each merged interval starting at 1.

2. Step 2: Increment count on overlap

   Each time an interval merges into the last merged interval, increment its count to reflect how many intervals combined.

3. Final Answer:

   Keep a count alongside each merged interval and increment it when merging overlaps -> Option A

4. Quick Check:

   Count merges while merging intervals [OK]

Hint: Track counts during merge, increment on overlap [OK]

Common Mistakes:

• Sorting by end time does not help counting merges
• Counting after merging loses interval mapping
• Counting total merges instead of per merged interval