Maximize the number by rearranging bits

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 with 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 with
        // 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 with 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 with 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 with
    // 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)
?>

Javascript

// An efficient JS program to find
// minimum number formed by bits of a
// given number.

function _popcnt32(n)
{
   var count = 0n;

    while (n != 0n)
    {
        n = n & (n - 1n);
        count = count + 1n;
    }

    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.
    var n = _popcnt32(a);

    // If all 32 bits are set.
    if (n == 32n)
        return a;

    // Find a number with n least
    // significant set bits.
    var res = (1n << n) - 1n;

    // Now shift result by 32 - n
    return (res << (32n - n));
}

var a = 3n;
console.log(Number(maximize(a)));

// This code is contributed by phasing17

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.