Skip to content
Related Articles

Related Articles

Improve Article

Maximize the number by rearranging bits

  • Difficulty Level : Easy
  • Last Updated : 03 Jun, 2021
Geek Week

Given an unsigned number, find the maximum number that could be formed by using the bits of the given unsigned number.

Examples : 

Input : 1 (0000....0001)
Output : 2147483648 (1000....0000)

Input : 7 (0000....0111)
Output : 3758096384 (0111....0000)

Method 1 (Simple) 
1. Find binary representation of the number using simple decimal to binary representation technique. 
2. Count number of set bits in the binary representation equal to ‘n’. 
3. Create a binary representation with its ‘n’ most significant bits set to 1. 
4. Convert the binary representation back to the number. 

C++




// An simple C++ program to find
// minimum number formed by bits of a
// given number.
#include <bits/stdc++.h>
#define ll unsigned int
using namespace std;
 
// Returns maximum number formed by
// bits of a given number.
ll maximize(ll a)
{
    // _popcnt32(a) gives number of 1's
    // present in binary representation of a.
    ll n = _popcnt32(a);
 
    // Set most significant n bits of res.
    ll res = 0;
    for (int i=1; i<=n; i++)
       res |= (1 << (32 - i));
 
    return res;
}
 
// Driver function.
int main()
{
    ll a = 1;
    cout << maximize(a) << endl;
    return 0;
}

Java




// An simple Java program to find
// minimum number formed by bits
// of a given number.
import java.io.*;
 
class GFG
{
    private static int _popcnt32(long number)
    {
        int counter = 0;
         
        while(number > 0)
        {
            if(number % 2 == 1)
            {
                counter++;
            }
             
            //or number = number >> 1
            number = number / 2;
        }
        return counter;
    }
     
    // Returns maximum number formed
    // by bits of a given number.
    static long maximize(long a)
    {
        // _popcnt32(a) gives number
        // of 1's present in binary
        // representation of a.
        int n = _popcnt32(a);
                 
        // Set most significant
        // n bits of res.
        long res = 0;
        for (int i = 1; i <= n; i++)
        res = (int)res | (1 << (32 - i));
     
        return Math.abs(res);
    }
     
    // Driver Code
    public static void main(String args[])
    {
        long a = 1;
        System.out.print(maximize(a));
    }
}
 
// This code is contributed by
// Manish Shaw(manishshaw1)

Python3




# An simple Python program to
# find minimum number formed
# by bits of a given number.
def _popcnt32(number) :
    counter = 0
     
    while(number > 0) :
        if(number % 2 == 1) :
            counter = counter + 1
             
        # or number = number >> 1
        number = int(number / 2)
 
    return counter
 
# Returns maximum number formed
# by bits of a given number.
def maximize(a) :
     
    # _popcnt32(a) gives number
    # of 1's present in binary
    # representation of a.
    n = _popcnt32(a)
             
    # Set most significant
    # n bits of res.
    res = 0
    for i in range(1, n + 1) :
        res = int(res |
                 (1 << (32 - i)))
 
    return abs(res)
 
# Driver Code
a = 1
print (maximize(a))
 
# This code is contributed by
# Manish Shaw(manishshaw1)

C#




// An simple C# program to find
// minimum number formed by bits
// of a given number.
using System;
 
class GFG
{
     
    // Returns maximum number formed
    // by bits of a given number.
    static long maximize(long a)
    {
        // _popcnt32(a) gives number
        // of 1's present in binary
        // representation of a.
        string binaryString = Convert.ToString(a, 2);
        int n = binaryString.Split(new [] {'0'},
                StringSplitOptions.RemoveEmptyEntries).Length;
                 
        // Set most significant n bits of res.
        long res = 0;
        for (int i = 1; i <= n; i++)
        res = (int)res | (1 << (32 - i));
     
        return Math.Abs(res);
    }
     
    // Driver Code.
    static void Main()
    {
        long a = 1;
        Console.WriteLine(maximize(a));
    }
}
// This code is contributed by
// Manish Shaw(manishshaw1)

PHP




<?php
// An simple PHP program to find
// minimum number formed by bits
// of a given number.
function _popcnt32($number)
{
    $counter = 0;
     
    while($number > 0)
    {
        if($number % 2 == 1)
        {
            $counter++;
        }
         
        //or number = number >> 1
        $number = intval($number / 2);
    }
    return $counter;
}
 
// Returns maximum number formed
// by bits of a given number.
function maximize($a)
{
    // _popcnt32(a) gives number
    // of 1's present in binary
    // representation of a.
    $n = _popcnt32($a);
             
    // Set most significant
    // n bits of res.
    $res = 0;
    for ($i = 1; $i <= $n; $i++)
    $res = intval($res |
                 (1 << (32 - $i)));
 
    return abs($res);
}
 
// Driver Code
$a = 1;
echo (maximize($a));
 
// This code is contributed by
// Manish Shaw(manishshaw1)
?>

Javascript




<script>
  
// An simple JavaScript program to find
// minimum number formed by bits of a
// given number.
 
 
function _popcnt32(number)
{
    var counter = 0;
     
    while(number > 0)
    {
        if(number % 2 == 1)
        {
            counter++;
        }
         
        //or number = number >> 1
        number = parseInt(number / 2);
    }
    return counter;
}
 
// Returns maximum number formed by
// bits of a given number.
function maximize(a)
{
    // _popcnt32(a) gives number of 1's
    // present in binary representation of a.
    var n = _popcnt32(a);
 
    // Set most significant n bits of res.
    var res = 0;
    for (var i=1; i<=n; i++)
       res |= (1 << (32 - i));
 
    return Math.abs(res);
}
 
// Driver function.
var a = 1;
document.write(maximize(a));
 
</script>
Output: 
2147483648

 

Method 2 (Efficient) 
The idea is to first find a number with n least significant set bits, then shift the number left by 32-n. 

C++




// An efficient C++ program to find
// minimum number formed by bits of a
// given number.
#include <bits/stdc++.h>
#define ll unsigned int
using namespace std;
 
// Returns maximum number formed by
// bits of a given number.
ll maximize(ll a)
{
    // _popcnt32(a) gives number of 1's
    // present in binary representation of a.
    ll n = _popcnt32(a);
     
    // If all 32 bits are set.
    if (n == 32)
      return a;
 
    // find a number witn n least
    // significant set bits.
    ll res = (1 << n) - 1;
     
    // Now shift result by 32 - n
    return (res << (32 - n)) ;
}
 
// Driver function.
int main()
{
    ll a = 3;
    cout << maximize(a) << endl;
    return 0;
}

Java




// An efficient Java program to
// find minimum number formed
// by bits of a given number.
import java.io.*;
 
class GFG
{
    static long _popcnt32(long n)
    {
        long count = 0;
        while (n != 0)
        {
            n = n & (n - 1);
            count++;
        }
        return count;
    }
     
    // Returns maximum number
    // formed by bits of a
    // given number.
    static long maximize(long a)
    {
        // _popcnt32(a) gives number
        // of 1's present in binary
        // representation of a.
        long n = _popcnt32(a);
 
        // If along 32
        // bits are set.
        if (n == 32)
        return a;
     
        // find a number witn
        // n least significant
        // set bits.
        long res = (1 << n) - 1;
         
        // Now shift result
        // by 32 - n
        return (res << (32 - n)) ;
    }    
     
    // Driver Code
    public static void main(String args[])
    {
        long a = 3;
        System.out.print(maximize(a));
    }
}
 
// This code is contributed by
// ManishShaw(manishshaw1)

Python3




# An efficient python3 program to find
# minimum number formed by bits of a
# given number.
def _popcnt32(n):
     
    count = 0
     
    while (n != 0):
        n = n & (n - 1)
        count = count + 1
         
    return count
 
# Returns maximum number formed by
# bits of a given number.
def maximize(a):
 
    # _popcnt32(a) gives number of 1's
    # present in binary representation of a.
    n = _popcnt32(a)
 
    # If all 32 bits are set.
    if (n == 32):
        return a
 
    # Find a number witn n least
    # significant set bits.
    res = (1 << n) - 1
 
    # Now shift result by 32 - n
    return (res << (32 - n))
 
# Driver code
if __name__ == '__main__':
     
    a = 3
    print(maximize(a))
 
# This code is contributed by nirajgusain5

C#




// An efficient C# program to
// find minimum number formed
// by bits of a given number.
using System;
 
class GFG
{
    static long _popcnt32(long n)
    {
        long count = 0;
        while (n != 0)
        {
            n = n & (n - 1);
            count++;
        }
        return count;
    }
     
    // Returns maximum number
    // formed by bits of a
    // given number.
    static long maximize(long a)
    {
        // _popcnt32(a) gives number
        // of 1's present in binary
        // representation of a.
        long n = _popcnt32(a);
 
        // If along 32
        // bits are set.
        if (n == 32)
        return a;
     
        // find a number witn n
        // least significant set bits.
        long res = (1 << Convert.ToInt32(n)) - 1;
         
        // Now shift result
        // by 32 - n
        return (res << (32 - Convert.ToInt32(n))) ;
    }    
     
    // Driver Code
    static void Main()
    {
        long a = 3;
        Console.WriteLine(maximize(a));
    }
}
 
// This code is contributed by
// ManishShaw(manishshaw1)

PHP




<?php
// An efficient Java program to
// find minimum number formed
// by bits of a given number.
 
function _popcnt32($n)
{
    $count = 0;
    while ($n != 0)
    {
        $n = $n & ($n - 1);
        $count++;
    }
    return $count;
}
 
// Returns maximum number
// formed by bits of a
// given number.
function maximize($a)
{
    // _popcnt32(a) gives number
    // of 1's present in binary
    // representation of a.
    $n = _popcnt32($a);
 
    // If a$32
    // bits are set.
    if ($n == 32)
    return $a;
 
    // find a number witn
    // n least significant
    // set bits.
    $res = (1 << $n) - 1;
     
    // Now shift result
    // by 32 - n
    return ($res << (32 - $n)) ;
}    
 
// Driver Code
$a = 3;
echo (maximize($a));
 
// This code is contributed by
// ManishShaw(manishshaw1)
?>
Output: 
3221225472

 

Note: The above codes use GCC specific functions. If we wish to write code for other compilers, we may use Count set bits in an integer.
 

Take a step-up from those “Hello World” programs. Learn to implement data structures like Heap, Stacks, Linked List and many more! Check out our Data Structures in C course to start learning today.



My Personal Notes arrow_drop_up
Recommended Articles
Page :