# Rank the array according to rightmost set bit and least set bits

Given an array arr[] of N integers, the task is to replace each element of Array with their rank according to Rightmost-Set Bit (RSB) in descending manner, If the RSB is the same for two numbers then choose the one which has the least number of set bits if the set bits of two numbers are same then choose the number who comes first in the array.

Examples:

Input: arr[] = {4, 5, 6, 7, 8}
Output: 2 4 3 5 1
Explanation: Then rank of elements is given by sorted descending of RSB.
Rank(8) = 1 as Rsb of 8(1000) is 8 and setbit count is 1.
Rank(4) = 2 as RSB of 4(0100) is 4 and setbit count is 1.
Rank(6) = 3 as RSB of 6(0110) is 2 and setbit count is 2.
Rank(5) = 4 as RSB of 5(0101) is 1 and setbit count is 2.
Rank(7) = 5 as Rsb of 7(0111) is 1 and setbit count is 3.
So, the answer will be { 2, 4, 3, 5, 1 }.

Input: arr[] = {5, 10, 15, 32}
Output: 3 2 4 1

Naive Approach: The naive approach is to find the rank of each element by comparing the RSB of that element with other elements and incrementing the rank by 1 whenever a greater value of RSB is encountered.

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

Efficient Approach: To optimize the above naive approach find ranks of elements and then assign the rank to the elements using a comparator. Using a comparator, the elements can be sorted based on data members. For instance, here the elements will be sorted based on the RSB and number of set bits.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Class for pair``class` `Pair {``    ``public``:``    ``int` `index;``    ``int` `rsb;``    ``int` `setbit;` `    ``// Constructor``    ``Pair(``int` `index, ``int` `rsb, ``int` `setbit)``     ``:index(index),rsb(rsb),setbit(setbit)``    ``{``    ``}``};` `// Comparator for sorting based on RSB``bool` `operator<(``const` `Pair& a, ``const` `Pair& b)``    ``{``        ``if` `(a.rsb > b.rsb)``            ``return` `false``;``        ``else` `if` `(a.rsb < b.rsb)``            ``return` `true``;``        ``else` `if` `(a.setbit < b.setbit)``            ``return` `false``;``        ``else` `if` `(b.setbit < a.setbit)``            ``return` `true``;``        ``else` `if` `(a.index < b.index)``            ``return` `false``;``        ``else``            ``return` `true``;``    ``}` `    ``// Function to rearrange the elements``    ``// according to Rightmpost set bits``    ``void` `rearrange(``int` `ar[], ``int` `n)``    ``{``        ``// Creating priority queue from``        ``// sorting according to``        ``// rightmost set bit.``        ``priority_queue pq;` `        ``// For creating object of each element``        ``// so that it can be sorted``        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// To calculate the rightmost``            ``// set bit in O(1)``            ``int` `k = (ar[i] & -ar[i]);` `            ``// Creating a pair object``            ``// with rsb and index``            ``int` `setbit``                ``= __builtin_popcount(ar[i]);` `            ``// Inserting the element``            ``// in priorityqueue``            ``pq.push(Pair(i, k, setbit));``        ``}` `        ``int` `rank = 1;``        ``// Popping the element of queue``        ``// to get respective rank.``        ``while` `(!pq.empty()) {``            ``Pair p = pq.top();``            ``pq.pop();``            ``ar[p.index] = rank++;``        ``}``    ``}` `    ``// Driver code``        ``int` `main()``    ``{``        ``int` `arr[] = { 4, 5, 6, 7, 8 };``        ``// To store the length of array``        ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);;` `        ``// To call the rearrange function``        ``rearrange(arr, N);``        ``for` `(``int` `i = 0; i < N; i++)``            ``cout<

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `// Class for pair``class` `Pair {``    ``int` `index;``    ``int` `rsb;``    ``int` `setbit;` `    ``// Constructor``    ``Pair(``int` `index, ``int` `rsb, ``int` `setbit)``    ``{``        ``this``.index = index;``        ``this``.rsb = rsb;``        ``this``.setbit = setbit;``    ``}``}` `// Comparator for sorting based on RSB``class` `pair_sort ``implements` `Comparator {``    ``// Used for sorting in descending order``    ``// of rightmost set bit``    ``public` `int` `compare(Pair a, Pair b)``    ``{``        ``if` `(a.rsb > b.rsb)``            ``return` `-``1``;``        ``else` `if` `(a.rsb < b.rsb)``            ``return` `1``;``        ``else` `if` `(a.setbit < b.setbit)``            ``return` `-``1``;``        ``else` `if` `(b.setbit < a.setbit)``            ``return` `1``;``        ``else` `if` `(a.index < b.index)``            ``return` `-``1``;``        ``else``            ``return` `1``;``    ``}``}` `// Class to implement the solution logic``class` `GFG {` `    ``// Function to rearrange the elements``    ``// according to Rightmpost set bits``    ``void` `rearrange(``int` `ar[], ``int` `n)``    ``{``        ``// Creating priority queue from``        ``// sorting according to``        ``// rightmost set bit.``        ``PriorityQueue pq``            ``= ``new` `PriorityQueue(``new` `pair_sort());` `        ``// For creating object of each element``        ``// so that it can be sorted``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// To calculate the rightmost``            ``// set bit in O(1)``            ``int` `k = (ar[i] & -ar[i]);` `            ``// Creating a pair object``            ``// with rsb and index``            ``int` `setbit``                ``= Integer.bitCount(ar[i]);``            ``Pair p = ``new` `Pair(i, k, setbit);` `            ``// Inserting the element``            ``// in priorityqueue``            ``pq.add(p);``        ``}` `        ``int` `rank = ``1``;``        ``// Popping the element of queue``        ``// to get respective rank.``        ``while` `(!pq.isEmpty()) {``            ``Pair p = pq.poll();` `            ``ar[p.index] = rank++;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``        ``throws` `java.lang.Exception``    ``{``        ``int` `arr[] = { ``4``, ``5``, ``6``, ``7``, ``8` `};` `        ``// Creating an object of class``        ``GFG ob = ``new` `GFG();` `        ``// To store the length of array``        ``int` `N = arr.length;` `        ``// To call the rearrange function``        ``ob.rearrange(arr, N);``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}``}`

## Python3

 `# Python program for the above approach``import` `heapq` `# pair class``class` `Pair:``    ``def` `__init__(``self``, index, rsb, setbit):``        ``self``.index ``=` `index``        ``self``.rsb ``=` `rsb``        ``self``.setbit ``=` `setbit` `class` `Soln:``     ``# Function to rearrange the elements``    ``# according to Rightmpost set bits``    ``def` `rearrng(``self``, arr: ``list``) ``-``> ``list``:``        ``n ``=` `len``(arr)``        ``pq ``=` `[]` `        ``# Creating a pair object``        ``# with rsb and index``        ``for` `i ``in` `range``(n):``            ``# To calculate the rightmost``            ``# set bit in O(1)``            ``k ``=` `(arr[i] & ``-``arr[i])``            ` `             ``# Creating a pair object``            ``# with rsb and index``            ``setbit ``=` `bin``(arr[i]).count(``'1'``)``            ``p ``=` `Pair(i, k, setbit)``              ``#Inserting the element``            ``#in priorityqueue``            ``heapq.heappush(pq, (``-``p.rsb, p.setbit, p.index))` `        ``rank ``=` `1``         ``# Popping the element of queue``        ``# to get respective rank.``        ``while` `pq:``            ``p ``=` `heapq.heappop(pq)``            ``arr[p[``2``]] ``=` `rank``            ``rank ``+``=` `1` `        ``return` `arr` `# Driver code``arr ``=` `[``4``, ``5``, ``6``, ``7``, ``8``]` `# Creating an object of class``ob ``=` `Soln()` `# To call the rearrange function``res ``=` `ob.rearrng(arr)``print``(res)`

## Javascript

 `// Define Priority Queuefor JavaScript as there is no pre-defined in JavaScript``class PriorityQueue {``  ``constructor() {``    ``this``.heap = [];``    ``this``.comparator = (a, b) => {``      ``if` `(a.rsb > b.rsb) {``        ``return` `1;``      ``} ``else` `if` `(a.rsb < b.rsb) {``        ``return` `-1;``      ``} ``else` `if` `(a.setbit > b.setbit) {``        ``return` `1;``      ``} ``else` `if` `(a.setbit < b.setbit) {``        ``return` `-1;``      ``} ``else` `if` `(a.index > b.index) {``        ``return` `1;``      ``} ``else` `{``        ``return` `-1;``      ``}``    ``};``  ``}``// To insert into queue``  ``enqueue(value) {``    ``this``.heap.push(value);``    ``let index = ``this``.heap.length - 1;``    ``while` `(index > 0) {``      ``let parentIndex = Math.floor((index - 1) / 2);``      ``if` `(``this``.comparator(``this``.heap[parentIndex], ``this``.heap[index]) <= 0) {``        ``break``;``      ``}``      ``[``this``.heap[parentIndex], ``this``.heap[index]] = [``        ``this``.heap[index],``        ``this``.heap[parentIndex],``      ``];``      ``index = parentIndex;``    ``}``  ``}``// To pop from queue``  ``dequeue() {``    ``if` `(``this``.isEmpty()) {``      ``return` `undefined;``    ``}``    ``if` `(``this``.size() === 1) {``      ``return` `this``.heap.shift();``    ``}``    ``const minValue = ``this``.heap[0];``    ``this``.heap[0] = ``this``.heap.pop();``    ``let index = 0;``    ``let leftChildIndex = 2 * index + 1;``    ``let rightChildIndex = 2 * index + 2;``    ``while` `(``      ``(leftChildIndex < ``this``.size() &&``        ``this``.comparator(``this``.heap[leftChildIndex], ``this``.heap[index]) < 0) ||``      ``(rightChildIndex < ``this``.size() &&``        ``this``.comparator(``this``.heap[rightChildIndex], ``this``.heap[index]) < 0)``    ``) {``      ``let smallerIndex =``        ``rightChildIndex < ``this``.size() &&``        ``this``.comparator(``this``.heap[rightChildIndex], ``this``.heap[leftChildIndex]) < 0``          ``? rightChildIndex``          ``: leftChildIndex;``      ``[``this``.heap[index], ``this``.heap[smallerIndex]] = [``        ``this``.heap[smallerIndex],``        ``this``.heap[index],``      ``];``      ``index = smallerIndex;``      ``leftChildIndex = 2 * index + 1;``      ``rightChildIndex = 2 * index + 2;``    ``}``    ``return` `minValue;``  ``}``// Queue is empty or not``  ``isEmpty() {``    ``return` `this``.size() === 0;``  ``}` `  ``size() {``    ``return` `this``.heap.length;``  ``}` `  ``peek() {``    ``if` `(``this``.isEmpty()) {``      ``return` `undefined;``    ``}``    ``return` `this``.heap[0];``  ``}``}` `// Class for pair``class Pair {``  ``constructor(index, rsb, setbit) {     ``// Constructor``    ``this``.index = index;``    ``this``.rsb = rsb;``    ``this``.setbit = setbit;``  ``}``}` `// Function to rearrange the elements``// according to Rightmpost set bits``function` `rearrange(arr) {``        ``// Creating priority queue from``        ``// sorting according to``        ``// rightmost set bit.``  ``const n = arr.length;``  ``const pq = [];` `    ``// For creating object of each element``        ``// so that it can be sorted``  ``for` `(let i = 0; i < n; i++) {``      ` `      ``// To calculate the rightmost``            ``// set bit in O(1)``    ``const k = (arr[i] & -arr[i]);``    ` `        ``// Creating a pair object``            ``// with rsb and index``    ``const setbit = arr[i].toString(2).replace(/0/g, ``''``).length;``    ` `        ``// Inserting the element``            ``// in priorityqueue``    ``pq.push(``new` `Pair(i, k, setbit));``  ``}``  ` `// sorting based on RSB``  ``pq.sort((a, b) => {  ``    ``if` `(a.rsb > b.rsb) {``      ``return` `-1;``    ``} ``else` `if` `(a.rsb < b.rsb) {``      ``return` `1;``    ``} ``else` `if` `(a.setbit < b.setbit) {``      ``return` `-1;``    ``} ``else` `if` `(a.setbit > b.setbit) {``      ``return` `1;``    ``} ``else` `if` `(a.index < b.index) {``      ``return` `-1;``    ``} ``else` `{``      ``return` `1;``    ``}``  ``});` `  ``for` `(let i = 0; i < n; i++) {``    ``arr[pq[i].index] = i + 1;``  ``}` `  ``return` `arr;``}` `// Driver Code``const arr = [4, 5, 6, 7, 8];``// To call the rearrange function``const res = rearrange(arr);``console.log(res.join(``' '``));`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `// Class for pair``class` `Pair : IComparable``{``public` `int` `index;``public` `int` `rsb;``public` `int` `setbit;``// Constructor``public` `Pair(``int` `index, ``int` `rsb, ``int` `setbit)``{``    ``this``.index = index;``    ``this``.rsb = rsb;``    ``this``.setbit = setbit;``}` `// Comparator for sorting based on RSB``public` `int` `CompareTo(Pair other)``{``    ``if` `(``this``.rsb > other.rsb)``        ``return` `-1;``    ``else` `if` `(``this``.rsb < other.rsb)``        ``return` `1;``    ``else` `if` `(``this``.setbit < other.setbit)``        ``return` `-1;``    ``else` `if` `(other.setbit < ``this``.setbit)``        ``return` `1;``    ``else` `if` `(``this``.index < other.index)``        ``return` `-1;``    ``else``        ``return` `1;``}``}``// Class to implement the solution logic``class` `GFG``{``    ``// Function to rearrange the elements``    ``// according to Rightmpost set bits``public` `void` `rearrange(``int``[] ar, ``int` `n)``{``    ``// Creating priority queue from``    ``// sorting according to``    ``// rightmost set bit.``    ``SortedSet pq = ``new` `SortedSet();` `    ``// For creating object of each element``    ``// so that it can be sorted``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// To calculate the rightmost``        ``// set bit in O(1)``        ``int` `k = (ar[i] & -ar[i]);``        ``// Creating a pair object``        ``// with rsb and index``        ``int` `setbit = Convert.ToString(ar[i], 2).Length - Convert.ToString(ar[i], 2).Replace(``"1"``, ``""``).Length;``        ``Pair p = ``new` `Pair(i, k, setbit);``        ``// Inserting the element``        ``// in priorityqueue``        ``pq.Add(p);``    ``}` `    ``int` `rank = 1;``    ``// Popping the element of queue``    ``// to get respective rank.``    ``foreach` `(Pair p ``in` `pq)``    ``{``        ``ar[p.index] = rank++;``    ``}``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = { 4, 5, 6, 7, 8 };` `    ``// Creating an object of class``    ``GFG ob = ``new` `GFG();` `    ``// To store the length of array``    ``int` `N = arr.Length;``    ` `    ``// To call the rearrange function``    ``ob.rearrange(arr, N);``    ``for` `(``int` `i = 0; i < N; i++)``        ``Console.Write(arr[i] + ``" "``);``}``}` `// This code is contributed by Aman Kumar.`

Output
`2 4 3 5 1 `

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

Previous
Next