 Open in App
Not now

# Position of rightmost set bit

• Difficulty Level : Medium
• Last Updated : 24 Jan, 2023

Write a one-line function to return the position of the first 1 from right to left, in the binary representation of an Integer.

Examples:

Input: n = 18
Output: 2
Explanation: Binary Representation of 18 is 010010, hence position of first set bit from right is 2.

Input:  n = 19
Output: 1
Explanation: Binary Representation of 19 is 010011, hence position of first set bit from right is 1.

Recommended Practice

## Position of rightmost set bit using two’s complement:

(n&~(n-1)) always return the binary number containing the rightmost set bit as 1. if N = 12 (1100) then it will return 4 (100). Here log2 will return, the number of times we can express that number in a power of two. For all binary numbers containing only the rightmost set bit as 1 like 2, 4, 8, 16, 32…. Find that position of rightmost set bit is always equal to log2(Number) + 1.

Follow the steps to solve the given problem:

• Let input be 12 (1100)
• Take two’s complement of the given no as all bits are reverted except the first ‘1’ from right to left (0100)
• Do a bit-wise & with original no, this will return no with the required one only (0100)
• Take the log2 of the no, you will get (position – 1) (2)

Below is the implementation of the above approach:

## C++

 `// C++ program for Position``// of rightmost set bit``#include ``#include ``using` `namespace` `std;` `class` `gfg {` `public``:``    ``unsigned ``int` `getFirstSetBitPos(``int` `n)``    ``{``        ``return` `log2(n & -n) + 1;``    ``}``};` `// Driver code``int` `main()``{``    ``gfg g;``    ``int` `n = 18;``    ``cout << g.getFirstSetBitPos(n);``    ``return` `0;``}` `// This code is contributed by SoM15242`

## C

 `// C program for Position``// of rightmost set bit``#include ``#include ` `// Driver code``int` `main()``{``    ``int` `n = 18;``    ``int` `ans = log2(n & -n) + 1;``    ``printf``(``"%d"``, ans);``    ``getchar``();``    ``return` `0;``}`

## Java

 `// Java Code for Position of rightmost set bit` `import` `java.io.*;` `class` `GFG {` `    ``public` `static` `int` `getFirstSetBitPos(``int` `n)``    ``{``        ``return` `(``int``)((Math.log10(n & -n)) / Math.log10(``2``))``            ``+ ``1``;``    ``}` `    ``// Drive code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``18``;``        ``System.out.println(getFirstSetBitPos(n));``    ``}``}``// This code is contributed by Arnav Kr. Mandal`

## Python3

 `# Python Code for Position``# of rightmost set bit` `import` `math`  `def` `getFirstSetBitPos(n):` `    ``return` `math.log2(n & ``-``n)``+``1` `# driver code`  `n ``=` `18``print``(``int``(getFirstSetBitPos(n)))` `# This code is contributed``# by Anant Agarwal.`

## C#

 `// C# Code for Position of rightmost set bit``using` `System;` `class` `GFG {``    ``public` `static` `int` `getFirstSetBitPos(``int` `n)``    ``{``        ``return` `(``int``)((Math.Log10(n & -n)) / Math.Log10(2))``            ``+ 1;``    ``}` `    ``// Driver method``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 18;``        ``Console.WriteLine(getFirstSetBitPos(n));``    ``}``}` `// This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

`2`

Time Complexity: O(log2N), Time taken by log2 function.
Auxiliary Space: O(1)

## Position of rightmost set bit using ffs() function:

ffs() function returns the index of first least significant set bit. The indexing starts in ffs() function from 1.
Illustration:

Input: N = 12

Binary Representation of 12 is 1100

ffs(N) returns the rightmost set bit index which is 3

Below is the implementation of the above approach:

## C++

 `// C++ program to find the``// position of first rightmost``// set bit in a given number.``#include ``using` `namespace` `std;` `// Function to find rightmost``// set bit in given number.``int` `getFirstSetBitPos(``int` `n) { ``return` `ffs(n); }` `// Driver function``int` `main()``{``    ``int` `n = 18;``    ``cout << getFirstSetBitPos(n) << endl;``    ``return` `0;``}`

## Java

 `// Java program  to find the``// position of first rightmost``// set bit in a given number``import` `java.util.*;` `class` `GFG {` `    ``// Function to find rightmost``    ``// set bit in given number.``    ``static` `int` `getFirstSetBitPos(``int` `n)``    ``{``        ``return` `(``int``)((Math.log10(n & -n)) / Math.log10(``2``))``            ``+ ``1``;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``18``;``        ``System.out.print(getFirstSetBitPos(n));``    ``}``}` `// This code is contributed by sanjoy_62.`

## Python3

 `# Python3 program to find the``# position of first rightmost``# set bit in a given number``import` `math` `# Function to find rightmost``# set bit in given number.`  `def` `getFirstSetBitPos(n):` `    ``return` `int``(math.log2(n & ``-``n) ``+` `1``)`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``n ``=` `18``    ``print``(getFirstSetBitPos(n))` `# This code is contributed by nirajgusain5.`

## C#

 `// C# program  to find the``// position of first rightmost``// set bit in a given number``using` `System;``public` `class` `GFG {` `    ``// Function to find rightmost``    ``// set bit in given number.``    ``static` `int` `getFirstSetBitPos(``int` `n)``    ``{``        ``return` `(``int``)((Math.Log10(n & -n)) / Math.Log10(2))``            ``+ 1;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `n = 18;``        ``Console.Write(getFirstSetBitPos(n));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

```2
```

Time Complexity: O(log2N), Time taken by ffs() function.
Auxiliary Space: O(1)

## Position of rightmost set bit using  & operator:

Follow the steps below to solve the problem:

• Initialize m as 1 as check its XOR with the bits starting from the rightmost bit.
• Left shift m by one till we find the first set bit
• as the first set bit gives a number when we perform a & operation with m.

Below is the implementation of above approach:

## C++

 `// C++ program to find the first``// rightmost set bit using XOR operator``#include ``using` `namespace` `std;` `// function to find the rightmost set bit``int` `PositionRightmostSetbit(``int` `n)``{``    ``if` `(n == 0)``        ``return` `0;``    ``// Position variable initialize with 1``    ``// m variable is used to check the set bit``    ``int` `position = 1;``    ``int` `m = 1;` `    ``while` `(!(n & m)) {` `        ``// left shift``        ``m = m << 1;``        ``position++;``    ``}``    ``return` `position;``}``// Driver Code``int` `main()``{``    ``int` `n = 18;``    ``// function call``    ``cout << PositionRightmostSetbit(n);``    ``return` `0;``}`

## Java

 `// Java program to find the``// first rightmost set bit``// using XOR operator` `class` `GFG {` `    ``// function to find``    ``// the rightmost set bit``    ``static` `int` `PositionRightmostSetbit(``int` `n)``    ``{``        ``// Position variable initialize``        ``// with 1 m variable is used to``        ``// check the set bit``        ``int` `position = ``1``;``        ``int` `m = ``1``;` `        ``while` `((n & m) == ``0``) {` `            ``// left shift``            ``m = m << ``1``;``            ``position++;``        ``}``        ``return` `position;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``18``;` `        ``// function call``        ``System.out.println(PositionRightmostSetbit(n));``    ``}``}` `// This code is contributed``// by Smitha`

## Python3

 `# Python3 program to find``# the first rightmost set``# bit using XOR operator` `# function to find the``# rightmost set bit`  `def` `PositionRightmostSetbit(n):` `    ``# Position variable initialize``    ``# with 1 m variable is used``    ``# to check the set bit``    ``position ``=` `1``    ``m ``=` `1` `    ``while` `(``not``(n & m)):` `        ``# left shift``        ``m ``=` `m << ``1``        ``position ``+``=` `1` `    ``return` `position`  `# Driver Code``n ``=` `18` `# function call``print``(PositionRightmostSetbit(n))` `# This code is contributed``# by Smitha`

## C#

 `// C# program to find the``// first rightmost set bit``// using XOR operator``using` `System;` `class` `GFG {` `    ``// function to find``    ``// the rightmost set bit``    ``static` `int` `PositionRightmostSetbit(``int` `n)``    ``{``        ``// Position variable initialize``        ``// with 1 m variable is used to``        ``// check the set bit``        ``int` `position = 1;``        ``int` `m = 1;` `        ``while` `((n & m) == 0) {` `            ``// left shift``            ``m = m << 1;``            ``position++;``        ``}``        ``return` `position;``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``int` `n = 18;` `        ``// function call``        ``Console.WriteLine(PositionRightmostSetbit(n));``    ``}``}` `// This code is contributed``// by @ajit`

## PHP

 ``

## Javascript

 ``

Output

`2`

Time Complexity: O(log2N), Traversing through all the bits of N, where at max there are logN bits.
Auxiliary Space: O(1)

## Position of rightmost set bit using Left Shift(<<):

Follow the steps below to solve the problem:

• Initialize pos with 1
• iterate up to INT_SIZE(Here 32)
• check whether bit is set or not
• if bit is set then break the loop
• else increment the pos.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;``#define INT_SIZE 32` `int` `Right_most_setbit(``int` `num)``{``    ``if` `(num == 0) ``// for num==0 there is zero set bit``    ``{``        ``return` `0;``    ``}``    ``else` `{``        ``int` `pos = 1;``        ``// counting the position of first set bit``        ``for` `(``int` `i = 0; i < INT_SIZE; i++) {``            ``if` `(!(num & (1 << i)))``                ``pos++;``            ``else``                ``break``;``        ``}``        ``return` `pos;``    ``}``}``int` `main()``{``    ``int` `num = 18;``    ``int` `pos = Right_most_setbit(num);``    ``cout << pos << endl;``    ``return` `0;``}``// This approach has been contributed by @yashasvi7`

## Java

 `// Java implementation of above approach``public` `class` `GFG {` `    ``static` `int` `INT_SIZE = ``32``;` `    ``static` `int` `Right_most_setbit(``int` `num)``    ``{``        ``int` `pos = ``1``;``        ``// counting the position of first set bit``        ``for` `(``int` `i = ``0``; i < INT_SIZE; i++) {``            ``if` `((num & (``1` `<< i)) == ``0``)``                ``pos++;` `            ``else``                ``break``;``        ``}``        ``return` `pos;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `num = ``18``;``        ``int` `pos = Right_most_setbit(num);``        ``System.out.println(pos);``    ``}``}`

## Python3

 `# Python 3 implementation of above approach` `INT_SIZE ``=` `32`  `def` `Right_most_setbit(num):` `    ``pos ``=` `1` `    ``# counting the position of first set bit``    ``for` `i ``in` `range``(INT_SIZE):``        ``if` `not``(num & (``1` `<< i)):``            ``pos ``+``=` `1``        ``else``:``            ``break` `    ``return` `pos`  `if` `__name__ ``=``=` `"__main__"``:` `    ``num ``=` `18``    ``pos ``=` `Right_most_setbit(num)``    ``print``(pos)` `# This code is contributed by ANKITRAI1`

## C#

 `// C# implementation of above approach``using` `System;` `class` `GFG {` `    ``static` `int` `INT_SIZE = 32;` `    ``static` `int` `Right_most_setbit(``int` `num)``    ``{``        ``int` `pos = 1;` `        ``// counting the position``        ``// of first set bit``        ``for` `(``int` `i = 0; i < INT_SIZE; i++) {``            ``if` `((num & (1 << i)) == 0)``                ``pos++;` `            ``else``                ``break``;``        ``}``        ``return` `pos;``    ``}` `    ``// Driver code``    ``static` `public` `void` `Main()``    ``{``        ``int` `num = 18;``        ``int` `pos = Right_most_setbit(num);``        ``Console.WriteLine(pos);``    ``}``}`

## PHP

 ``

## Javascript

 ``

Output

```2
```

Time Complexity: O(log2n), Traversing through all the bits of N, where at max there are logN bits.
Auxiliary Space: O(1)

## Position of rightmost set bit using Right Shift(<<):

Follow the steps below to solve the problem:

• Initialize pos=1.
• Iterate till number>0,  at each step check if the last bit is set.
• If last bit is set, return current position
• else increment pos by 1 and right shift n by 1.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Program to find position of``// rightmost set bit``int` `PositionRightmostSetbit(``int` `n)``{``    ``int` `p = 1;` `    ``// Iterate till number>0``    ``while` `(n > 0) {` `        ``// Checking if last bit is set``        ``if` `(n & 1) {``            ``return` `p;``        ``}` `        ``// Increment position and right shift number``        ``p++;``        ``n = n >> 1;``    ``}` `    ``// set bit not found.``    ``return` `-1;``}` `// Driver Code``int` `main()``{``    ``int` `n = 18;` `    ``// Function call``    ``int` `pos = PositionRightmostSetbit(n);` `    ``if` `(pos != -1)``        ``cout << pos;``    ``else``        ``cout << 0;` `    ``return` `0;``}` `// This code is contributed by zishanahmad786`

## Java

 `// Java program for above approach``import` `java.io.*;` `class` `GFG {` `    ``// Function to find position of``    ``// rightmost set bit``    ``public` `static` `int` `Last_set_bit(``int` `n)``    ``{``        ``int` `p = ``1``;` `        ``// Iterate till number>0``        ``while` `(n > ``0``) {` `            ``// Checking if last bit is set``            ``if` `((n & ``1``) > ``0``) {``                ``return` `p;``            ``}` `            ``// Increment position and``            ``// right shift number``            ``p++;``            ``n = n >> ``1``;``        ``}` `        ``// set bit not found.``        ``return` `-``1``;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``18``;` `        ``// Function call``        ``int` `pos = Last_set_bit(n);` `        ``if` `(pos != -``1``)``            ``System.out.println(pos);``        ``else``            ``System.out.println(``"0"``);``    ``}``}` `// This code is contributed by RohitOberoi`

## Python3

 `# Python program for above approach` `# Program to find position of``# rightmost set bit`  `def` `PositionRightmostSetbit(n):``    ``p ``=` `1` `    ``# Iterate till number>0``    ``while``(n > ``0``):` `        ``# Checking if last bit is set``        ``if``(n & ``1``):``            ``return` `p` `        ``# Increment position and right shift number``        ``p ``+``=` `1``        ``n ``=` `n >> ``1` `    ``# set bit not found.``    ``return` `-``1`  `# Driver Code``n ``=` `18``# Function call``pos ``=` `PositionRightmostSetbit(n)``if``(pos !``=` `-``1``):``    ``print``(pos)``else``:``    ``print``(``0``)` `# This code is contributed by rohitsingh07052.`

## C#

 `// C# program for above approach``using` `System;` `class` `GFG {` `    ``// Function to find position of``    ``// rightmost set bit``    ``public` `static` `int` `Last_set_bit(``int` `n)``    ``{``        ``int` `p = 1;` `        ``// Iterate till number>0``        ``while` `(n > 0) {` `            ``// Checking if last bit is set``            ``if` `((n & 1) > 0) {``                ``return` `p;``            ``}` `            ``// Increment position and``            ``// right shift number``            ``p++;``            ``n = n >> 1;``        ``}` `        ``// Set bit not found.``        ``return` `-1;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int` `n = 18;` `        ``// Function call``        ``int` `pos = Last_set_bit(n);` `        ``if` `(pos != -1)``            ``Console.WriteLine(pos);``        ``else``            ``Console.WriteLine(``"0"``);``    ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

## C

 `#include ` `// Function to find position of``// rightmost set bit``int` `Last_set_bit(``int` `n)``{``    ``int` `p = 1;` `    ``// Iterate till number>0``    ``while` `(n > 0) {` `        ``// Checking if last bit is set``        ``if` `((n & 1) > 0) {``            ``return` `p;``        ``}` `        ``// Increment position and``        ``// right shift number``        ``p++;``        ``n = n >> 1;``    ``}` `    ``// set bit not found.``    ``return` `-1;``}` `int` `main(``void``)``{``    ``int` `n = 18;` `    ``// Function call``    ``int` `pos = Last_set_bit(n);` `    ``if` `(pos != -1)``        ``printf``(``"%d\n"``, pos);``    ``else``        ``printf``(``"0\n"``);` `    ``return` `0;``}`

Output

`2`

Time Complexity: O(log2n), Traversing through all the bits of N, where at max there are logN bits.
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up