Count of numbers having only 1 set bit in the range [0, n]

Given an integer n, the task is to count the numbers having only 1 set bit in the range [0, n].
Examples:

Input: n = 7 
Output: 3 
Explanation: 000, 001, 010, 011, 100, 101, 110 and 111 are the binary representation of all the numbers upto 7. And there are only 3 numbers ( 001, 010 and 100 ) having only 1 set bit.

Input: n = 3 
Output: 2 

Approach: If k bits are required to represent n then there are k numbers possible as 1 can be positioned at k different positions each time.
Below is the implementation of the above approach

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the required count
int count(int n)
{

    // To store the count of numbers
    int cnt = 0;
    int p = 1;
    while (p <= n) {
        cnt++;

        // Every power of 2 contains
        // only 1 set bit
        p *= 2;
    }
    return cnt;
}

// Driver code
int main()
{
    int n = 7;
    cout << count(n);

    return 0;
}

Java

// Java implementation of the approach
class GFG {

    // Function to return the required count
    static int count(int n)
    {

        // To store the count of numbers
        int cnt = 0;
        int p = 1;
        while (p <= n) {
            cnt++;

            // Every power of 2 contains
            // only 1 set bit
            p *= 2;
        }
        return cnt;
    }

    // Driver code
    public static void main(String args[])
    {
        int n = 7;
        System.out.print(count(n));
    }
}

C#

// C# implementation of the approach
using System;
class GFG {

    // Function to return the required count
    static int count(int n)
    {

        // To store the count of numbers
        int cnt = 0;
        int p = 1;
        while (p <= n) {
            cnt++;

            // Every power of 2 contains
            // only 1 set bit
            p *= 2;
        }
        return cnt;
    }

    // Driver code
    public static void Main()
    {
        int n = 7;
        Console.Write(count(n));
    }
}

Python3

# Python3 implementation of the approach

# Function to return the required count
def count(n):

    # To store the count of numbers
    cnt = 0
    p = 1
    while (p <= n):
        cnt = cnt + 1

        # Every power of 2 contains
        # only 1 set bit
        p *= 2
    return cnt

# Driver code
n = 7
print(count(n));

PHP

<?php
// PHP implementation of the approach

// Function to return the required count
function count_t($n)
{

    // To store the count of numbers
    $cnt = 0;
    $p = 1;
    while ($p <= $n)
    {
        $cnt++;

        // Every power of 2 contains
        // only 1 set bit
        $p *= 2;
    }
    return $cnt;
}

// Driver code
$n = 7;
echo count_t($n);

// This Code is contributed by ajit.
?>

Javascript

<script>
// Javascript implementation of the approach

// Function to return the required count
function count(n)
{

    // To store the count of numbers
    var cnt = 0;
    var p = 1;
    while (p <= n) {
        cnt++;

        // Every power of 2 contains
        // only 1 set bit
        p *= 2;
    }
    return cnt;
}

// Driver code
var n = 7;
document.write(count(n));

// This code is contributed by noob2000.
</script>

Output

3

Time Complexity: O(log n)
Auxiliary Space: O(1)