Skip to content
Related Articles

Related Articles

Improve Article

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

  • Last Updated : 30 Jun, 2021

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 <bits/stdc++.h>
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<vector<int>> getNew(vector<int> arr)
{
 
    // Stores the new array elements
    vector<vector<int>> ans;
 
    for (int i:arr)
        ans.push_back({keyFunc(i), i});
 
    return ans;
}
 
// Function for rearranging the array
vector<int> getArr(vector<vector<int> > 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<vector<int> > 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)

Javascript




<script>
 
// JavaScript program for the above approach
 
// Function to reverse the bits of a number
function keyFunc(n) {
 
    // Stores the reversed number
    let 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
function getNew(arr) {
 
    // Stores the new array elements
    let ans = [];
 
    for (let i of arr)
        ans.push([keyFunc(i), i]);
 
    return ans;
}
 
// Function for rearranging the array
function getArr(arr) {
 
    // Stores the new array
    let ans = [];
 
    for (let i of arr)
        ans.push(i[1]);
    return ans;
}
 
 
// Function to sort the array by reversing
// binary representation
function sortArray(arr) {
 
    // Creating a new array
    let newArr = getNew(arr);
 
    // Sort the array with the key
    newArr.sort();
 
    // Get arr from newArr
    arr = getArr(newArr);
 
    // Print the sorted array
    let n = arr.length;
    document.write("[");
    for (let i = 0; i < n - 1; i++)
        document.write(arr[i] + ", ");
    document.write(arr[n - 1] + "]");
}
 
// Driver Code
 
 
let arr = [43, 52, 61, 41];
sortArray(arr);
 
// This code is contributed by _saurabh_jaiswal
 
</script>
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:

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)
Output: 
[52, 41, 61, 43]

 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :