Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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 : 08 Jun, 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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 = 13) and reverse(arr[0]) + arr[2](= 2 + 11 = 13).
  • (0, 3): arr[0] + reverse(arr[3]) (= 2 + 7 = 9) and reverse(arr[0]) + arr[3](= 2 + 7 = 9).
  • (2, 3): arr[2] + reverse(arr[3]) (= 11 + 7 = 18) and reverse(arr[2]) + arr[3](= 11 + 7 = 18).

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(N2*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.
C#



// C# program for the above approach
using System;
using System.Collections.Generic;
 
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])
    Dictionary<int,
               int> u_map = new Dictionary<int,
                                           int>();
                                            
    // 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
        if (u_map.ContainsKey(val))
            pairs += u_map[val];
 
        // Increment frequency of val
        if (u_map.ContainsKey(val))
            u_map[val]++;
        else
            u_map.Add(val, 1);
    }
 
    // Print the number of pairs
    Console.Write(pairs);
}
 
// Driver Code
public static void Main()
{
    int []arr = { 2, 15, 11, 7 };
    int N = arr.Length;
 
    // Function Call
    countPairs(arr, N);
}
}
 
// This code is contributed by SURENDRA_GANGWAR
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to find the
// reverse of the number n
function reverse(n)
{
    var temp = n, rev = 0, r;
 
    // Iterate until temp is 0
    while (temp) {
 
        r = temp % 10;
        rev = rev * 10 + r;
        temp = parseInt(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
function countPairs(A, N)
{
    // Store the frequency of keys
    // as A[i] - reverse(A[i])
    var u_map = new Map();
 
    // Stores count of desired pairs
    var pairs = 0;
 
    // Iterate the array A[]
    for (var i = 0; i < N; i++) {
 
        var val = A[i] - reverse(A[i]);
 
        // Add frequency of val
        // to the required answer
        pairs += u_map.has(val)?u_map.get(val):0;
 
        // Increment frequency of val
        if(u_map.has(val))
            u_map.set(val, u_map.get(val)+1)
        else
            u_map.set(val, 1)
    }
 
    // Print the number of pairs
    document.write( pairs);
}
 
// Driver Code
var arr = [2, 15, 11, 7];
var N = arr.length;
 
// Function Call
countPairs(arr, N);
 
// This code is contributed by itsok.
</script>
Output: 
3
 
Time Complexity: O(N*log M), where M is the largest element in the array.
Auxiliary Space: O(1)



My Personal Notes
arrow_drop_up
Previous
Sum of Fibonacci Numbers | Set 2
Next

Class 12 RD Sharma Solutions - Chapter 22 Differential Equations - Exercise 22.2 | Set 2
Recommended Articles
Page :
Count of unique pairs (arr[i], arr[j]) such that i < j
04, Feb 19
Count of pairs {X, Y} from an array such that sum of count of set bits in X ⊕ Y and twice the count of set bits in X & Y is M
12, Mar 21
Count pairs in array such that one element is reverse of another
14, Apr 20
Count the pairs in an array such that the difference between them and their indices is equal
09, Oct 19
Count pairs in an array such that both elements has equal set bits
16, Nov 18
Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND
22, Feb 21
Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR
22, Feb 21
Maximum possible sum of a window in an array such that elements of same window in other array are unique
04, Aug 17
Partition an array into two subsets with equal count of unique elements
29, Jun 21
Minimum sum of all differences between unique pairs in the Array
06, Aug 21
Count of pairs (arr[i], arr[j]) such that arr[i] + j and arr[j] + i are equal
11, Nov 21
Max count of unique ratio/fraction pairs in given arrays
12, Jun 20
Count of indices pairs such that product of elements at these indices is equal to absolute difference of indices
07, Jul 21
Count of pairs upto N such whose LCM is not equal to their product for Q queries
24, Apr 20
Count of equal value pairs from given two Arrays such that a[i] equals b[j]
06, Dec 21
Count pairs in an array having sum of elements with their respective sum of digits equal
10, Aug 21
Find Unique pair in an array with pairs of numbers
03, Oct 17
Number of unique pairs in an array
23, Jan 19
Find the GCD of LCM of all unique pairs in an Array
14, May 20
Generate a permutation of first N natural numbers having count of unique adjacent differences equal to K
26, May 21
Generate a permutation of first N natural numbers having count of unique adjacent differences equal to K | Set 2
30, Nov 21
Find an element in array such that sum of left array is equal to sum of right array
07, Sep 17
Count pairs from an array having sum of twice of their AND and XOR equal to K
01, Feb 21
Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
17, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ManikantaBandla
@ManikantaBandla
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!