# Find most significant set bit of a number

• Difficulty Level : Medium
• Last Updated : 27 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;` `}`

## C

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

 ``

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

## C

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

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

## C

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

 ``

## Javascript

 ``

Output:

`256`

Another Approach :

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.