Minimum number using set bits of a given number

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

Examples :

Input : 6 
Output : 3 
Binary representation of 6 is 0000….0110. Smallest number with same number of set bits 0000….0011. 

Input : 11 
Output : 7 

Simple Approach:
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 it’s ‘n’ least significant bits set to 1. 
4. Convert the binary representation back to the number.
Efficient Approach:
1. Just measure the number of 1’s present in the bit representation of the number. 
2. (Number of set bits raised to the power of 2) – 1 represents the minimized number.

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 minimum number formed by
// bits of a given number.
ll minimize(ll a)
{
    // _popcnt32(a) gives number of 1's
    // present in binary representation
    // of a.
    ll n = _popcnt32(a);

    return (pow(2, n) - 1);
}

// Driver function.
int main()
{
    ll a = 11;
    cout << minimize(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
{
    public static int _popcnt32(long number)
    {
        int count = 0;
        while (number > 0)
        {
            count += number & 1L;
            number >>= 1L;
        }
        return count;
    }

    // Returns minimum number formed
    // by bits of a given number.
    static long minimize(long a)
    {
        // _popcnt32(a) gives number
        // of 1's present in binary
        // representation of a.
        int n = _popcnt32(a);

        return ((long)Math.pow(2, n) - 1);
    }

    // Driver Code.
    public static void main(String args[])
    {
        long a = 11;
        System.out.print(minimize(a));
    }
}

// This code is contributed by
// Manish Shaw(manishshaw1)

Python3

# An efficient Python3 program
# to find minimum number formed
# by bits of a given number.

# Returns minimum number formed by
# bits of a given number.
def minimize(a):

    # _popcnt32(a) gives number of 1's
    # present in binary representation
    # of a.
    n = bin(a).count("1")

    return (pow(2, n) - 1)

# Driver Code
a = 11
print(minimize(a))

# This code is contributed by Mohit Kumar

C#

// An efficient C# program to
// find minimum number formed
// by bits of a given number.
using System;
using System.Linq;
using System.Collections.Generic;

class GFG
{
    // Returns minimum number formed
    // by bits of a given number.
    static long minimize(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 + 1;

        return ((long)Math.Pow(2, n) - 1);
    }

    // Driver Code.
    static void Main()
    {
        long a = 11;
        Console.Write(minimize(a));
    }
}

// This code is contributed by
// Manish Shaw(manishshaw1)

Javascript

<script>
// An efficient Javascript program to
// find minimum number formed
// by bits of a given number.

    function _popcnt32(number)
    {
        let count = 0;
        while (number > 0)
        {
            count += number & 1;
            number >>= 1;
        }
        return count;
    }

    // Returns minimum number formed
    // by bits of a given number.
    function minimize(a)
    {

        // _popcnt32(a) gives number
        // of 1's present in binary
        // representation of a.
        let n = _popcnt32(a);

        return (Math.pow(2, n) - 1);
    }

    // Driver Code.
    let a = 11;
    document.write(minimize(a));

// This code is contributed by unknown2108
</script>

Time Complexity: O(log N), as the _popcnt32 has a time complexity O(logN), however, _popcnt32 has a maximum value of O(log32), so it can be interpreted as O(1) as well.
Auxiliary Space: O(1)
Note : The above code uses GCC specific functions. If we wish to write code for other compilers, we may use Count set bits in an integer.