Count of elements such that its sum/difference with X also exists in the Array

Given an array arr[] and an integer X, the task is to count the elements of the array such that their exist a element or in the array.
Examples:

Input: arr[] = {3, 4, 2, 5}, X = 2 
Output: 4 
Explanation:
In the above-given example, there are 4 such numbers – 
For Element 3: Possible numbers are 1, 5, whereas 5 is present in array 
For Element 4: Possible numbers are 2, 6, whereas 2 is present in array 
For Element 2: Possible numbers are 0, 4, whereas 4 is present in array 
For Element 5: Possible numbers are 3, 7, whereas 3 is present in array 
Therefore, Total count = 4
Input: arr[] = {2, 2, 4, 5, 6}, X = 3 
Output: 3 
Explanation:
In the above-given example, there are 3 such numbers {2, 2, 5} 

Brute Force Approach:

1. Initialize a variable count to 0 to keep track of the count of elements that satisfy the condition.
2. Loop through each element ‘num’ in the array arr.
3. For each element ‘num’, check if either ‘num + x’ or ‘num – x’ is present in the array arr.
4. If either ‘num + x’ or ‘num – x’ is present in the array arr, increment the count variable.
5. After looping through all elements in the array arr, return the value of count.

Below is the implementation of the above approach:

C++

// C++ implementation to count of
// elements such that its sum/difference
// with X also exists in the Array

#include <bits/stdc++.h>

using namespace std;

// Function to find the count of
// elements in the array such that
// element at the difference at X
// is present in the array
void findAns(int arr[], int n, int x)
{
    int count = 0;
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if(i != j && (arr[i] - arr[j] == x || arr[j] - arr[i] == x))
            {
                count++;
                break;
            }
        }
    }
    cout << count << endl;
}


// Driver Code
int main()
{
    int arr[] = { 2, 2, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(int);
    int x = 3;

    findAns(arr, n, x);

    return 0;
}

Java

import java.util.*;

public class Main {
    // Function to find the count of elements in the array such that
    // element at the difference at X is present in the array
    public static void findAns(int[] arr, int n, int x) {
        int count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i != j && (arr[i] - arr[j] == x || arr[j] - arr[i] == x)) {
                    count++;
                    break;
                }
            }
        }
        System.out.println(count);
    }

    // Driver Code
    public static void main(String[] args) {
        int[] arr = {2, 2, 4, 5, 6};
        int n = arr.length;
        int x = 3;

        findAns(arr, n, x);
    }
}

Python3

def findAns(arr, n, x):
    # Function to find the count of elements in the array such that
    # element at the difference at X is present in the array
    count = 0
    for i in range(n):
        for j in range(n):
            if i != j and (arr[i] - arr[j] == x or arr[j] - arr[i] == x):
                count += 1
                break
    print(count)

# Driver code
if __name__ == '__main__':
    arr = [2, 2, 4, 5, 6]
    n = len(arr)
    x = 3

    findAns(arr, n, x)

C#

using System;

class Program
{
    // Function to find the count of elements in the array such that the
    // element's sum or difference with X exists in the array
    static void FindCount(int[] arr, int n, int x)
    {
        int count = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i != j && (arr[i] - arr[j] == x || arr[j] - arr[i] == x))
                {
                    count++;
                    break;
                }
            }
        }
        Console.WriteLine(count);
    }

    // Driver Code
    static void Main()
    {
        int[] arr = { 2, 2, 4, 5, 6 };
        int n = arr.Length;
        int x = 3;

        FindCount(arr, n, x);
    }
}

Javascript

function findAns(arr, N, x) {
    let count = 0;
    for (let i = 0; i < N; i++) {
        for (let j = 0; j < N; j++) {
            if (i !== j && (arr[i] - arr[j] === x || arr[j] - arr[i] === x)) {
                count++;
                break;
            }
        }
    }
    console.log(count);
}
// Driver Code
const arr = [2, 2, 4, 5, 6];
const N = arr.length;
const x = 3;
GFG(arr, N, x);

Output

3

Time Complexity: O(N^2)
Auxiliary Space: O(1)

Approach: The idea is to use hash-map to check that an element is present in the hash-map or not in O(1) time. Then, iterate over the elements of the array and for each element check that or is present in the array. If yes, then increment the count of such elements by 1.
Below is the implementation of the above approach:

C++

// C++ implementation to count of
// elements such that its sum/difference
// with X also exists in the Array

#include <bits/stdc++.h>

using namespace std;

// Function to find the count of
// elements in the array such that
// element at the difference at X
// is present in the array
void findAns(int arr[], int n, int x)
{
    int ans;
    unordered_set<int> s;

    // Loop to insert the elements
    // of the array into the set
    for (int i = 0; i < n; i++)
        s.insert(arr[i]);

    ans = 0;

    // Loop to iterate over the array
    for (int i = 0; i < n; i++) {

        // if any of the elements are there
        // then increase the count variable
        if (s.find(arr[i] + x) != s.end() || s.find(arr[i] - x) != s.end())
            ans++;
    }
    cout << ans;
    return;
}

// Driver Code
int main()
{
    int arr[] = { 2, 2, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(int);
    int x = 3;

    findAns(arr, n, x);

    return 0;
}

Java

// Java implementation to count of
// elements such that its sum/difference
// with X also exists in the Array
import java.util.*;
class GFG{

// Function to find the count of
// elements in the array such that
// element at the difference at X
// is present in the array
static void findAns(int arr[],
                    int n, int x)
{
    int ans;
    HashSet<Integer> s = new HashSet<Integer>();

    // Loop to insert the elements
    // of the array into the set
    for (int i = 0; i < n; i++)
        s.add(arr[i]);

    ans = 0;

    // Loop to iterate over the array
    for (int i = 0; i < n; i++)
    {

        // if any of the elements are there
        // then increase the count variable
        if (s.contains(arr[i] + x) ||
            s.contains(arr[i] - x))
            ans++;
    }
    System.out.print(ans);
    return;
}

// Driver Code
public static void main(String[] args)
{
    int arr[] = { 2, 2, 4, 5, 6 };
    int n = arr.length;
    int x = 3;

    findAns(arr, n, x);
}
}

// This code is contributed by Rajput-Ji

Python3

# Python3 implementation to count of
# elements such that its sum/difference
# with X also exists in the array

# Function to find the count of
# elements in the array such that
# element at the difference at X
# is present in the array
def findAns(arr, n, x):

    s = set()

    # Loop to insert the elements
    # of the array into the set
    for i in range(n):
        s.add(arr[i])

    ans = 0

    # Loop to iterate over the array
    for i in range(n):

        # If any of the elements are there
        # then increase the count variable
        if arr[i] + x in s or arr[i] - x in s:
            ans = ans + 1

    print(ans)

# Driver Code
arr = [ 2, 2, 4, 5, 6 ]
n = len(arr)
x = 3

# Function call
findAns(arr, n, x)

# This code is contributed by ishayadav181

C#

// C# implementation to count of
// elements such that its sum/difference
// with X also exists in the Array
using System;
using System.Collections.Generic;

class GFG{

// Function to find the count of
// elements in the array such that
// element at the difference at X
// is present in the array
static void findAns(int[] arr,
                    int n, int x)
{
    int ans;
    HashSet<int> s = new HashSet<int>();

    // Loop to insert the elements
    // of the array into the set
    for(int i = 0; i < n; i++)
       s.Add(arr[i]);

    ans = 0;

    // Loop to iterate over the array
    for(int i = 0; i < n; i++)
    {

       // if any of the elements are there
       // then increase the count variable
       if (s.Contains(arr[i] + x) ||
           s.Contains(arr[i] - x))
           ans++;
    }
    Console.Write(ans);
    return;
}

// Driver Code
public static void Main(String[] args)
{
    int[] arr = { 2, 2, 4, 5, 6 };
    int n = arr.Length;
    int x = 3;

    findAns(arr, n, x);
}
}

// This code is contributed by ShubhamCoder

Javascript

<script>

// Javascript implementation to count of
// elements such that its sum/difference
// with X also exists in the Array

// Function to find the count of
// elements in the array such that
// element at the difference at X
// is present in the array
function findAns(arr, n, x)
{
    let ans;
    let s = new Set();

    // Loop to insert the elements
    // of the array leto the set
    for (let i = 0; i < n; i++)
        s.add(arr[i]);

    ans = 0;

    // Loop to iterate over the array
    for (let i = 0; i < n; i++)
    {

        // if any of the elements are there
        // then increase the count variable
        if (s.has(arr[i] + x) ||
            s.has(arr[i] - x))
            ans++;
    }
    document.write(ans);
    return;
}

// Driver code

      let arr = [ 2, 2, 4, 5, 6 ];
    let n = arr.length;
    let x = 3;

    findAns(arr, n, x);

 // This code is contributed by code_hunt.
</script>

Output

3

Performance Analysis:

• Time Complexity: O(N)
• Auxiliary Space Complexity: O(N)