Given an **array a[] and an integer k**, find the number of elements x in this array such that the sum of x and k is also present in the array.

**Examples:**

Input:{ 3, 6, 2, 8, 7, 6, 5, 9 } and k = 2Output:5Explanation:Elements {3, 6, 7, 6, 5} in this array have x + 2 value that is {5, 8, 9, 8, 7} present in this array.Input:{ 1, 2, 3, 4, 5} and k = 1Output:4Explanation:Elements {1, 2, 3, 4} in this array have x + 2 value that is {2, 3, 4, 5} present in this array.

The problem is similar to finding the count of pairs with a given sum in an Array.

**Naive Approach:**

The solve the problem mentioned above we can use the brute force approach and find the result. Iterate two loops, check whether x+2 exists in an array or not for each x in this array. If it exists then increment the count and finally return the count.

**Efficient Approach:**

The efficient approach to solve the problem is to use a HashMap, the key in map will act as the unique element in this array and the corresponding value will tell us the frequency of this element.

Iterate over this map and find for each key x in this map whether the key x + k exists in the map or not, if exist then add this frequency to the answer i.e for this element x we have x+k in this array. Finally, return the answer.

Below is the implementation of the above approach:

## C++

`// C++ implementation of find number ` `// of elements x in this array ` `// such x+k also present in this array. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the ` `// count of element x such that ` `// x+k also lies in this array ` `int` `count_element(` `int` `N, ` `int` `K, ` `int` `* arr) ` `{ ` ` ` `// Key in map will store elements ` ` ` `// and value will store the ` ` ` `// frequency of the elements ` ` ` `map<` `int` `, ` `int` `> mp; ` ` ` ` ` `for` `(` `int` `i = 0; i < N; ++i) ` ` ` `mp[arr[i]]++; ` ` ` ` ` `int` `answer = 0; ` ` ` ` ` `for` `(` `auto` `i : mp) { ` ` ` ` ` `// Find if i.first + K is ` ` ` `// present in this map or not ` ` ` `if` `(mp.find(i.first + K) != mp.end()) ` ` ` ` ` `// If we find i.first or key + K in this map ` ` ` `// then we have to increase in answer ` ` ` `// the frequency of this element ` ` ` `answer += i.second; ` ` ` `} ` ` ` ` ` `return` `answer; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `// array initialisation ` ` ` `int` `arr[] = { 3, 6, 2, 8, 7, 6, 5, 9 }; ` ` ` ` ` `// size of array ` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]); ` ` ` ` ` `// initialise k ` ` ` `int` `K = 2; ` ` ` ` ` `cout << count_element(N, K, arr); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of find number ` `// of elements x in this array ` `// such x+k also present in this array. ` `import` `java.util.*; ` ` ` `class` `GFG{ ` ` ` `// Function to return the ` `// count of element x such that ` `// x+k also lies in this array ` `static` `int` `count_element(` `int` `N, ` `int` `K, ` `int` `[] arr) ` `{ ` ` ` `// Key in map will store elements ` ` ` `// and value will store the ` ` ` `// frequency of the elements ` ` ` `HashMap<Integer,Integer> mp = ` `new` `HashMap<Integer,Integer>(); ` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < N; ++i) ` ` ` `if` `(mp.containsKey(arr[i])){ ` ` ` `mp.put(arr[i], mp.get(arr[i])+` `1` `); ` ` ` `}` `else` `{ ` ` ` `mp.put(arr[i], ` `1` `); ` ` ` `} ` ` ` ` ` `int` `answer = ` `0` `; ` ` ` ` ` `for` `(Map.Entry<Integer,Integer> i : mp.entrySet()) { ` ` ` ` ` `// Find if i.first + K is ` ` ` `// present in this map or not ` ` ` `if` `(mp.containsKey(i.getKey() + K) ) ` ` ` ` ` `// If we find i.first or key + K in this map ` ` ` `// then we have to increase in answer ` ` ` `// the frequency of this element ` ` ` `answer += i.getValue(); ` ` ` `} ` ` ` ` ` `return` `answer; ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `// array initialisation ` ` ` `int` `arr[] = { ` `3` `, ` `6` `, ` `2` `, ` `8` `, ` `7` `, ` `6` `, ` `5` `, ` `9` `}; ` ` ` ` ` `// size of array ` ` ` `int` `N = arr.length; ` ` ` ` ` `// initialise k ` ` ` `int` `K = ` `2` `; ` ` ` ` ` `System.out.print(count_element(N, K, arr)); ` `} ` `} ` ` ` `// This code is contributed by Princi Singh ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of find number ` `# of elements x in this array ` `# such x+k also present in this array. ` ` ` `# Function to return the ` `# count of element x such that ` `# x+k also lies in this array ` `def` `count_element(N, K, arr): ` ` ` ` ` `# Key in map will store elements ` ` ` `# and value will store the ` ` ` `# frequency of the elements ` ` ` `mp ` `=` `dict` `() ` ` ` ` ` `for` `i ` `in` `range` `(N): ` ` ` `mp[arr[i]] ` `=` `mp.get(arr[i], ` `0` `) ` `+` `1` ` ` ` ` `answer ` `=` `0` ` ` ` ` `for` `i ` `in` `mp: ` ` ` ` ` `# Find if i.first + K is ` ` ` `# present in this map or not ` ` ` `if` `i ` `+` `K ` `in` `mp: ` ` ` ` ` `# If we find i.first or key + K in this map ` ` ` `# then we have to increase in answer ` ` ` `# the frequency of this element ` ` ` `answer ` `+` `=` `mp[i] ` ` ` ` ` `return` `answer ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` `# array initialisation ` ` ` `arr` `=` `[` `3` `, ` `6` `, ` `2` `, ` `8` `, ` `7` `, ` `6` `, ` `5` `, ` `9` `] ` ` ` ` ` `# size of array ` ` ` `N ` `=` `len` `(arr) ` ` ` ` ` `# initialise k ` ` ` `K ` `=` `2` ` ` ` ` `print` `(count_element(N, K, arr)) ` ` ` `# This code is contributed by mohit kumar 29 ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of find number ` `// of elements x in this array ` `// such x+k also present in this array. ` `using` `System; ` `using` `System.Collections.Generic; ` ` ` `public` `class` `GFG{ ` ` ` `// Function to return the ` `// count of element x such that ` `// x+k also lies in this array ` `static` `int` `count_element(` `int` `N, ` `int` `K, ` `int` `[] arr) ` `{ ` ` ` `// Key in map will store elements ` ` ` `// and value will store the ` ` ` `// frequency of the elements ` ` ` `Dictionary<` `int` `,` `int` `> mp = ` `new` `Dictionary<` `int` `,` `int` `>(); ` ` ` ` ` `for` `(` `int` `i = 0; i < N; ++i) ` ` ` `if` `(mp.ContainsKey(arr[i])){ ` ` ` `mp[arr[i]] = mp[arr[i]]+1; ` ` ` `}` `else` `{ ` ` ` `mp.Add(arr[i], 1); ` ` ` `} ` ` ` ` ` `int` `answer = 0; ` ` ` ` ` `foreach` `(KeyValuePair<` `int` `,` `int` `> i ` `in` `mp) { ` ` ` ` ` `// Find if i.first + K is ` ` ` `// present in this map or not ` ` ` `if` `(mp.ContainsKey(i.Key + K) ) ` ` ` ` ` `// If we find i.first or key + K in this map ` ` ` `// then we have to increase in answer ` ` ` `// the frequency of this element ` ` ` `answer += i.Value; ` ` ` `} ` ` ` ` ` `return` `answer; ` `} ` ` ` `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` ` `// array initialisation ` ` ` `int` `[]arr = { 3, 6, 2, 8, 7, 6, 5, 9 }; ` ` ` ` ` `// size of array ` ` ` `int` `N = arr.Length; ` ` ` ` ` `// initialise k ` ` ` `int` `K = 2; ` ` ` ` ` `Console.Write(count_element(N, K, arr)); ` `} ` `} ` `// This code contributed by Princi Singh ` |

*chevron_right*

*filter_none*

**Output:**

5

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:

- Count of elements such that its sum/difference with X also exists in the Array
- Count of elements A[i] such that A[i] + 1 is also present in the Array
- Maximum difference between frequency of two elements such that element having greater frequency is also greater
- Count of all values of N in [L, R] such that count of primes upto N is also prime
- First string from the given array whose reverse is also present in the same array
- Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
- Count number of subsets whose median is also present in the same subset
- Find if there exists a direction for ranges such that no two range intersect
- Create an array of size N with sum S such that no subarray exists with sum S or S-K
- Generate a pair of integers from a range [L, R] whose LCM also lies within the range
- Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
- Find K such that changing all elements of the Array greater than K to K will make array sum N
- Check if a subarray of size K exists whose elements form a number divisible by 3
- Count the number of sub-arrays such that the average of elements present in the sub-array is greater than that not present in the sub-array
- Check whether (i,j) exists such that arr[i] != arr[j] and arr[arr[i]] is equal to arr[arr[j]]
- Check whether there exists a triplet (i, j, k) such that arr[i] < arr[k] < arr[j] for i < j < k
- Rearrange array such that even index elements are smaller and odd index elements are greater
- Generate an array of K elements such that sum of elements is N and the condition a[i] < a[i+1] <= 2*a[i] is met | Set 2
- Rearrange array elements such that Bitwise AND of first N - 1 elements is equal to last element
- Minimum number of elements to be removed such that the sum of the remaining elements is equal to k

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.