Open In App

Find most significant set bit of a number

Last Updated : 06 Apr, 2023
Comments
Improve
Suggest changes
Like Article
Like
Report

Given a number, find the greatest number less than the given a number which is the power of two or find the most significant bit number .

Examples: 

Input: 10
Output: 8
Explanation:
Greatest number which is a Power of 2 less than 10 is 8
Binary representation of 10 is 1010
The most significant bit corresponds to decimal number 8.

Input: 18
Output: 16 

A simple solution is to one by one divide n by 2 until it becomes 0 and increment a count while doing this. This count actually represents the position of MSB. 

C++ 
// Simple CPP program to find MSB number
// for given POSITIVE n.
#include <iostream>
using namespace std;

int setBitNumber(int n)
{
    if (n == 0)
        return 0;

    int msb = 0;
    n = n / 2;
    while (n != 0) {
        n = n / 2;
        msb++;
    }

    return (1 << msb);
}

// Driver code
int main()
{
    int n = 0;
    cout << setBitNumber(n);
    n = ~(int)0; // test for possible overflow
    cout << "\n" << (unsigned int)setBitNumber(n);

    return 0;
}
C 
#include <stdio.h>

int setBitNumber(int n)
{
    if (n == 0)
        return 0;

    int msb = 0;
    n = n / 2;
    while (n != 0) {
        n = n / 2;
        msb++;
    }

    return (1 << msb);
}
int main() {

    int n = 0;
    printf("%d \n",setBitNumber(n));
    n = ~(int)0; // test for possible overflow
    int ns = (unsigned int)setBitNumber(n);
    printf("%d",ns);

    return 0;
}
Java 
// Simple Java program to find
// MSB number for given n.
import java.io.*;

class GFG {
    static int setBitNumber(int n)
    {
        if (n == 0)
            return 0;

        int msb = 0;
        n = n / 2;

        while (n != 0) {
            n = n / 2;
            msb++;
        }

        return (1 << msb);
    }

    // Driver code
    public static void main(String[] args)
    {
        int n = 0;
        System.out.println(setBitNumber(n));
    }
}

// This code is contributed by ajit
Python3 
# Simple Python3 program 
# to find MSB number
# for given n.
def setBitNumber(n):
    if (n == 0):
        return 0;

    msb = 0;
    n = int(n / 2);

    while (n > 0):
        n = int(n / 2);
        msb += 1;

    return (1 << msb);

# Driver code
n = 0;
print(setBitNumber(n));
    
# This code is contributed 
# by mits
C# 
// Simple C# program to find
// MSB number for given n.
using System;

class GFG {
    static int setBitNumber(int n)
    {
        if (n == 0)
            return 0;

        int msb = 0;
        n = n / 2;

        while (n != 0) {
            n = n / 2;
            msb++;
        }

        return (1 << msb);
    }

    // Driver code
    static public void Main()
    {
        int n = 0;
        Console.WriteLine(setBitNumber(n));
    }
}

// This code is contributed
// by akt_mit
PHP 
<?php
// Simple PhP program 
// to find MSB number
// for given n.

function setBitNumber($n)
{
    if ($n == 0)
        return 0;

    $msb = 0;
        $n = $n / 2;

    while ($n != 0) 
    {
        $n = $n / 2;
        $msb++;
    }

    return (1 << $msb);
}

// Driver code
$n = 0;
echo setBitNumber($n);
    
// This code is contributed 
// by akt_mit
?>
JavaScript 
<script>

// Javascript  program
// to find MSB number
// for given n.

function setBitNumber(n)
{
    if (n == 0)
        return 0;

    let msb = 0;
        n = n / 2;

    while (n != 0)
    {
        n = $n / 2;
        msb++;
    }

    return (1 << msb);
}

// Driver code
let n = 0;
document.write (setBitNumber(n));
    
// This code is contributed by Bobby

</script>

Output
0
1

Time Complexity: O(logn)
Auxiliary Space: O(1)

An efficient solution for a fixed size integer (say 32 bits) is to one by one set bits, then add 1 so that only the bit after MSB is set. Finally right shift by 1 and return the answer. This solution does not require any condition checking.

C++ 
// CPP program to find MSB number for ANY given n.
#include <iostream>
#include <limits.h>
using namespace std;

int setBitNumber(int n)
{
    // Below steps set bits after
    // MSB (including MSB)

    // Suppose n is 273 (binary
    // is 100010001). It does following
    // 100010001 | 010001000 = 110011001
    n |= n >> 1;

    // This makes sure 4 bits
    // (From MSB and including MSB)
    // are set. It does following
    // 110011001 | 001100110 = 111111111
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // The naive approach would increment n by 1,
    // so only the MSB+1 bit will be set,
    // So now n theoretically becomes 1000000000.
    // All the would remain is a single bit right shift:
    //    n = n + 1;
    //    return (n >> 1);
    //
    // ... however, this could overflow the type.
    // To avoid overflow, we must retain the value
    // of the bit that could overflow:
    //     n & (1 << ((sizeof(n) * CHAR_BIT)-1))
    // and OR its value with the naive approach:
    //     ((n + 1) >> 1)
    n = ((n + 1) >> 1) |
        (n & (1 << ((sizeof(n) * CHAR_BIT)-1)));
    return n;
}

// Driver code
int main()
{
    int n = 273;
    cout << setBitNumber(n);
    n = ~(int)0; // test for possible overflow
    cout << "\n" << (unsigned int)setBitNumber(n);
    return 0;
}
C 
#include <stdio.h>
#include <limits.h>
int setBitNumber(int n)
{
    // Below steps set bits after
    // MSB (including MSB)

    // Suppose n is 273 (binary
    // is 100010001). It does following
    // 100010001 | 010001000 = 110011001
    n |= n >> 1;

    // This makes sure 4 bits
    // (From MSB and including MSB)
    // are set. It does following
    // 110011001 | 001100110 = 111111111
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
  
  // The naive approach would increment n by 1,
    // so only the MSB+1 bit will be set,
    // So now n theoretically becomes 1000000000.
    // All the would remain is a single bit right shift:
    //    n = n + 1;
    //    return (n >> 1);
    //
    // ... however, this could overflow the type.
    // To avoid overflow, we must retain the value
    // of the bit that could overflow:
    //     n & (1 << ((sizeof(n) * CHAR_BIT)-1))
    // and OR its value with the naive approach:
    //     ((n + 1) >> 1)
    n = ((n + 1) >> 1) |
        (n & (1 << ((sizeof(n) * CHAR_BIT)-1)));
    return n;
}

int main() {
   int n = 273;
    printf("%d\n",setBitNumber(n));
    return 0;
}
Java 
// Java program to find MSB
// number for given n.

class GFG {

    static int setBitNumber(int n)
    {

        // Below steps set bits after
        // MSB (including MSB)

        // Suppose n is 273 (binary
        // is 100010001). It does following
        // 100010001 | 010001000 = 110011001
        n |= n >> 1;

        // This makes sure 4 bits
        // (From MSB and including MSB)
        // are set. It does following
        // 110011001 | 001100110 = 111111111
        n |= n >> 2;

        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;

        // Increment n by 1 so that
        // there is only one set bit
        // which is just before original
        // MSB. n now becomes 1000000000
        n = n + 1;

        // Return original MSB after shifting.
        // n now becomes 100000000
        return (n >> 1);
    }

    // Driver code
    public static void main(String arg[])
    {
        int n = 273;
        System.out.print(setBitNumber(n));
    }
}

// This code is contributed by Anant Agarwal.
Python3 
# Python program to find
# MSB number for given n.

def setBitNumber(n):

    # Below steps set bits after
    # MSB (including MSB)
 
    # Suppose n is 273 (binary 
    # is 100010001). It does following
    # 100010001 | 010001000 = 110011001
    n |= n>>1
 
    # This makes sure 4 bits
    # (From MSB and including MSB)
    # are set. It does following
    # 110011001 | 001100110 = 111111111
    n |= n>>2   
 
    n |= n>>4  
    n |= n>>8
    n |= n>>16
     
    # Increment n by 1 so that
    # there is only one set bit
    # which is just before original
    # MSB. n now becomes 1000000000
    n = n + 1
 
    # Return original MSB after shifting.
    # n now becomes 100000000
    return (n >> 1)

# Driver code

n = 273            
print(setBitNumber(n))

# This code is contributed
# by Anant Agarwal.
C# 
// C# program to find MSB number for given n.
using System;

class GFG {

    static int setBitNumber(int n)
    {

        // Below steps set bits after
        // MSB (including MSB)

        // Suppose n is 273 (binary
        // is 100010001). It does following
        // 100010001 | 010001000 = 110011001
        n |= n >> 1;

        // This makes sure 4 bits
        // (From MSB and including MSB)
        // are set. It does following
        // 110011001 | 001100110 = 111111111
        n |= n >> 2;

        n |= n >> 4;
        n |= n >> 8;
        n |= n >> 16;

        // Increment n by 1 so that
        // there is only one set bit
        // which is just before original
        // MSB. n now becomes 1000000000
        n = n + 1;

        // Return original MSB after shifting.
        // n now becomes 100000000
        return (n >> 1);
    }

    // Driver code
    public static void Main()
    {
        int n = 273;
        Console.WriteLine(setBitNumber(n));
    }
}

// This code is contributed by Sam007.
PHP 
<?php
// PHP program to find 
// MSB number for given n.

function setBitNumber($n)
{
    // Below steps set bits 
    // after MSB (including MSB)

    // Suppose n is 273 (binary
    // is 100010001). It does
    // following 100010001 |
    // 010001000 = 110011001
    $n |= $n >> 1;

    // This makes sure 4 bits
    // (From MSB and including 
    // MSB) are set. It does 
    // following 110011001 | 
    // 001100110 = 111111111
    $n |= $n >> 2;

    $n |= $n >> 4;
    $n |= $n >> 8;
    $n |= $n >> 16;

    // Increment n by 1 so 
    // that there is only 
    // one set bit which is
    // just before original
    // MSB. n now becomes 
    // 1000000000
    $n = $n + 1;

    // Return original MSB 
    // after shifting. n 
    // now becomes 100000000
    return ($n >> 1);
}

// Driver code
$n = 273;
echo setBitNumber($n);

// This code is contributed
// by akt_mit
?>
JavaScript 
<script>

// Javascript program to find MSB
// number for given n.
function setBitNumber(n)
{
    
    // Below steps set bits after
    // MSB (including MSB)

    // Suppose n is 273 (binary
    // is 100010001). It does following
    // 100010001 | 010001000 = 110011001
    n |= n >> 1;

    // This makes sure 4 bits
    // (From MSB and including MSB)
    // are set. It does following
    // 110011001 | 001100110 = 111111111
    n |= n >> 2;

    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    // Increment n by 1 so that
    // there is only one set bit
    // which is just before original
    // MSB. n now becomes 1000000000
    n = n + 1;

    // Return original MSB after shifting.
    // n now becomes 100000000
    return (n >> 1);
}

// Driver code
let n = 273;
document.write(setBitNumber(n));

// This code is contributed by suresh07

</script>

Output
256
2147483648

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

Using __builtin_clz(x) (GCC builtin function)

Say for a fixed integer (32 bits), count the number of leading zeroes by using the built-in function and subtract it from 31 to get the position of MSB from left, then return the MSB using left shift operation on 1.

An efficient solution for a fixed size integer (say 32 bits) is to one by one set bits, then add 1 so that only the bit after MSB is set. Finally right shift by 1 and return the answer. This solution does not require any condition checking.

C++ 
// CPP program to find MSB
// number for a given POSITIVE n.
#include <bits/stdc++.h>
using namespace std;

int setBitNumber(int n)
{

    // calculate the  number
    // of leading zeroes
    int k = __builtin_clz(n);

    // To return the value
    // of the number with set
    // bit at (31 - k)-th position
    // assuming 32 bits are used
    return 1 << (31 - k);
}

// Driver code
int main()
{
    int n = 273;
    cout << setBitNumber(n);
    n = ~(int)0; // test for possible overflow
    cout << "\n" << (unsigned int)setBitNumber(n);
    return 0;
}
Java 
import java.lang.*;

public class Main {
    public static int setBitNumber(int n) {
        // calculate the  number
        // of leading zeroes
        int k = Integer.numberOfLeadingZeros(n);

        // To return the value
        // of the number with set
        // bit at (31 - k)-th position
        // assuming 32 bits are used
        return 1 << (31 - k);
    }

    // Driver code
    public static void main(String[] args) {
        int n = 273;
        System.out.println(setBitNumber(n));

        n = ~(int)0; // test for possible overflow
        System.out.println((int)setBitNumber(n));
    }
}
// This code is Contributed by 'Shiv1o43g'
C# 
using System;

public class MainClass {
    public static int SetBitNumber(int n)
    {
        // calculate the  number
        // of leading zeroes
        int k = 32 - Convert.ToString(n, 2).Length;

        // To return the value
        // of the number with set
        // bit at (31 - k)-th position
        // assuming 32 bits are used
        return 1 << (31 - k);
    }

    // Driver code
    public static void Main()
    {
        int n = 273;
        Console.WriteLine(SetBitNumber(n));

        n = ~(int)0; // test for possible overflow
        Console.WriteLine((uint)SetBitNumber(n));
    }
}
// This code is contributed by user_dtewbxkn77n
JavaScript 
function setBitNumber(n) {
  // calculate the number of leading zeroes
  let k = 31 - Math.floor(Math.log2(n));
  
  // To return the value of the number with set
  // bit at (31 - k)-th position
  return 1 << k;
}

// Driver code
let n = 273;
console.log(setBitNumber(n)); // expected output: 256

n = ~(0); // test for possible overflow
console.log(setBitNumber(n)); // expected output: 2147483648

Output
256
2147483648

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

Another Approach: Given a number n. First, find the position of the most significant set bit and then compute the value of the number with a set bit at k-th position. 

Thanks Rohit Narayan for suggesting this method. 

C++ 
// CPP program to find MSB
// number for given POSITIVE n.
#include <bits/stdc++.h>
using namespace std;

int setBitNumber(int n)
{
  //this will be the answer going to return
  //This will work for 64-bit if using with long long
  //while in-built functions overflow 
    int ans = 1;
    while (n) {
        ans *= 2;
        n /= 2;
    }
      ans/=2;
    return ans;
}

// Driver code
int main()
{
    int n = 273;
    cout << setBitNumber(n);
   
    return 0;
}
C 
#include <stdio.h>
#include <math.h>

int setBitNumber(int n)
{

    if (n == 0)
        return 0;

    int msb = 0;
    n = n / 2;
    while (n != 0) {
        n = n / 2;
        msb++;
    }

    return (1 << msb);
}
int main() {
    int n = 273;
    printf("%d",setBitNumber(n));

    return 0;
}
Java 
// Java program to find MSB
// number for given n.

class GFG {

    static int setBitNumber(int n)
    {

        // To find the position of the
        // most significant set bit
        int k = (int)(Math.log(n) / Math.log(2));

        // To return the value of the number
        // with set bit at k-th position
        return 1 << k;
    }

    // Driver code
    public static void main(String arg[])
    {
        int n = 273;
        System.out.print(setBitNumber(n));
    }
}
Python3 
# Python program to find
# MSB number for given n.
import math

def setBitNumber(n):
    
    # To find the position of
    # the most significant 
    # set bit
    k = int(math.log(n, 2))
    
    # To return the value 
    # of the number with set 
    # bit at k-th position
    return 1 << k

# Driver code
n = 273        
print(setBitNumber(n))
C# 
// C# program to find MSB
// number for given n.
using System;

public class GFG {

    static int setBitNumber(int n)
    {

        // To find the position of the
        // most significant set bit
        int k = (int)(Math.Log(n) / Math.Log(2));

        // To return the  value of the number
        // with set bit at k-th position
        return 1 << k;
    }

    // Driver code
    static public void Main()
    {
        int n = 273;
        Console.WriteLine(setBitNumber(n));
    }
}
PHP 
<?php
// PHP program to find MSB
// number for given n.

function setBitNumber($n)
{

    // To find the position
    // of the most significant
    // set bit
    $k =(int)(log($n, 2));

    // To return the value
    // of the number with set
    // bit at k-th position
    return 1 << $k;
}

// Driver code
    $n = 273;
    echo setBitNumber($n);

// This code is contributed
// by jit_t.
?>
JavaScript 
<script>

    // Javascript program to find
    // MSB number for given n.
    
    function setBitNumber(n)
    {
 
        // To find the position of the
        // most significant set bit
        let k = parseInt(Math.log(n) / Math.log(2), 10);
 
        // To return the value of the number
        // with set bit at k-th position
        return 1 << k;
    }
    
    let n = 273;
      document.write(setBitNumber(n));
    
</script>

Output
256

Time Complexity: O(logn)
Auxiliary Space: O(1)



Next Article
Find most significant set bit of a number

D

Devanshu Agarwal
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox