Number of recycled pairs in an array
Given an array of integers arr[], find the number of recycled pairs in the array. A recycled pair of two numbers {a, b} has the following properties :
- A should be smaller than B.
- Number of digits should be same.
- By rotating A any number of times in one direction, we should get B.
Examples:
Input : arr[] = {32, 42, 13, 23, 9, 5, 31}
Output : 2
Explanation : Since there are two pairs {13, 31} and {23, 32}.
By rotating 13 for first time, output is 31 and by rotating 23 once output is 32.
Both of these pairs satisfy our criteria.
Input : arr[] = {1212, 2121}
Output : 1
Explanation : Since there are two pairs {1212, 2121}. By rotating 1212
for first time, output is 2121. This pair satisfies our criteria.
Note that if rotation id done further, rotating 1212 again output is 1212
which is given number and 2121 which has been already counted.
So discard both of these results.
Below is the step by step algorithm to solve the above problem:
- Sort the array.
- Create a new array ‘temp’ of size n where n is the length of original array.
- Remove duplicates from the array by copying unique values to new array ‘temp’.
- Find the number of elements copied from original array and let this number be the size of array.
- Create a HashSet to store only unique rotations of the current number.
- Initialize a counter with value = 0.
- Traverse ‘temp’ and for every number do the following steps –
- Find the number of digits. Let it be ‘d1’.
- Rotate the number for d-1 times and store every number formed by each rotation in a HashSet.
- If formed number is found in HashSet, ignore it.
- For every rotated number, do a binary search for its presence in rest of the array.
- If it is present, increment counter.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int recycledPairs( int a[], int n)
{
int count = 0;
sort(a, a + n);
int temp[n];
memset (temp, -1, n);
int j = 0;
for ( int i = 0; i < n - 1; i++)
if (a[i] != a[i + 1])
temp[j++] = a[i];
temp[j++] = a[n - 1];
int size = n;
for ( int i = n - 1; i >= 0; i--)
if (temp[i] != -1) {
size = i;
break ;
}
set< int > hs;
for ( int i = 0; i < size + 1; i++) {
hs.clear();
int x = temp[i];
int d1 = ( int ) log10 (temp[i]) + 1;
int f = ( int ) pow (10, d1 - 1);
for (j = 1; j <= d1 - 1; j++) {
int r = x % 10;
int q = x / 10;
x = r * f + q;
int d2 = ( int ) log10 (x) + 1;
set< int >::iterator it = hs.find(x);
if (it == hs.end()) {
hs.insert(x);
if ((d1 == d2)) {
int position
= lower_bound(temp + i,
temp + size + 1, x)
- (temp + i + 1);
if (position >= 0) {
count++;
}
}
}
}
}
return count;
}
int main()
{
int a[] = { 32, 42, 13, 23, 9, 5, 31 };
int n = sizeof (a) / sizeof (a[0]);
int result = recycledPairs(a, n);
cout << (result);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int recycledPairs( int [] a)
{
int count = 0 ;
Arrays.sort(a);
int n = a.length;
int [] temp = new int [n];
Arrays.fill(temp, - 1 );
int j = 0 ;
for ( int i = 0 ; i < n - 1 ; i++)
if (a[i] != a[i + 1 ])
temp[j++] = a[i];
temp[j++] = a[n - 1 ];
int size = n;
for ( int i = n - 1 ; i >= 0 ; i--)
if (temp[i] != - 1 ) {
size = i;
break ;
}
HashSet<Integer> hs = new HashSet<Integer>();
for ( int i = 0 ; i < size + 1 ; i++) {
hs.clear();
int x = temp[i];
int d1 = ( int )Math.log10(temp[i]) + 1 ;
int f = ( int )Math.pow( 10 , d1 - 1 );
for (j = 1 ; j <= d1 - 1 ; j++) {
int r = x % 10 ;
int q = x / 10 ;
x = r * f + q;
int d2 = ( int )Math.log10(x) + 1 ;
if (!hs.contains(x)) {
hs.add(x);
if ((d1 == d2)) {
int position = Arrays.binarySearch(
temp, i + 1 , size + 1 , x);
if (position >= 0 ) {
count++;
}
}
}
}
}
return count;
}
public static void main(String[] args)
{
int a[] = { 32 , 42 , 13 , 23 , 9 , 5 , 31 };
int result = recycledPairs(a);
System.out.println(result);
}
}
|
C#
using System;
using System.Collections.Generic;
class GFG {
static int recycledPairs( int [] a)
{
int count = 0;
Array.Sort(a);
int n = a.Length;
int [] temp = new int [n];
for ( int i = 0; i < n; i++)
temp[i] = -1;
int j = 0;
for ( int i = 0; i < n - 1; i++)
if (a[i] != a[i + 1])
temp[j++] = a[i];
temp[j++] = a[n - 1];
int size = n;
for ( int i = n - 1; i >= 0; i--)
if (temp[i] != -1) {
size = i;
break ;
}
HashSet< int > hs = new HashSet< int >();
for ( int i = 0; i < size + 1; i++) {
hs.Clear();
int x = temp[i];
int d1 = ( int )Math.Log10(temp[i]) + 1;
int f = ( int )Math.Pow(10, d1 - 1);
for (j = 1; j <= d1 - 1; j++) {
int r = x % 10;
int q = x / 10;
x = r * f + q;
int d2 = ( int )Math.Log10(x) + 1;
if (!hs.Contains(x)) {
hs.Add(x);
if ((d1 == d2)) {
int position = Array.BinarySearch(
temp, i + 1, size - i, x);
if (position >= 0) {
count++;
}
}
}
}
}
return count;
}
public static void Main(String[] args)
{
int [] a = { 32, 42, 13, 23, 9, 5, 31 };
int result = recycledPairs(a);
Console.WriteLine(result);
}
}
|
Javascript
function recycledPairs(a)
{
var count = 1;
a.sort( function (a, b) { return a - b;});
var n = a.length;
var temp = Array(n).fill(0);
temp.fill(-1);
var j = 0;
var i =0;
for (i; i < n - 1; i++)
{
if (a[i] != a[i + 1])
{
temp[j++] = a[i];
}
}
temp[j++] = a[n - 1];
var size = n;
for (i; i >= 0; i--)
{
if (temp[i] != -1)
{
size = i;
break ;
}
}
function binarySearch(arr, start, end, x) {
while (start<=end){
let mid=Math.floor((start + end)/2);
if (arr[mid]===x) return mid;
else if (arr[mid] < x)
start = mid + 1;
else
end = mid - 1;
}
return start;
}
var hs = new Set();
for (i; i < size + 1; i++)
{
new Array();
var x = temp[i];
var d1 = parseInt(Math.log10(temp[i])) + 1;
var f = parseInt(Math.pow(10,d1 - 1));
for (j = 1; j <= d1 - 1; j++)
{
var r = x % 10;
var q = parseInt(x / 10);
x = r * f + q;
var d2 = parseInt(Math.log10(x)) + 1;
if (!hs.has(x))
{
hs.add(x);
if ((d1 == d2))
{
var position = binarySearch(temp,i + 1,size + 1,x);
if (position >= 0)
{
count++;
}
}
}
}
}
return count;
}
var a = [32, 42, 13, 23, 9, 5, 31];
var result = recycledPairs(a);
console.log(result);
|
Python3
import math
def recycled_pairs(a):
count = 0
a.sort()
temp = []
for i in range ( len (a) - 1 ):
if a[i] ! = a[i + 1 ]:
temp.append(a[i])
temp.append(a[ - 1 ])
size = len (temp)
hs = set ()
for i in range (size):
hs.clear()
x = temp[i]
d1 = int (math.log10(temp[i])) + 1
f = pow ( 10 , d1 - 1 )
for j in range ( 1 , d1):
r = x % 10
q = x / / 10
x = r * f + q
d2 = int (math.log10(x)) + 1
if x not in hs:
hs.add(x)
if d1 = = d2:
position = i + 1
while position < size and temp[position] < x:
position + = 1
if position < size and temp[position] = = x:
count + = 1
return count
if __name__ = = '__main__' :
a = [ 32 , 42 , 13 , 23 , 9 , 5 , 31 ]
result = recycled_pairs(a)
print (result)
|
Time Complexity : O(n*log(n)).
Note: For any given integer, the maximum number of rotations to form new numbers are fixed that is (no_of_digits-1). Hence, this operation is constant time that is O(1).
Asked in Google.
Last Updated :
03 Apr, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...