Get the best out of our app
GFG App
Open App
Browser
Continue

# Find a pair with the given difference

Given an unsorted array and a number n, find if there exists a pair of elements in the array whose difference is n.
Examples:

Input: arr[] = {5, 20, 3, 2, 50, 80}, n = 78
Output: Pair Found: (2, 80)

Input: arr[] = {90, 70, 20, 80, 50}, n = 45
Output: No Such Pair

Recommended Practice

Method 1: The simplest method is to run two loops, the outer loop picks the first element (smaller element) and the inner loop looks for the element picked by outer loop plus n. Time complexity of this method is O(n2).

Algorithm:

1.    Start iterating through each element of the array using an outer loop.
2.    For each element, start iterating again through each of the elements of the array except the one picked in outer loop using an inner loop.
3.    If the difference between the current element and any of the elements of it is equal to the given difference, print both elements.
4.    Continue the process until all possible pairs of elements are compared.
5.    If no pair found, print “No such pair”.

Below is the implementation of the approach:

## C++

 `// C++ code for the approach`   `#include` `using` `namespace` `std;`   `// Function to find if there exists a pair ` `// of elements in the array whose difference is n` `void` `findPair(``int` `arr[], ``int` `n, ``int` `diff) {` `    ``// Nested loop to compare all possible ` `      ``// pairs of elements` `    ``for``(``int` `i=0; i

Output

`Pair Found: (100, 40)`

Time Complexity: O(n*n) as two nested for loops are executing both from 1 to n where n is size of input array.
Space Complexity: O(1) as no extra space has been taken.

Method 2: We can use sorting and Binary Search to improve time complexity to O(nLogn). The first step is to sort the array in ascending order. Once the array is sorted, traverse the array from left to right, and for each element arr[i], binary search for arr[i] + n in arr[i+1..n-1]. If the element is found, return the pair. Both first and second steps take O(nLogn). So overall complexity is O(nLogn).
Method 3: The second step of the Method -2 can be improved to O(n). The first step remains the same. The idea for the second step is to take two index variables i and j, and initialize them as 0 and 1 respectively. Now run a linear loop. If arr[j] – arr[i] is smaller than n, we need to look for greater arr[j], so increment j. If arr[j] – arr[i] is greater than n, we need to look for greater arr[i], so increment i. Thanks to Aashish Barnwal for suggesting this approach.
The following code is only for the second step of the algorithm, it assumes that the array is already sorted.

## C++

 `// C++ program to find a pair with the given difference ` `#include ` `using` `namespace` `std;`   `// The function assumes that the array is sorted ` `bool` `findPair(``int` `arr[], ``int` `size, ``int` `n) ` `{ ` `    ``// Initialize positions of two elements ` `    ``int` `i = 0; ` `    ``int` `j = 1; `   `    ``// Search for a pair ` `    ``while` `(i < size && j < size) ` `    ``{ ` `        ``if` `(i != j && (arr[j] - arr[i] == n || arr[i] - arr[j] == n) )` `        ``{ ` `            ``cout << ``"Pair Found: ("` `<< arr[i] <<` `                        ``", "` `<< arr[j] << ``")"``; ` `            ``return` `true``; ` `        ``} ` `        ``else` `if` `(arr[j]-arr[i] < n) ` `            ``j++; ` `        ``else` `            ``i++; ` `    ``} `   `    ``cout << ``"No such pair"``; ` `    ``return` `false``; ` `} `   `// Driver program to test above function ` `int` `main() ` `{ ` `    ``int` `arr[] = {1, 8, 30, 40, 100}; ` `    ``int` `size = ``sizeof``(arr)/``sizeof``(arr[0]); ` `    ``int` `n = -60; ` `    ``findPair(arr, size, n); ` `    ``return` `0; ` `} `   `// This is code is contributed by rathbhupendra`

## C

 `// C program to find a pair with the given difference` `#include `   `// The function assumes that the array is sorted ` `int` `findPair(``int` `arr[], ``int` `size, ``int` `n)` `{` `    ``// Initialize positions of two elements` `    ``int` `i = 0;  ` `    ``int` `j = 1;`   `    ``// Search for a pair` `    ``while` `(i

## Java

 `// Java program to find a pair with the given difference` `import` `java.io.*;`   `class` `PairDifference` `{` `    ``// The function assumes that the array is sorted` `    ``static` `boolean` `findPair(``int` `arr[],``int` `n)` `    ``{` `        ``int` `size = arr.length;`   `        ``// Initialize positions of two elements` `        ``int` `i = ``0``, j = ``1``;`   `        ``// Search for a pair` `        ``while` `(i < size && j < size)` `        ``{` `            ``if` `(i != j && (arr[j] - arr[i] == n || arr[i] - arr[j] == n))` `            ``{` `                ``System.out.print(``"Pair Found: "``+` `                                 ``"( "``+arr[i]+``", "``+ arr[j]+``" )"``);` `                ``return` `true``;` `            ``}` `            ``else` `if` `(arr[j] - arr[i] < n)` `                ``j++;` `            ``else` `                ``i++;` `        ``}`   `        ``System.out.print(``"No such pair"``);` `        ``return` `false``;` `    ``}`   `    ``// Driver program to test above function` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``int` `arr[] = {``1``, ``8``, ``30``, ``40``, ``100``};` `        ``int` `n = -``60``;` `        ``findPair(arr,n);` `    ``}` `}` `/*This code is contributed by Devesh Agrawal*/`

## Python

 `# Python program to find a pair with the given difference`   `# The function assumes that the array is sorted` `def` `findPair(arr,n):`   `    ``size ``=` `len``(arr)`   `    ``# Initialize positions of two elements` `    ``i,j ``=` `0``,``1`   `    ``# Search for a pair` `    ``while` `i < size ``and` `j < size:`   `        ``if` `i !``=` `j ``and` `arr[j]``-``arr[i] ``=``=` `n:` `            ``print` `"Pair found ("``,arr[i],``","``,arr[j],``")"` `            ``return` `True`   `        ``elif` `arr[j] ``-` `arr[i] < n:` `            ``j``+``=``1` `        ``else``:` `            ``i``+``=``1` `    ``print` `"No pair found"` `    ``return` `False`   `# Driver function to test above function` `arr ``=` `[``1``, ``8``, ``30``, ``40``, ``100``]` `n ``=` `60` `findPair(arr, n)`   `# This code is contributed by Devesh Agrawal`

## C#

 `// C# program to find a pair with the given difference` `using` `System;`   `class` `GFG {` `    `  `    ``// The function assumes that the array is sorted` `    ``static` `bool` `findPair(``int` `[]arr, ``int` `n)` `    ``{` `        ``int` `size = arr.Length;`   `        ``// Initialize positions of two elements` `        ``int` `i = 0, j = 1;`   `        ``// Search for a pair` `        ``while` `(i < size && j < size)` `        ``{` `            ``if` `(i != j && arr[j] - arr[i] == n)` `            ``{` `                ``Console.Write(``"Pair Found: "` `                ``+ ``"( "` `+ arr[i] + ``", "` `+ arr[j] +``" )"``);` `                `  `                ``return` `true``;` `            ``}` `            ``else` `if` `(arr[j] - arr[i] < n)` `                ``j++;` `            ``else` `                ``i++;` `        ``}`   `        ``Console.Write(``"No such pair"``);` `        `  `        ``return` `false``;` `    ``}`   `    ``// Driver program to test above function` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `[]arr = {1, 8, 30, 40, 100};` `        ``int` `n = 60;` `        `  `        ``findPair(arr, n);` `    ``}` `}`   `// This code is contributed by Sam007.`

## PHP

 ``

## Javascript

 ``

Output

`Pair Found: (100, 40)`

Time Complexity: O(n*log(n)) [Sorting is still required as first step], Where n is number of element in given array
Auxiliary Space: O(1)

The above code can be simplified and can be made more understandable by reducing bunch of If-Else checks . Thanks to Nakshatra Chhillar for suggesting this simplification. We will understand simplifications through following code:

## C++

 `// C++ program to find a pair with the given difference` `#include ` `using` `namespace` `std;` `bool` `findPair(``int` `arr[], ``int` `size, ``int` `n)` `{` `    ``// Step-1 Sort the array` `    ``sort(arr, arr + size);`   `    ``// Initialize positions of two elements` `    ``int` `l = 0;` `    ``int` `r = 1;`   `    ``// take absolute value of difference` `    ``// this does not affect the pair as A-B=diff is same as` `    ``// B-A= -diff` `    ``n = ``abs``(n);`   `    ``// Search for a pair`   `    ``// These loop running conditions are sufficient` `    ``while` `(l <= r and r < size) {` `        ``int` `diff = arr[r] - arr[l];` `        ``if` `(diff == n` `            ``and l != r) ``// we need distinct elements in pair` `                        ``// so l!=r` `        ``{` `            ``cout << ``"Pair Found: ("` `<< arr[l] << ``", "` `                 ``<< arr[r] << ``")"``;` `            ``return` `true``;` `        ``}` `        ``else` `if` `(diff > n) ``// try to reduce the diff` `            ``l++;` `        ``else` `// Note if l==r then r will be advanced thus no` `             ``// pair will be missed` `            ``r++;` `    ``}` `    ``cout << ``"No such pair"``;` `    ``return` `false``;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `arr[] = { 1, 8, 30, 40, 100 };` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `n = -60;` `    ``findPair(arr, size, n);` `    ``cout << endl;` `    ``n = 20;` `    ``findPair(arr, size, n);` `    ``return` `0;` `}`   `// This code is contributed by Nakshatra Chhillar`

## Java

 `// Java program to find a pair with the given difference` `import` `java.io.*;` `import` `java.util.Arrays;` ` `  `class` `GFG {` `static` `boolean` `findPair(``int` `arr[], ``int` `size, ``int` `n)` `{` `    ``// Step-1 Sort the array` `    ``Arrays.sort(arr);`   `    ``// Initialize positions of two elements` `    ``int` `l = ``0``;` `    ``int` `r = ``1``;`   `    ``// take absolute value of difference` `    ``// this does not affect the pair as A-B=diff is same as` `    ``// B-A= -diff` `    ``n = Math.abs(n);`   `    ``// Search for a pair`   `    ``// These loop running conditions are sufficient` `    ``while` `(l <= r && r < size) {` `        ``int` `diff = arr[r] - arr[l];` `        ``if` `(diff == n` `            ``&& l != r) ``// we need distinct elements in pair` `                        ``// so l!=r` `        ``{` `            ``System.out.print(``"Pair Found: ("` `+ arr[l] + ``", "` `                ``+ arr[r] + ``")"``);` `            ``return` `true``;` `        ``}` `        ``else` `if` `(diff > n) ``// try to reduce the diff` `            ``l++;` `        ``else` `// Note if l==r then r will be advanced thus no` `            ``// pair will be missed` `            ``r++;` `    ``}` `    ``System.out.print(``"No such pair"``);` `    ``return` `false``;` `}`   `// Driver program to test above function` `public` `static` `void` `main (String[] args) ` `{` `    ``int` `arr[] = { ``1``, ``8``, ``30``, ``40``, ``100` `};` `    ``int` `size = arr.length;` `    ``int` `n = -``60``;` `    ``findPair(arr, size, n);` `    ``System.out.println();` `    ``n = ``20``;` `    ``findPair(arr, size, n);` `}` `}`   `// This code is contributed by Pushpesh Raj`

## Python3

 `# Python program to find a pair with the given difference` `def` `findPair( arr, size, n):` `    ``# Step-1 Sort the array` `    ``arr.sort();` `    `  `    ``# Initialize positions of two elements` `    ``l ``=` `0``;` `    ``r ``=` `1``;`   `    ``# take absolute value of difference` `    ``# this does not affect the pair as A-B=diff is same as` `    ``# B-A= -diff` `    ``n ``=` `abs``(n);`   `    ``# Search for a pair`   `    ``# These loop running conditions are sufficient` `    ``while` `(l <``=` `r ``and` `r < size) :` `        ``diff ``=` `arr[r] ``-` `arr[l];` `        ``if` `(diff ``=``=` `n ``and` `l !``=` `r): ` `        ``# we need distinct elements in pair` `        ``# so l!=r` `            ``print``(``"Pair Found: ("` `, arr[l] , ``", "` `                 ``, arr[r] , ``")"``);` `            ``return` `True``;`   `        ``elif` `(diff > n):``# try to reduce the diff` `            ``l ``+``=` `1``;` `        ``else` `:``# Note if l==r then r will be advanced thus no` `             ``# pair will be missed` `            ``r``+``=``1``;`   `    ``print``(``"No such pair"``);` `    ``return` `False``;`   `# Driver program to test above function` `arr ``=` `[ ``1``, ``8``, ``30``, ``40``, ``100` `];` `size ``=` `len``(arr);` `n ``=` `-``60``;` `findPair(arr, size, n);` `n ``=` `20``;` `findPair(arr, size, n);`   `# This code is contributed by agrawalpoojaa976.`

## C#

 `// C# code implementation` `using` `System;` `using` `System.Collections;` `public` `class` `GFG` `{`   `  ``static` `bool` `findPair(``int``[] arr, ``int` `size, ``int` `n)` `  ``{`   `    ``// Step-1 Sort the array` `    ``Array.Sort(arr);`   `    ``// Initialize positions of two elements` `    ``int` `l = 0;` `    ``int` `r = 1;`   `    ``// take absolute value of difference` `    ``// this does not affect the pair as A-B=diff is same` `    ``// as B-A= -diff` `    ``n = Math.Abs(n);`   `    ``// Search for a pair`   `    ``// These loop running conditions are sufficient` `    ``while` `(l <= r && r < size) {` `      ``int` `diff = arr[r] - arr[l];` `      ``if` `(diff == n` `          ``&& l != r) ``// we need distinct elements in` `        ``// pair so l!=r` `      ``{` `        ``Console.Write(``"Pair Found: ("` `+ arr[l]` `                      ``+ ``", "` `+ arr[r] + ``")"``);` `        ``return` `true``;` `      ``}` `      ``else` `if` `(diff > n) ``// try to reduce the diff` `        ``l++;` `      ``else` `// Note if l==r then r will be advanced` `        ``// thus no` `        ``// pair will be missed` `        ``r++;` `    ``}` `    ``Console.Write(``"No such pair"``);` `    ``return` `false``;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int``[] arr = { 1, 8, 30, 40, 100 };` `    ``int` `size = arr.Length;` `    ``int` `n = -60;` `    ``findPair(arr, size, n);` `    ``Console.WriteLine();` `    ``n = 20;` `    ``findPair(arr, size, n);` `  ``}` `}`   `// This code is contributed by lokesh.`

## Javascript

 `// JavaScript program to find a pair with the given difference`   `const findPair = (arr, size, n) => {` `    ``// Step-1 Sort the array` `    ``arr.sort((a, b) => a - b);`   `    ``// Initialize positions of two elements` `    ``let l = 0;` `    ``let r = 1;`   `    ``// take absolute value of difference` `    ``// this does not affect the pair as A-B=diff is same as` `    ``// B-A= -diff` `    ``n = Math.abs(n);`   `    ``// Search for a pair`   `    ``// These loop running conditions are sufficient` `    ``while` `(l <= r && r < size) {` `        ``let diff = arr[r] - arr[l];` `        ``if` `(diff === n` `            ``&& l !== r) ``// we need distinct elements in pair` `                        ``// so l!==r` `        ``{` `            ``console.log(``"Pair Found: ("` `+ arr[l] + ``", "` `                ``+ arr[r] + ``")"``);` `            ``return` `true``;` `        ``}` `        ``else` `if` `(diff > n) ``// try to reduce the diff` `            ``l++;` `        ``else` `// Note if l==r then r will be advanced thus no` `             ``// pair will be missed` `            ``r++;` `    ``}` `    ``console.log(``"No such pair"``);` `    ``return` `false``;` `}`   `// Driver program to test above function` `const main = () => {` `    ``let arr = [1, 8, 30, 40, 100];` `    ``let size = arr.length;` `    ``let n = -60;` `    ``findPair(arr, size, n);` `    ``console.log();` `    ``n = 20;` `    ``findPair(arr, size, n);` `}`   `main();`

Output

```Pair Found: (40, 100)
No such pair```

Time Complexity: O(n*log(n)) [Sorting is still required as first step], Where n is number of element in given array
Auxiliary Space: O(1)

Method 4 :Hashing can also be used to solve this problem. Create an empty hash table HT. Traverse the array, use array elements as hash keys and enter them in HT. Traverse the array again look for value n + arr[i] in HT.

## C++

 `// C++ program to find a pair with the given difference` `#include ` `using` `namespace` `std;`   `// The function assumes that the array is sorted` `bool` `findPair(``int` `arr[], ``int` `size, ``int` `n)` `{` `    ``unordered_map<``int``, ``int``> mpp;` `    ``for` `(``int` `i = 0; i < size; i++) {` `        ``mpp[arr[i]]++;`   `        ``// Check if any element whose frequency` `        ``// is greater than 1 exist or not for n == 0` `        ``if` `(n == 0 && mpp[arr[i]] > 1)` `            ``return` `true``;` `    ``}`   `    ``// Check if difference is zero and` `    ``// we are unable to find any duplicate or` `    ``// element whose frequency is greater than 1` `    ``// then no such pair found.` `    ``if` `(n == 0)` `        ``return` `false``;`   `    ``for` `(``int` `i = 0; i < size; i++) {` `        ``if` `(mpp.find(n + arr[i]) != mpp.end()) {` `            ``cout << ``"Pair Found: ("` `<< arr[i] << ``", "` `                 ``<< n + arr[i] << ``")"``;` `            ``return` `true``;` `        ``}` `    ``}`   `    ``cout << ``"No Pair found"``;` `    ``return` `false``;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `arr[] = { 1, 8, 30, 40, 100 };` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `n = -60;` `    ``findPair(arr, size, n);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG` `{`   `  ``// The function assumes that the array is sorted` `  ``static` `boolean` `findPair(``int``[] arr, ``int` `size, ``int` `n)` `  ``{` `    ``HashMap mpp = ``new` `HashMap();`   `     ``// Traverse the array` `    ``for``(``int` `i = ``0``; i < size; i++)` `    ``{` `         `  `        ``// Update frequency` `        ``// of arr[i]` `        ``mpp.put(arr[i],` `               ``mpp.getOrDefault(arr[i], ``0``) + ``1``);` `      `  `        ``// Check if any element whose frequency` `        ``// is greater than 1 exist or not for n == 0` `        ``if` `(n == ``0` `&& mpp.get(arr[i]) > ``1``)` `            ``return` `true``;` `    ``}` ` `  `     ``// Check if difference is zero and` `    ``// we are unable to find any duplicate or` `    ``// element whose frequency is greater than 1` `    ``// then no such pair found.` `    ``if` `(n == ``0``)` `        ``return` `false``;`   `    ``for` `(``int` `i = ``0``; i < size; i++) {` `      ``if` `(mpp.containsKey(n + arr[i])) {` `        ``System.out.print(``"Pair Found: ("` `+ arr[i] + ``", "` `+` `                      ``+ (n + arr[i]) + ``")"``);` `        ``return` `true``;` `      ``}` `    ``}` `    ``System.out.print(``"No Pair found"``);` `    ``return` `false``;` `  ``}`     `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int``[] arr = { ``1``, ``8``, ``30``, ``40``, ``100` `};` `    ``int` `size = arr.length;` `    ``int` `n = -``60``;` `    ``findPair(arr, size, n);` `}` `}`   `// This code is contributed by code_hunt.`

## Python3

 `# Python program to find a pair with the given difference`   `# The function assumes that the array is sorted` `def` `findPair(arr, size, n):`   `    ``mpp ``=` `{}`   `    ``for` `i ``in` `range``(size):` `        ``if` `arr[i] ``in` `mpp.keys():` `             ``mpp[arr[i]] ``+``=` `1` `             ``if``(n ``=``=` `0` `and` `mpp[arr[i]] > ``1``): ` `                ``return` `true;` `        ``else``:` `             ``mpp[arr[i]] ``=` `1` `    `  `    ``if``(n ``=``=` `0``):` `      ``return` `false;`   `    ``for` `i ``in` `range``(size):` `         ``if` `n ``+` `arr[i] ``in` `mpp.keys():` `            ``print``(``"Pair Found: ("` `+` `str``(arr[i]) ``+` `", "` `+` `str``(n ``+` `arr[i]) ``+` `")"``)` `            ``return` `True` `    `  `    ``print``(``"No Pair found"``)` `    ``return` `False`   `# Driver program to test above function` `arr ``=` `[ ``1``, ``8``, ``30``, ``40``, ``100` `]` `size ``=` `len``(arr)` `n ``=` `-``60` `findPair(arr, size, n)`   `# This code is contributed by shinjanpatra`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `// The function assumes that the array is sorted` `static` `bool` `findPair(``int``[] arr, ``int` `size, ``int` `n)` `{` `    ``Dictionary<``int``, ``int``> mpp = ``new` `Dictionary<``int``, ``int``>();`   `    ``// Traverse the array` `    ``for``(``int` `i = 0; i < size; i++)` `    ``{` `        `  `        ``// Update frequency` `        ``// of arr[i]` `        ``mpp[arr[i]]=mpp.GetValueOrDefault(arr[i], 0) + 1;` `    `  `        ``// Check if any element whose frequency` `        ``// is greater than 1 exist or not for n == 0` `        ``if` `(n == 0 && mpp[arr[i]] > 1)` `            ``return` `true``;` `    ``}`   `    ``// Check if difference is zero and` `    ``// we are unable to find any duplicate or` `    ``// element whose frequency is greater than 1` `    ``// then no such pair found.` `    ``if` `(n == 0)` `        ``return` `false``;`   `    ``for` `(``int` `i = 0; i < size; i++) {` `    ``if` `(mpp.ContainsKey(n + arr[i])) {` `        ``Console.WriteLine(``"Pair Found: ("` `+ arr[i] + ``", "` `+` `                    ``+ (n + arr[i]) + ``")"``);` `        ``return` `true``;` `    ``}` `    ``}` `    ``Console.WriteLine(``"No Pair found"``);` `    ``return` `false``;` `}`   `// Driver Code` `public` `static` `void` `Main(``string` `[]args) ` `{` `    ``int``[] arr = { 1, 8, 30, 40, 100 };` `    ``int` `size = arr.Length;` `    ``int` `n = -60;` `    ``findPair(arr, size, n);` `}` `}`   `// This code is contributed by Aman Kumar`

## Javascript

 ``

Output

`Pair Found: (100, 40)`

Time Complexity: O(n), Where n is number of element in given array
Auxiliary Space: O(n)

Please write comments if you find any of the above codes/algorithms incorrect, or find other ways to solve the same problem.

My Personal Notes arrow_drop_up
Similar Reads
Related Tutorials