What is Maximize the number by rearranging bits?

In this article, we will learn Maximize the number by rearranging bits,This free C Language tutorial for complete beginners will help you learn C Language from scratch.

Maximize the number by rearranging bits - ❤️C Language Tutorials In 2024

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.