Count of unique pairs (i, j) in an array such that sum of A[i] and reverse of A[j] is equal to sum of reverse of A[i] and A[j]

Difficulty Level : Easy
Last Updated : 17 Mar, 2021

Given an array arr[] consisting of N positive integers, the task is to find the count of unique pairs (i, j) such that the sum of arr[i] and the reverse(arr[j]) is same as the sum of reverse(arr[i]) and arr[j].

Examples:

Input: arr[] = {2, 15, 11, 7}
Output: 3
Explanation:
The pairs are (0, 2), (0, 3) and (2, 3).

(0, 2): arr[0] + reverse(arr[2]) (= 2 + 11 = 211) and reverse(arr[0]) + arr[2](= 2 + 11 = 211).
(0, 3): arr[0] + reverse(arr[3]) (= 2 + 7 = 27) and reverse(arr[0]) + arr[3](= 2 + 7 = 27).
(2, 3): arr[2] + reverse(arr[3]) (= 11 + 7 = 117) and reverse(arr[2]) + arr[3](= 11 + 7 = 117).
Input: A[] = {22, 115, 7, 313, 17, 23, 22}
Output: 6

Naive Approach: The simplest approach is to generate all possible pairs of the given array and if any pair of elements satisfy the given conditions then count these pairs. After completing the above stepsm, print the value of count as the result.

Time Complexity: O(N²*log M), where M is the maximum element in A[]
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using Hashing technique and rewriting the equation as:

A[i] + reverse(A[j]) = reverse(A[i]) + A[j]
=> A[i] – reverse(A[i]) = A[j] – reverse(A[j])

Now, the idea is to count the frequency of (A[i] – reverse(A[i])) for every element arr[i] and then count possible number of valid pairs satisfying the given condition. Follow the steps below to solve the problem:

Maintain a Hashmap, say u_map to store the frequency count of A[i] – reverse(A[i]) for any index i.
Initialize a variable pairs to store the number of pairs that satisfy the given condition.
Traverse the given array A[] using the variable i and perform the following operations:
- Store the frequency of A[i] – reverse(A[i]) in val.
- Increment pairs by val.
- Update the frequency of val in u_map.
After completing the above steps, print the value of pairs as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the
// reverse of the number n
int reverse(int n)
{
    int temp = n, rev = 0, r;
 
    // Iterate until temp is 0
    while (temp) {
 
        r = temp % 10;
        rev = rev * 10 + r;
        temp /= 10;
    }
 
    // Return the reversed number
    return rev;
}
 
// Function to count number of unique
// pairs (i, j) from the array A[]
// which satisfies the given condition
void countPairs(int A[], int N)
{
    // Store the frequency of keys
    // as A[i] - reverse(A[i])
    unordered_map<int, int> u_map;
 
    // Stores count of desired pairs
    int pairs = 0;
 
    // Iterate the array A[]
    for (int i = 0; i < N; i++) {
 
        int val = A[i] - reverse(A[i]);
 
        // Add frequency of val
        // to the required answer
        pairs += u_map[val];
 
        // Increment frequency of val
        u_map[val]++;
    }
 
    // Print the number of pairs
    cout << pairs;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 15, 11, 7 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    countPairs(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Function to find the
// reverse of the number n
static int reverse(int n)
{
    int temp = n, rev = 0, r;
 
    // Iterate until temp is 0
    while (temp > 0)
    {
        r = temp % 10;
        rev = rev * 10 + r;
        temp /= 10;
    }
 
    // Return the reversed number
    return rev;
}
 
// Function to count number of unique
// pairs (i, j) from the array A[]
// which satisfies the given condition
static void countPairs(int A[], int N)
{
     
    // Store the frequency of keys
    // as A[i] - reverse(A[i])
    HashMap<Integer, Integer> map = new HashMap<>();
 
    // Stores count of desired pairs
    int pairs = 0;
 
    // Iterate the array A[]
    for(int i = 0; i < N; i++)
    {
        int val = A[i] - reverse(A[i]);
 
        // Add frequency of val
        // to the required answer
        pairs += map.getOrDefault(val, 0);
 
        // Increment frequency of val
        map.put(val, map.getOrDefault(val, 0) + 1);
    }
 
    // Print the number of pairs
    System.out.println(pairs);
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 2, 15, 11, 7 };
    int N = arr.length;
 
    // Function Call
    countPairs(arr, N);
}
}
 
// This code is contributed by Kingash

Python3

# Python3 program for the above approach
from collections import defaultdict
 
# Function to find the
# reverse of the number n
def reverse(n):
    temp = n
    rev = 0
 
    # Iterate until temp is 0
    while (temp):
        r = temp % 10
        rev = rev * 10 + r
        temp //= 10
 
    # Return the reversed number
    return rev
 
# Function to count number of unique
# pairs (i, j) from the array A[]
# which satisfies the given condition
def countPairs(A, N):
 
    # Store the frequency of keys
    # as A[i] - reverse(A[i])
    u_map = defaultdict(int)
 
    # Stores count of desired pairs
    pairs = 0
 
    # Iterate the array A[]
    for i in range(N):
        val = A[i] - reverse(A[i])
 
        # Add frequency of val
        # to the required answer
        pairs += u_map[val]
 
        # Increment frequency of val
        u_map[val] += 1
 
    # Print the number of pairs
    print(pairs)
 
 
# Driver Code
if __name__ == "__main__":
 
    arr = [2, 15, 11, 7]
    N = len(arr)
 
    # Function Call
    countPairs(arr, N)
 
    # This code is contributed by chitranayal.

Output:

Time Complexity: O(N*log M), where M is the largest element in the array.
Auxiliary Space: O(1)

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.

My Personal Notes

Related Articles

C++

Java

Python3