# Find intersection of intervals given by two lists

Given two **2-D arrays** which represent intervals. Each 2-D array represents a list of intervals. Each list of intervals is **disjoint** and sorted in increasing order. Find the intersection or set of ranges that are common to both the lists.

Disjoint means no element is common in a list. Example: {1, 4} and {5, 6} are disjoint while {1, 4} and {2, 5} are not as 2, 3 and 4 are common to both intervals.

**Examples:**

Input:arr1[][] = {{0, 4}, {5, 10}, {13, 20}, {24, 25}}

arr2[][] = {{1, 5}, {8, 12}, {15, 24}, {25, 26}}

Output:{{1, 4}, {5, 5}, {8, 10}, {15, 20}, {24, 24}, {25, 25}}

Explanation:

{1, 4} lies completely within range {0, 4} and {1, 5}. Hence, {1, 4} is the desired intersection. Similarly, {24, 24} lies completely within two intervals {24, 25} and {15, 24}.

Input:arr1[][] = {{0, 2}, {5, 10}, {12, 22}, {24, 25}}

arr2[][] = {{1, 4}, {9, 12}, {15, 24}, {25, 26}}

Output:{{1, 2}, {9, 10}, {12, 12}, {15, 22}, {24, 24}, {25, 25}}

Explanation:

{1, 2} lies completely within range {0, 2} and {1, 4}. Hence, {1, 2} is the desired intersection. Similarly, {12, 12} lies completely within two intervals {12, 22} and {9, 12}.

**Approach:**

To solve the problem mentioned above, two pointer technique can be used, as per the steps given below:

- Maintain
**two pointers**i and j to traverse the two interval lists, arr1 and arr2 respectively. - Now, if arr1[i] has smallest endpoint, it can only intersect with arr2[j]. Similarly, if arr2[j] has smallest endpoint, it can only intersect with arr1[i]. If intersection occurs, find the intersecting segment.
- [l, r] will be the intersecting segment iff l <= r, where
**l = max(arr1[i][0], arr2[j][0])**and**r = min(arr1[i][1], arr2[j][1])**. - Increment the i and j pointers accordingly to move ahead.

Below is the implementation of the approach:

`// C++ implementation to find the ` `// intersection of the two intervals ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to print intersecting intervals ` `void` `printIntervals(vector<vector<` `int` `> > arr1, ` ` ` `vector<vector<` `int` `> > arr2) ` `{ ` ` ` ` ` `// i and j pointers for ` ` ` `// arr1 and arr2 respectively ` ` ` `int` `i = 0, j = 0; ` ` ` ` ` `// Size of the two lists ` ` ` `int` `n = arr1.size(), m = arr2.size(); ` ` ` ` ` `// Loop through all intervals unless ` ` ` `// one of the interval gets exhausted ` ` ` `while` `(i < n && j < m) { ` ` ` `// Left bound for intersecting segment ` ` ` `int` `l = max(arr1[i][0], arr2[j][0]); ` ` ` ` ` `// Right bound for intersecting segment ` ` ` `int` `r = min(arr1[i][1], arr2[j][1]); ` ` ` ` ` `// If segment is valid print it ` ` ` `if` `(l <= r) ` ` ` `cout << ` `"{"` `<< l << ` `", "` ` ` `<< r << ` `"}\n"` `; ` ` ` ` ` `// If i-th interval's right ` ` ` `// bound is smaller ` ` ` `// increment i else ` ` ` `// increment j ` ` ` `if` `(arr1[i][1] < arr2[j][1]) ` ` ` `i++; ` ` ` `else` ` ` `j++; ` ` ` `} ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` ` ` `vector<vector<` `int` `> > arr1 ` ` ` `= { { 0, 4 }, { 5, 10 }, ` ` ` `{ 13, 20 }, { 24, 25 } }; ` ` ` ` ` `vector<vector<` `int` `> > arr2 ` ` ` `= { { 1, 5 }, { 8, 12 }, ` ` ` `{ 15, 24 }, { 25, 26 } }; ` ` ` ` ` `printIntervals(arr1, arr2); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

{1, 4} {5, 5} {8, 10} {15, 20} {24, 24} {25, 25}

* Time Complexity: O(N + M)*, where N and M are lengths of the 2-D arrays

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Find Intersection of all Intervals
- Find intersection point of two Linked Lists without finding the length
- Find Union and Intersection of two unsorted arrays
- Find smallest range containing elements from k lists
- Merge Overlapping Intervals
- Maximum number of overlapping Intervals
- Count the number of intervals in which a given value lies
- Make the intervals non-overlapping by assigning them to two different processors
- Check if given intervals can be made non-overlapping by adding/subtracting some X
- Count of available non-overlapping intervals to be inserted to make interval [0, R]
- Union and Intersection of two sorted arrays
- Intersection of two arrays in Python ( Lambda expression and filter function )
- Python | Using 2D arrays/lists the right way
- Comparison between Lists and Array in Python
- Add two numbers represented by linked lists | Set 2
- Merge two unsorted linked lists to get a sorted list
- Find the value of max(f(x)) - min(f(x)) for a given F(x)
- Find minimum x such that (x % k) * (x / k) == n
- Find all divisors of N
^{2}using N - Find a triplet that sum to a given value

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.