# Find most significant set bit of a number

• Difficulty Level : Medium
• Last Updated : 09 May, 2022

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
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 ``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;``}`

## 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

 ``

## Javascript

 ``
Output:
`0`

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 ``#include ``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;``}`

## 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

 `> 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

 ``
Output:
`256`

Time complexity is 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 ``using` `namespace` `std;` `int` `setBitNumber(``int` `n)``{` `    ``// To find the position``    ``// of the most significant``    ``// set bit``    ``int` `k = (``int``)(log2(n));` `    ``// To return the value``    ``// of the number with set``    ``// bit at k-th position``    ``return` `1 << 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

 `// 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

 ``

## Javascript

 ``
Output:
`256`

This article is contributed by Devanshu Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.