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++

`// 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*

## Java

`// Java implementation to find ` `// intersecting intervals ` `class` `GFG{ ` ` ` `// Function to print intersecting intervals ` `static` `void` `printIntervals(` `int` `arr1[][], ` ` ` `int` `arr2[][]) ` `{ ` ` ` ` ` `// i and j pointers for arr1 and ` ` ` `// arr2 respectively ` ` ` `int` `i = ` `0` `, j = ` `0` `; ` ` ` ` ` `int` `n = arr1.length, m = arr2.length; ` ` ` ` ` `// Loop through all intervals unless ` ` ` `// one of the interval gets exhausted ` ` ` `while` `(i < n && j < m) ` ` ` `{ ` ` ` ` ` `// Left bound for intersecting segment ` ` ` `int` `l = Math.max(arr1[i][` `0` `], arr2[j][` `0` `]); ` ` ` ` ` `// Right bound for intersecting segment ` ` ` `int` `r = Math.min(arr1[i][` `1` `], arr2[j][` `1` `]); ` ` ` ` ` `// If segment is valid print it ` ` ` `if` `(l <= r) ` ` ` `System.out.println(` `"{"` `+ l + ` `", "` `+ ` ` ` `r + ` `"}"` `); ` ` ` ` ` `// 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 ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `arr1[][] = { { ` `0` `, ` `4` `}, { ` `5` `, ` `10` `}, ` ` ` `{ ` `13` `, ` `20` `}, { ` `24` `, ` `25` `} }; ` ` ` ` ` `int` `arr2[][] = { { ` `1` `, ` `5` `}, { ` `8` `, ` `12` `}, ` ` ` `{ ` `15` `, ` `24` `}, { ` `25` `, ` `26` `} }; ` ` ` ` ` `printIntervals(arr1, arr2); ` `} ` `} ` ` ` `// This code is contributed by sarthak_eddy ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation to find ` `# intersecting intervals ` ` ` `# Function to print intersecting ` `# intervals ` `def` `printIntervals(arr1, arr2): ` ` ` ` ` `# i and j pointers for arr1 ` ` ` `# and arr2 respectively ` ` ` `i ` `=` `j ` `=` `0` ` ` ` ` `n ` `=` `len` `(arr1) ` ` ` `m ` `=` `len` `(arr2) ` ` ` ` ` `# Loop through all intervals unless one ` ` ` `# of the interval gets exhausted ` ` ` `while` `i < n ` `and` `j < m: ` ` ` ` ` `# Left bound for intersecting segment ` ` ` `l ` `=` `max` `(arr1[i][` `0` `], arr2[j][` `0` `]) ` ` ` ` ` `# Right bound for intersecting segment ` ` ` `r ` `=` `min` `(arr1[i][` `1` `], arr2[j][` `1` `]) ` ` ` ` ` `# If segment is valid print it ` ` ` `if` `l <` `=` `r: ` ` ` `print` `(` `'{'` `, l, ` `','` `, r, ` `'}'` `) ` ` ` ` ` `# If i-th interval's right bound is ` ` ` `# smaller increment i else increment j ` ` ` `if` `arr1[i][` `1` `] < arr2[j][` `1` `]: ` ` ` `i ` `+` `=` `1` ` ` `else` `: ` ` ` `j ` `+` `=` `1` ` ` `# Driver code ` `arr1 ` `=` `[ [ ` `0` `, ` `4` `], [ ` `5` `, ` `10` `], ` ` ` `[ ` `13` `, ` `20` `], [ ` `24` `, ` `25` `] ] ` ` ` `arr2 ` `=` `[ [ ` `1` `, ` `5` `], [ ` `8` `, ` `12` `], ` ` ` `[ ` `15` `, ` `24` `], [ ` `25` `, ` `26` `] ] ` ` ` `printIntervals(arr1, arr2) ` ` ` `# This code is contributed by sarthak_eddy ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation to find ` `// intersecting intervals ` `using` `System; ` `class` `GFG{ ` ` ` `// Function to print intersecting intervals ` `static` `void` `printIntervals(` `int` `[,]arr1, ` ` ` `int` `[,]arr2) ` `{ ` ` ` ` ` `// i and j pointers for arr1 and ` ` ` `// arr2 respectively ` ` ` `int` `i = 0, j = 0; ` ` ` ` ` `int` `n = arr1.GetLength(0), ` ` ` `m = arr2.GetLength(0); ` ` ` ` ` `// Loop through all intervals unless ` ` ` `// one of the interval gets exhausted ` ` ` `while` `(i < n && j < m) ` ` ` `{ ` ` ` ` ` `// Left bound for intersecting segment ` ` ` `int` `l = Math.Max(arr1[i, 0], arr2[j, 0]); ` ` ` ` ` `// Right bound for intersecting segment ` ` ` `int` `r = Math.Min(arr1[i, 1], arr2[j, 1]); ` ` ` ` ` `// If segment is valid print it ` ` ` `if` `(l <= r) ` ` ` `Console.WriteLine(` `"{"` `+ l + ` `", "` `+ ` ` ` `r + ` `"}"` `); ` ` ` ` ` `// 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 ` `public` `static` `void` `Main(String[] args) ` `{ ` ` ` `int` `[,]arr1 = { { 0, 4 }, { 5, 10 }, ` ` ` `{ 13, 20 }, { 24, 25 } }; ` ` ` ` ` `int` `[,]arr2 = { { 1, 5 }, { 8, 12 }, ` ` ` `{ 15, 24 }, { 25, 26 } }; ` ` ` ` ` `printIntervals(arr1, arr2); ` `} ` `} ` ` ` `// This code is contributed by Princi Singh ` |

*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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Find Intersection of all Intervals
- Find intersection point of two Linked Lists without finding the length
- Find least non-overlapping number from a given set of intervals
- Make the intervals non-overlapping by assigning them to two different processors
- Count the number of intervals in which a given value lies
- Check if given intervals can be made non-overlapping by adding/subtracting some X
- Find Union and Intersection of two unsorted arrays
- Maximum number of overlapping Intervals
- Count of available non-overlapping intervals to be inserted to make interval [0, R]
- Merge Overlapping Intervals
- Union and Intersection of two sorted arrays
- Intersection of two arrays in Python ( Lambda expression and filter function )
- Add two numbers represented by linked lists | Set 2
- Merge two unsorted linked lists to get a sorted list
- Find smallest range containing elements from k lists
- Python | Using 2D arrays/lists the right way
- Comparison between Lists and Array in Python
- Find the two repeating elements in a given array
- Given two unsorted arrays, find all pairs whose sum is x
- Python List Comprehension to find pair with given sum from two arrays

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.