# Rearrange array to make decimal equivalents of reversed binary representations of array elements sorted

Given an array arr[] consisting of N positive integers, the task is to rearrange the array such that the reversed binary representation of all the array elements is sorted.

If the decimal equivalent of reversed binary representations of two or more array elements is equal, then the original value is taken into consideration while rearranging the array.

Examples:

Input: arr[] = {43, 52, 61, 41}
Output: 52 41 61 43
Explanation:
Below are the reversed binary representation of the array elements:

1. 43 –> (101011)2 –> reversed –> 53.
2. 52 –> (110100)2 –> reversed –> 11.
3. 61 –> (111101)2 –> reversed –> 47.
4. 41 –> (101001)2 –> reversed –> 37.

Therefore, after rearranging the array element as {52, 41, 61, 43}, the reversed binary representation of rearranged array elements is in sorted order.

Input: arr[] = {5, 3, 6, 2, 4}
Output: 2 4 3 6 5

Approach: Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to reverse the bits of a number` `int` `keyFunc(``int` `n)` `{`   `    ``// Stores the reversed number` `    ``int` `rev = 0;`   `    ``while` `(n > 0)` `    ``{`   `        ``// Divide rev by 2` `        ``rev = rev << 1;`   `        ``// If the value of N is odd` `        ``if` `(n & 1 == 1)` `            ``rev = rev ^ 1;`   `        ``// Update the value of N` `        ``n = n >> 1;` `      ``}`   `    ``// Return the final value of rev` `    ``return` `rev;` `}`   `// Function for rearranging the array` `// element according to the given rules` `vector> getNew(vector<``int``> arr)` `{`   `    ``// Stores the new array elements` `    ``vector> ans;`   `    ``for` `(``int` `i:arr)` `        ``ans.push_back({keyFunc(i), i});`   `    ``return` `ans;` `}`   `// Function for rearranging the array` `vector<``int``> getArr(vector > arr){`   `    ``// Stores the new array` `    ``vector<``int``> ans;`   `    ``for` `(``auto` `i:arr)` `        ``ans.push_back(i[1]);` `    ``return` `ans;` `}`     `// Function to sort the array by reversing` `// binary representation` `void` `sortArray(vector<``int``> arr)` `{`   `  ``// Creating a new array` `  ``vector > newArr = getNew(arr);`   `  ``// Sort the array with the key` `  ``sort(newArr.begin(),newArr.end());`   `  ``// Get arr from newArr` `  ``arr = getArr(newArr);`   `  ``// Print the sorted array` `  ``int` `n = arr.size();` `  ``cout<<``"["``;` `  ``for``(``int` `i = 0; i < n - 1; i++) ` `    ``cout << arr[i] << ``", "``;` `  ``cout << arr[n - 1] << ``"]"``;` `}`   `// Driver Code` `int` `main()` `{` `  `  `  ``vector<``int``> arr = {43, 52, 61, 41};` `  ``sortArray(arr);`   `  ``return` `0;` `}`   `// This code is contributed by mohit kumar 29.`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG{`   `// Function to reverse the bits of a number` `static` `int` `keyFunc(``int` `n)` `{` `    `  `    ``// Stores the reversed number` `    ``int` `rev = ``0``;`   `    ``while` `(n > ``0``)` `    ``{` `        `  `        ``// Divide rev by 2` `        ``rev = rev << ``1``;`   `        ``// If the value of N is odd` `        ``if` `((n & ``1``) == ``1``)` `            ``rev = rev ^ ``1``;`   `        ``// Update the value of N` `        ``n = n >> ``1``;` `    ``}`   `    ``// Return the final value of rev` `    ``return` `rev;` `}`   `// Function for rearranging the array` `// element according to the given rules` `static` `int``[][] getNew(``int` `arr[])` `{` `    `  `    ``// Stores the new array elements` `    ``int` `ans[][] = ``new` `int``[arr.length][``2``];`   `    ``for``(``int` `i = ``0``; i < arr.length; i++)` `        ``ans[i] = ``new` `int``[]{ keyFunc(arr[i]), arr[i] };`   `    ``return` `ans;` `}`   `// Function for rearranging the array` `static` `int``[] getArr(``int``[][] arr)` `{`   `    ``// Stores the new array` `    ``int` `ans[] = ``new` `int``[arr.length];` `    ``int` `idx = ``0``;` `    ``for``(``int` `i[] : arr)` `        ``ans[idx++] = i[``1``];` `        `  `    ``return` `ans;` `}`   `// Function to sort the array by reversing` `// binary representation` `static` `void` `sortArray(``int` `arr[])` `{`   `    ``// Creating a new array` `    ``int``[][] newArr = getNew(arr);`   `    ``// Sort the array with the key` `    ``Arrays.sort(newArr, (a, b) -> {` `        ``if` `(Integer.compare(a[``0``], b[``0``]) == ``0``)` `            ``return` `Integer.compare(a[``1``], b[``1``]);` `            `  `        ``return` `Integer.compare(a[``0``], b[``0``]);` `    ``});`   `    ``// Get arr from newArr` `    ``arr = getArr(newArr);`   `    ``// Print the sorted array` `    ``int` `n = arr.length;` `    ``System.out.print(``"["``);` `    ``for``(``int` `i = ``0``; i < n - ``1``; i++)` `        ``System.out.print(arr[i] + ``", "``);` `        `  `    ``System.out.print(arr[n - ``1``] + ``"]"``);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``43``, ``52``, ``61``, ``41` `};` `    ``sortArray(arr);` `}` `}`   `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach`   `# Function to reverse the bits of a number` `def` `keyFunc(n):`   `    ``# Stores the reversed number` `    ``rev ``=` `0`   `    ``while` `(n > ``0``):`   `        ``# Divide rev by 2` `        ``rev ``=` `rev << ``1`   `        ``# If the value of N is odd` `        ``if` `(n & ``1` `=``=` `1``):` `            ``rev ``=` `rev ^ ``1`   `        ``# Update the value of N` `        ``n ``=` `n >> ``1`   `    ``# Return the final value of rev` `    ``return` `rev`   `# Function for rearranging the array` `# element according to the given rules` `def` `getNew(arr):`   `    ``# Stores the new array elements` `    ``ans ``=` `[]`   `    ``for` `i ``in` `arr:` `        ``ans.append([keyFunc(i), i])` `    ``return` `ans`   `# Function for rearranging the array` `def` `getArr(arr):`   `    ``# Stores the new array` `    ``ans ``=` `[]`   `    ``for` `i ``in` `arr:` `        ``ans.append(i[``1``])` `    ``return` `ans`   `# Function to sort the array by reversing` `# the binary representation` `def` `sortArray(arr):`   `    ``# Creating a new array` `    ``newArr ``=` `getNew(arr)`   `    ``# Sort the array with the key` `    ``newArr.sort()`   `    ``# Get arr from newArr` `    ``arr ``=` `getArr(newArr)`   `    ``# Print the sorted array` `    ``print``(arr)`     `# Driver Code`   `arr ``=` `[``43``, ``52``, ``61``, ``41``]` `sortArray(arr)`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG {`   `  ``// Function to reverse the bits of a number` `  ``static` `int` `keyFunc(``int` `n)` `  ``{`   `    ``// Stores the reversed number` `    ``int` `rev = 0;`   `    ``while` `(n > 0) {`   `      ``// Divide rev by 2` `      ``rev = rev << 1;`   `      ``// If the value of N is odd` `      ``if` `((n & 1) == 1)` `        ``rev = rev ^ 1;`   `      ``// Update the value of N` `      ``n = n >> 1;` `    ``}`   `    ``// Return the final value of rev` `    ``return` `rev;` `  ``}`   `  ``// Function for rearranging the array` `  ``// element according to the given rules` `  ``static` `int``[][] getNew(``int``[] arr)` `  ``{`   `    ``// Stores the new array elements` `    ``int``[][] ans = ``new` `int``[arr.Length][];`   `    ``for` `(``int` `i = 0; i < arr.Length; i++)` `      ``ans[i] = ``new` `int``[] { keyFunc(arr[i]), arr[i] };`   `    ``return` `ans;` `  ``}`   `  ``// Function for rearranging the array` `  ``static` `int``[] getArr(``int``[][] arr)` `  ``{`   `    ``// Stores the new array` `    ``int``[] ans = ``new` `int``[arr.Length];` `    ``int` `idx = 0;` `    ``foreach``(``var` `i ``in` `arr) ans[idx++] = i[1];`   `    ``return` `ans;` `  ``}`   `  ``// Function to sort the array by reversing` `  ``// binary representation` `  ``static` `void` `sortArray(``int``[] arr)` `  ``{`   `    ``// Creating a new array` `    ``int``[][] newArr = getNew(arr);`   `    ``// Sort the array with the key` `    ``Array.Sort(` `      ``newArr, ``new` `Comparison<``int``[]>((a, b) => {` `        ``return` `(a[0] == b[0]) ? (a[1] - b[1])` `          ``: (a[0] - b[0]);` `      ``}));`   `    ``// Get arr from newArr` `    ``arr = getArr(newArr);`   `    ``// Print the sorted array` `    ``int` `n = arr.Length;` `    ``Console.Write(``"["``);` `    ``for` `(``int` `i = 0; i < n - 1; i++)` `      ``Console.Write(arr[i] + ``", "``);`   `    ``Console.Write(arr[n - 1] + ``"]"``);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int``[] arr = { 43, 52, 61, 41 };` `    ``sortArray(arr);` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 ``

Output:

`[52, 41, 61, 43]`

Time Complexity: O(N * log N)
Auxiliary Space: O(N)

Space-Optimized Approach: Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to reverse the bits of number` `int` `keyFunc(``int` `n)` `{`   `    ``// Stores the reversed number` `    ``int` `rev = 0;`   `    ``while` `(n > 0) {`   `        ``// Divide rev by 2` `        ``rev = rev << 1;`   `        ``// If the value of N is odd` `        ``if` `(n & 1 == 1)` `            ``rev = rev ^ 1;`   `        ``// Update the value of N` `        ``n = n >> 1;` `    ``}`   `    ``// Return the final value of rev` `    ``return` `rev;` `}`   `//defining the comparison function` `bool` `compare(``int` `a, ``int` `b)` `{` `    ``return` `keyFunc(a) < keyFunc(b);` `}` `// Function to sort the array by reversing` `// binary representation` `void` `sortArray(``int` `arr[], ``int` `n)` `{` `    ``// Sort the array with the key` `    ``sort(arr, arr + n, compare);`   `    ``// Print the sorted array` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cout << arr[i] << ``" "``;` `}`   `int` `main()` `{` `    ``// Driver Code` `    ``int` `arr[] = { 43, 52, 61, 41 };` `    ``int` `n = 4;` `    ``sortArray(arr, n);`   `    ``return` `0;` `}`   `// this code is contributed by phasing17`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``// Function to reverse the bits of number` `  ``public` `static` `int` `keyFunc(String num)` `  ``{`   `    ``int` `n = Integer.parseInt(num);`   `    ``// Stores the reversed number` `    ``int` `rev = ``0``;`   `    ``while` `(n > ``0``) {`   `      ``// Divide rev by 2` `      ``rev = rev << ``1``;`   `      ``// If the value of N is odd` `      ``if` `((n & ``1``) == ``1``)` `        ``rev = rev ^ ``1``;`   `      ``// Update the value of N` `      ``n = n >> ``1``;` `    ``}`   `    ``// Return the final value of rev` `    ``return` `rev;` `  ``}`   `  ``// Function to sort the array by reversing` `  ``// binary representation` `  ``public` `static` `void` `sortArray(List arrInt,` `                               ``int` `n)` `  ``{` `    ``// Sort the array with the key` `    ``List arr = ``new` `ArrayList();` `    ``for` `(``int` `i = ``0``; i < arrInt.size(); i++) {` `      ``arr.add(Integer.toString(arrInt.get(i)));` `    ``}`   `    ``Collections.sort(arr, ``new` `Comparator() {` `      ``@Override` `      ``// defining the comparison function` `      ``public` `int` `compare(``final` `String a, String b)` `      ``{` `        ``if` `(keyFunc(a) < keyFunc(b))` `          ``return` `-``1``;` `        ``return` `1``;` `      ``}` `    ``});`   `    ``// Print the sorted array` `    ``for` `(``int` `i = ``0``; i < n; i++)` `      ``System.out.print(arr.get(i) + ``" "``);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``List arr = ``new` `ArrayList();` `    ``arr.add(``43``);` `    ``arr.add(``52``);` `    ``arr.add(``61``);` `    ``arr.add(``41``);` `    ``int` `n = ``4``;` `    ``sortArray(arr, n);` `  ``}` `}`   `// This code is contributed by akashish__`

## Python3

 `# Python3 program for the above approach`   `# Function to reverse the bits of number` `def` `keyFunc(n):` `  `  `    ``# Stores the reversed number` `    ``rev ``=` `0` `    `  `    ``while` `(n > ``0``):` `      `  `        ``# Divide rev by 2` `        ``rev ``=` `rev << ``1` `        `  `        ``# If the value of N is odd` `        ``if` `(n & ``1` `=``=` `1``):` `            ``rev ``=` `rev ^ ``1` `            `  `        ``# Update the value of N` `        ``n ``=` `n >> ``1` `        `  `    ``# Return the final value of rev` `    ``return` `rev`   `# Function to sort the array by reversing` `# binary representation` `def` `sortArray(arr):`   `    ``# Sort the array with the key` `    ``arr ``=` `sorted``(arr, key ``=` `keyFunc)`   `    ``# Print the sorted array` `    ``print``(arr)`   `# Driver Code`   `arr ``=` `[``43``, ``52``, ``61``, ``41``]` `sortArray(arr)`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG ` `{`   `  ``// Function to reverse the bits of number` `  ``public` `static` `int` `keyFunc(``int` `n)` `  ``{`   `    ``// Stores the reversed number` `    ``int` `rev = 0;`   `    ``while` `(n > 0) {`   `      ``// Divide rev by 2` `      ``rev = rev << 1;`   `      ``// If the value of N is odd` `      ``if` `((n & 1) == 1)` `        ``rev = rev ^ 1;`   `      ``// Update the value of N` `      ``n = n >> 1;` `    ``}`   `    ``// Return the final value of rev` `    ``return` `rev;` `  ``}` `  ``// defining the comparison function` `  ``public` `static` `int` `compare(``int` `a, ``int` `b)` `  ``{` `    ``return` `keyFunc(a) - keyFunc(b);` `  ``}` `  ``// Function to sort the array by reversing` `  ``// binary representation` `  ``public` `static` `void` `sortArray(``int``[] arr, ``int` `n)` `  ``{` `    ``// Sort the array with the key` `    ``Array.Sort(arr, compare);`   `    ``// Print the sorted array` `    ``for` `(``int` `i = 0; i < n; i++)` `      ``Console.Write(arr[i] + ``" "``);` `  ``}` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    `  `    ``// Driver Code` `    ``int``[] arr = { 43, 52, 61, 41 };` `    ``int` `n = 4;` `    ``sortArray(arr, n);` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 `// JavaScript program for the above approach`   `// Function to reverse the bits of number` `function` `keyFunc(n)` `{` `  `  `    ``// Stores the reversed number` `    ``var` `rev = 0;` `    `  `    ``while` `(n > 0)` `    ``{` `      `  `        ``// Divide rev by 2` `        ``rev = rev << 1;` `        `  `        ``// If the value of N is odd` `        ``if` `(n & 1 == 1)` `            ``rev = rev ^ 1;` `            `  `        ``// Update the value of N` `        ``n = n >> 1;` `    ``}` `        `  `    ``// Return the final value of rev` `    ``return` `rev;` `}`   `// Function to sort the array by reversing` `// binary representation` `function` `sortArray(arr)` `{`   `    ``// Sort the array with the key` `    ``arr.sort((a, b) => keyFunc(a) > keyFunc(b));`   `    ``// Print the sorted array` `    ``console.log(arr);` `}`   `// Driver Code` `var` `arr = [43, 52, 61, 41];` `sortArray(arr);`   `//this code is contributed by phasing17`

Output:

`[52, 41, 61, 43]`

Time Complexity: O(N * log N)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next