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]
Last Updated :
28 Dec, 2022
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:
- Maintain a Hashmap, say u_map to store the frequency count of A[i] – reverse(A[i]) for any index i.
- Initialize 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++
#include <bits/stdc++.h>
using namespace std;
int reverse( int n)
{
int temp = n, rev = 0, r;
while (temp) {
r = temp % 10;
rev = rev * 10 + r;
temp /= 10;
}
return rev;
}
void countPairs( int A[], int N)
{
unordered_map< int , int > u_map;
int pairs = 0;
for ( int i = 0; i < N; i++) {
int val = A[i] - reverse(A[i]);
pairs += u_map[val];
u_map[val]++;
}
cout << pairs;
}
int main()
{
int arr[] = { 2, 15, 11, 7 };
int N = sizeof (arr) / sizeof (arr[0]);
countPairs(arr, N);
return 0;
}
|
Java
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
static int reverse( int n)
{
int temp = n, rev = 0 , r;
while (temp > 0 )
{
r = temp % 10 ;
rev = rev * 10 + r;
temp /= 10 ;
}
return rev;
}
static void countPairs( int A[], int N)
{
HashMap<Integer, Integer> map = new HashMap<>();
int pairs = 0 ;
for ( int i = 0 ; i < N; i++)
{
int val = A[i] - reverse(A[i]);
pairs += map.getOrDefault(val, 0 );
map.put(val, map.getOrDefault(val, 0 ) + 1 );
}
System.out.println(pairs);
}
public static void main(String[] args)
{
int arr[] = { 2 , 15 , 11 , 7 };
int N = arr.length;
countPairs(arr, N);
}
}
|
Python3
from collections import defaultdict
def reverse(n):
temp = n
rev = 0
while (temp):
r = temp % 10
rev = rev * 10 + r
temp / / = 10
return rev
def countPairs(A, N):
u_map = defaultdict( int )
pairs = 0
for i in range (N):
val = A[i] - reverse(A[i])
pairs + = u_map[val]
u_map[val] + = 1
print (pairs)
if __name__ = = "__main__" :
arr = [ 2 , 15 , 11 , 7 ]
N = len (arr)
countPairs(arr, N)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int reverse( int n)
{
int temp = n, rev = 0, r;
while (temp > 0)
{
r = temp % 10;
rev = rev * 10 + r;
temp /= 10;
}
return rev;
}
static void countPairs( int []A, int N)
{
Dictionary< int ,
int > u_map = new Dictionary< int ,
int >();
int pairs = 0;
for ( int i = 0; i < N; i++)
{
int val = A[i] - reverse(A[i]);
if (u_map.ContainsKey(val))
pairs += u_map[val];
if (u_map.ContainsKey(val))
u_map[val]++;
else
u_map.Add(val, 1);
}
Console.Write(pairs);
}
public static void Main()
{
int []arr = { 2, 15, 11, 7 };
int N = arr.Length;
countPairs(arr, N);
}
}
|
Javascript
<script>
function reverse(n)
{
var temp = n, rev = 0, r;
while (temp) {
r = temp % 10;
rev = rev * 10 + r;
temp = parseInt(temp/10);
}
return rev;
}
function countPairs(A, N)
{
var u_map = new Map();
var pairs = 0;
for ( var i = 0; i < N; i++) {
var val = A[i] - reverse(A[i]);
pairs += u_map.has(val)?u_map.get(val):0;
if (u_map.has(val))
u_map.set(val, u_map.get(val)+1)
else
u_map.set(val, 1)
}
document.write( pairs);
}
var arr = [2, 15, 11, 7];
var N = arr.length;
countPairs(arr, N);
</script>
|
Time Complexity: O(N*log10 M), where M is the largest element in the array.
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...