Open In App

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

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]

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 the 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 = 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 steps, 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:

Below is the implementation of the above approach:




// 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 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 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# 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


















                        






                        























                                    



                                    




                                    




                                    


                                



















<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*log10 M), where M is the largest element in the array.
Auxiliary Space: O(N)

	

        Article Tags : 
        

            Arrays
DSA
Hash        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Find unique pairs such that each element is less than or equal to N

          
2. 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

          
3. Count of unique pairs (arr[i], arr[j]) such that i < j

          
4. Count pairs in array such that one element is reverse of another

          
5. Count the pairs in an array such that the difference between them and their indices is equal

          
6. Count pairs in an array such that both elements has equal set bits

          
7. Maximize count of pairs whose Bitwise AND exceeds Bitwise XOR by replacing such pairs with their Bitwise AND

          
8. Count ways to remove pairs from a matrix such that remaining elements can be grouped in vertical or horizontal pairs

          
9. Maximize count of pairs whose bitwise XOR is even by replacing such pairs with their Bitwise XOR

          
10. Maximum count of pairs such that element at each index i is included in i pairs

          
11. Count pairs in an array having sum of elements with their respective sum of digits equal

          
12. Count of pairs (arr[i], arr[j]) such that arr[i] + j and arr[j] + i are equal

          
13. Find an element in array such that sum of left array is equal to sum of right array

          
14. Maximum possible sum of a window in an array such that elements of same window in other array are unique

          
15. Count of equal value pairs from given two Arrays such that a[i] equals b[j]

          
16. Count of pairs (A, B) in range 1 to N such that last digit of A is equal to the first digit of B

          
17. Count of pairs upto N such whose LCM is not equal to their product for Q queries

          
18. Count of indices pairs such that product of elements at these indices is equal to absolute difference of indices

          
19. Count of index pairs (i, j) such that string after deleting ith character is equal to string after deleting jth character

          
20. Partition an array into two subsets with equal count of unique elements

          
21. Count pairs from an array having sum of twice of their AND and XOR equal to K

          
22. Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring

          
23. Minimum sum of all differences between unique pairs in the Array

          
24. Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element

          
25. Count pairs from an array having product of their sum and difference equal to 0