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

1. A should be smaller than B.
2. Number of digits should be same.
3. 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.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Below is the step by step algorithm to solve the above problem:

1. Sort the array.
2. Create a new array ‘temp’ of size n where n is the length of original array.
3. Remove duplicates from the array by copying unique values to new array ‘temp’.
4. Find the number of elements copied from original array and let this number be the size of array.
5. Create a HashSet to store only unique rotations of the current number.
6. Initialize a counter with value = 0.
7. 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.

## Java

 `// Java code for Recycled Pairs in array. ` `import` `java.util.*; ` ` `  `class` `GFG { ` `     `  `    ``// Function to find recycled pairs ` `    ``static` `int` `recycledPairs(``int``[] a) ` `    ``{ ` `        ``int` `count = ``0``; ` `         `  `        ``// Sorting array ` `        ``Arrays.sort(a); ` `        ``int` `n = a.length; ` `         `  `        ``// Removing duplicates by creating new array temp. ` `        ``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; ` `         `  `        ``// Finding number of locations in temp which are occupied from copying. ` `        ``for` `(``int` `i = n - ``1``; i >= ``0``; i--) ` `            ``if` `(temp[i] != -``1``) { ` `                ``size = i; ` `                ``break``; ` `            ``} ` `         `  `        ``// Hashset to store new Rotations ` `        ``HashSet hs = ``new` `HashSet(); ` `         `  `        ``for` `(``int` `i = ``0``; i < size + ``1``; i++) { ` `             `  `            ``// Clearing hashset for each number in temp. ` `            ``hs.clear(); ` `            ``int` `x = temp[i]; ` `             `  `            ``// Finding number of digits of taken number ` `            ``int` `d1 = (``int``)Math.log10(temp[i]) + ``1``; ` ` `  `            ``int` `f = (``int``)Math.pow(``10``, d1 - ``1``); ` `            ``for` `(j = ``1``; j <= d1 - ``1``; j++) { ` `                 `  `                ``// Remainder ` `                ``int` `r = x % ``10``; ` `                 `  `                ``// Quotient ` `                ``int` `q = x / ``10``; ` `                 `  `                ``// Forming new number by rotating. ` `                ``x = r * f + q; ` `                 `  `                ``// Number of digits of newly formed rotated number ` `                ``// to avoid duplicate numbers. ` `                ``int` `d2 = (``int``)Math.log10(x) + ``1``; ` `                 `  `                ``// Inserting formed rotated number to set s ` `                ``if` `(!hs.contains(x)) { ` `                    ``hs.add(x); ` `                     `  `                    ``// Checking for number of digits of new number. ` `                    ``if` `((d1 == d2)) ` `                    ``{ ` `                        ``// Searching for the formed element in rest of array. ` `                        ``int` `position = Arrays.binarySearch(temp, i + ``1``, size + ``1``, x); ` `                         `  `                        ``// If position found ` `                        ``if``(position >= ``0``) ` `                        ``{ ` `                            ``// Increment counter. ` `                            ``count++; ` `                        ``} ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `         `  `        ``// Return counter ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Driver function ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `a[] = { ``32``, ``42``, ``13``, ``23``, ``9``, ``5``, ``31` `}; ` `        ``int` `result = recycledPairs(a); ` `        ``System.out.println(result); ` `    ``} ` `} `

## C#

 `// C# code for Recycled Pairs in array. ` `using` `System; ` `using` `System.Collections.Generic;  ` `     `  `class` `GFG  ` `{ ` `     `  `    ``// Function to find recycled pairs ` `    ``static` `int` `recycledPairs(``int``[] a) ` `    ``{ ` `        ``int` `count = 0; ` `         `  `        ``// Sorting array ` `        ``Array.Sort(a); ` `        ``int` `n = a.Length; ` `         `  `        ``// Removing duplicates by  ` `        ``// creating new array temp. ` `        ``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; ` `         `  `        ``// Finding number of locations in temp  ` `        ``// which are occupied from copying. ` `        ``for` `(``int` `i = n - 1; i >= 0; i--) ` `            ``if` `(temp[i] != -1)  ` `            ``{ ` `                ``size = i; ` `                ``break``; ` `            ``} ` `         `  `        ``// Hashset to store new Rotations ` `        ``HashSet<``int``> hs = ``new` `HashSet<``int``>(); ` `         `  `        ``for` `(``int` `i = 0; i < size + 1; i++)  ` `        ``{ ` `             `  `            ``// Clearing hashset for each number in temp. ` `            ``hs.Clear(); ` `            ``int` `x = temp[i]; ` `             `  `            ``// Finding number of digits of taken number ` `            ``int` `d1 = (``int``)Math.Log10(temp[i]) + 1; ` ` `  `            ``int` `f = (``int``)Math.Pow(10, d1 - 1); ` `            ``for` `(j = 1; j <= d1 - 1; j++) ` `            ``{ ` `                 `  `                ``// Remainder ` `                ``int` `r = x % 10; ` `                 `  `                ``// Quotient ` `                ``int` `q = x / 10; ` `                 `  `                ``// Forming new number by rotating. ` `                ``x = r * f + q; ` `                 `  `                ``// Number of digits of newly formed rotated number ` `                ``// to avoid duplicate numbers. ` `                ``int` `d2 = (``int``)Math.Log10(x) + 1; ` `                 `  `                ``// Inserting formed rotated number to set s ` `                ``if` `(!hs.Contains(x))  ` `                ``{ ` `                    ``hs.Add(x); ` `                     `  `                    ``// Checking for number of digits of new number. ` `                    ``if` `((d1 == d2)) ` `                    ``{ ` `                        ``// Searching for the formed element in rest of array. ` `                        ``int` `position = Array.BinarySearch(temp, i + 1,   ` `                                                          ``size - i, x); ` `                         `  `                        ``// If position found ` `                        ``if``(position >= 0) ` `                        ``{ ` `                            ``// Increment counter. ` `                            ``count++; ` `                        ``} ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `         `  `        ``// Return counter ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `[]a = { 32, 42, 13, 23, 9, 5, 31 }; ` `        ``int` `result = recycledPairs(a); ` `        ``Console.WriteLine(result); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```2
```

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

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : 29AjayKumar

Article Tags :
Practice Tags :

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.