Insert Interval into Sorted List in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to append the new interval to the result list.

DSA Go

result := [][]int{}
for i := 0; i < len(intervals); i++ {
    if intervals[i][1] < newInterval[0] {
        result = append(result, intervals[i])
    } else if intervals[i][0] > newInterval[1] {
        result = append(result, newInterval)
        newInterval = intervals[i]
    } else {
        newInterval[0] = min(intervals[i][0], newInterval[0])
        newInterval[1] = max(intervals[i][1], newInterval[1])
    }
}
result = append(result, [1])

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

Aresult[len(result)-1]

Bintervals[len(intervals)-1]

Cintervals[0]

DnewInterval

Attempts:

3 left

💡 Hint

Common Mistakes

Appending the wrong interval like the last original interval instead of the merged one.

Forgetting to append the newInterval at the end.

After merging or skipping intervals, the last newInterval must be appended to the result list.

2fill in blank

medium

Complete the code to check if the current interval is completely before the new interval.

DSA Go

for i := 0; i < len(intervals); i++ {
    if intervals[i][1] [1] newInterval[0] {
        result = append(result, intervals[i])
    } else if intervals[i][0] > newInterval[1] {
        // merging logic
    }
}

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

A>

B<

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using > or >= which would miss intervals that end exactly at newInterval start.

Using < which excludes intervals that end exactly at newInterval start.

If the end of the current interval is less than or equal to the start of newInterval, it means it is completely before and does not overlap.

3fill in blank

hard

Fix the error in the merging logic to update the newInterval boundaries correctly.

DSA Go

if intervals[i][0] <= newInterval[1] && intervals[i][1] >= newInterval[0] {
    newInterval[0] = [1](intervals[i][0], newInterval[0])
    newInterval[1] = [2](intervals[i][1], newInterval[1])
}

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

Amin

Bmax

Cabs

Dsum

Attempts:

3 left

💡 Hint

Common Mistakes

Using max for start or min for end which breaks the interval boundaries.

Using sum or abs which are not relevant here.

To merge intervals, the start is the minimum of both starts, and the end is the maximum of both ends.

4fill in blank

hard

Fill both blanks to complete the helper functions for min and max.

DSA Go

func min(a, b int) int {
    if a [1] b {
        return a
    }
    return b
}

func max(a, b int) int {
    if a [2] b {
        return a
    }
    return b
}

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

A<

B>

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using >= or <= which can cause incorrect returns when values are equal.

Swapping the operators between min and max.

min returns a if a < b else b; max returns a if a > b else b.

5fill in blank

hard

Fill all three blanks to complete the main function signature and return statement.

DSA Go

func insert([1] [][]int, [2] []int) [][]int {
    // implementation
    return [3]
}

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

Aintervals

BnewInterval

Cresult

Dinterval

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names in the signature or return statement.

Returning the wrong variable instead of the result list.

The function takes intervals and newInterval as inputs and returns the result list.

Practice

1. What is the main goal when inserting a new interval into a sorted list of non-overlapping intervals?

easy

A. To merge overlapping intervals and keep the list sorted

B. To add the new interval at the end without merging

C. To remove all intervals that come before the new interval

D. To sort the list again after insertion

Solution

1. Step 1: Understand the problem context

   The list contains sorted, non-overlapping intervals. Inserting a new interval may cause overlaps.

2. Step 2: Determine the correct action

   We must merge any overlapping intervals with the new one to keep the list sorted and non-overlapping.

3. Final Answer:

   To merge overlapping intervals and keep the list sorted -> Option A

4. Quick Check:

   Insert interval = merge and keep sorted [OK]

Hint: Merge overlaps to keep intervals sorted and non-overlapping [OK]

Common Mistakes:

• Just appending without merging
• Removing intervals incorrectly
• Sorting again after insertion

2. Which Go syntax correctly declares a slice of intervals where each interval is a slice of two integers?

easy

A. intervals := [][2]int{{1, 3}, {6, 9}}

B. intervals := [][]int{1, 3, 6, 9}

C. intervals := []int{1, 3, 6, 9}

D. intervals := [][]int{{1, 3}, {6, 9}}

Solution

1. Step 1: Identify slice of slices syntax

   In Go, [][]int means a slice of slices of int, suitable for intervals like [start, end].

2. Step 2: Check each option

   intervals := [][]int{{1, 3}, {6, 9}} correctly uses [][]int with nested slices for intervals. intervals := [][2]int{{1, 3}, {6, 9}} uses array [2]int which is valid but less common. intervals := []int{1, 3, 6, 9} is a flat slice, not intervals. intervals := [][]int{1, 3, 6, 9} is invalid syntax.

3. Final Answer:

   intervals := [][]int{{1, 3}, {6, 9}} -> Option D

4. Quick Check:

   Slice of slices = [][]int{{start,end}} [OK]

Hint: Use [][]int for slice of intervals in Go [OK]

Common Mistakes:

• Using flat []int instead of [][]int
• Incorrect array vs slice syntax
• Missing curly braces for nested slices

3. What is the output of the following Go code snippet after inserting interval [2,5] into intervals [[1,2],[6,9]]?

intervals := [][]int{{1, 2}, {6, 9}}
newInterval := []int{2, 5}
// After insertion and merging
result := [][]int{{1, 5}, {6, 9}}
fmt.Println(result)

medium

A. [[1 2] [6 9] [2 5]]

B. [[1 2] [2 5] [6 9]]

C. [[1 5] [6 9]]

D. [[2 5] [6 9]]

Solution

1. Step 1: Insert and check overlap

   New interval [2,5] overlaps with [1,2] because 2 <= 2. Merge them to [1,5].

2. Step 2: Keep other intervals

   [6,9] does not overlap with [1,5], so it stays as is.

3. Final Answer:

   [[1 5] [6 9]] -> Option C

4. Quick Check:

   Merged intervals = [[1 5] [6 9]] [OK]

Hint: Merge overlapping intervals to combine ranges [OK]

Common Mistakes:

• Not merging overlapping intervals
• Appending new interval without sorting
• Incorrect interval order

4. Given this Go function snippet to insert an interval, what is the bug?

func insert(intervals [][]int, newInterval []int) [][]int {
    var result [][]int
    for _, interval := range intervals {
        if interval[1] < newInterval[0] {
            result = append(result, interval)
        } else if interval[0] > newInterval[1] {
            result = append(result, newInterval)
            newInterval = interval
        } else {
            newInterval[0] = min(newInterval[0], interval[0])
            newInterval[1] = max(newInterval[1], interval[1])
        }
    }
    result = append(result, newInterval)
    return result
}

medium

A. Appending newInterval multiple times causes duplicates

B. Not updating newInterval correctly during merge

C. Missing return statement

D. Incorrect comparison operators in if conditions

Solution

1. Step 1: Analyze appending logic

   When interval[0] > newInterval[1], newInterval is appended and then replaced by interval. This can cause multiple appends of newInterval.

2. Step 2: Identify duplicate insertion

   Because newInterval is appended inside the loop multiple times, duplicates appear in result.

3. Final Answer:

   Appending newInterval multiple times causes duplicates -> Option A

4. Quick Check:

   Multiple appends = duplicates [OK]

Hint: Append newInterval once after loop to avoid duplicates [OK]

Common Mistakes:

• Appending inside loop multiple times
• Not updating newInterval boundaries
• Forgetting to return result

5. You have intervals [[1,3],[6,9]] and want to insert [2,7]. What is the final list after insertion and merging?

hard

A. [[1,3],[2,7],[6,9]]

B. [[1,9]]

C. [[1,7],[6,9]]

D. [[1,9],[6,9]]

Solution

1. Step 1: Merge [2,7] with overlapping intervals

   [2,7] overlaps with [1,3] and [6,9]. Merge all three intervals into one covering from min start 1 to max end 9.

2. Step 2: Final merged interval

   The merged interval is [1,9], replacing the original two intervals.

3. Final Answer:

   [[1,9]] -> Option B

4. Quick Check:

   Merge all overlapping = [[1,9]] [OK]

Hint: Merge all overlapping intervals into one big interval [OK]

Common Mistakes:

• Partial merges leaving overlaps
• Appending without merging
• Incorrect interval boundaries