Position of rightmost set bit - GeeksforGeeks

10 May, 2022
Write a one-line function to return the position of the first 1 from right to left, in the binary representation of an Integer. 
I/P    18,   Binary Representation 010010
O/P   2
I/P    19,   Binary Representation 010011
O/P   1
Algorithm: (Example 12(1100))Let I/P be 12 (1100)1. Take two’s complement of the given no as all bits are revertedexcept the first ‘1’ from right to left (0100)2  Do a bit-wise & with original no, this will return no with therequired one only (0100)3  Take the log2 of the no, you will get (position – 1) (2)4  Add 1 (3)
Explanation –
(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 you, 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....We will find that position of rightmost set bit is always equal to log2(Number)+1
Program: 
C++
C
Java
Python3
C#
PHP
Javascript
// C++ program for Position// of rightmost set bit#include <iostream>#include <math.h>using namespace std; class gfg{ public:unsigned int getFirstSetBitPos(int n){    return log2(n & -n) + 1;}}; // Driver codeint main(){    gfg g;    int n = 12;    cout << g.getFirstSetBitPos(n);    return 0;} // This code is contributed by SoM15242
// C program for Position// of rightmost set bit#include <math.h>#include <stdio.h> unsigned int getFirstSetBitPos(int n){    return log2(n & -n) + 1;} // Driver codeint main(){    int n = 12;    printf("%u", getFirstSetBitPos(n));    getchar();    return 0;}
// Java Code for Position of rightmost set bitclass 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 = 12;        System.out.println(getFirstSetBitPos(n));    }}// This code is contributed by Arnav Kr. Mandal
# Python Code for Position# of rightmost set bit import math def getFirstSetBitPos(n):      return math.log2(n&-n)+1 # driver code n = 12print(int(getFirstSetBitPos(n))) # This code is contributed# by Anant Agarwal.
// C# Code for Position of rightmost set bitusing 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 = 12;        Console.WriteLine(getFirstSetBitPos(n));    }} // This code is contributed by Sam007
<?php// PHP Code for Position of// rightmost set bit function getFirstSetBitPos($n){    return ceil(log(($n& -                     $n) + 1, 2));} // Driver Code$n = 12;echo getFirstSetBitPos($n);     // This code is contributed by m_kit?>
<script>// JavaScript program for Position// of rightmost set bit function getFirstSetBitPos(n){    return Math.log2(n & -n) + 1;} // Driver code    let g;    let n = 12;    document.write(getFirstSetBitPos(n)); // This code is contributed by Manoj.</script>
3
Time Complexity: O(log2n)Auxiliary Space: O(1)
Using ffs() function: ffs() function returns the index of first least significant set bit. The indexing starts in ffs() function from 1. For example: n = 12 = 1100 
In the above example, ffs(n) returns the rightmost set bit index which is 3. 
C++
Java
Python3
C#
Javascript
// C++ program to find the// position of first rightmost// set bit in a given number.#include <bits/stdc++.h>using namespace std; // Function to find rightmost// set bit in given number.int getFirstSetBitPos(int n){    return ffs(n);} // Driver functionint main(){    int n = 12;    cout << getFirstSetBitPos(n) << endl;    return 0;}
// Java program  to find the// position of first rightmost// set bit in a given numberimport 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 codepublic static void main(String[] args){    int n = 12;    System.out.print( getFirstSetBitPos(n));         }} // This code is contributed by sanjoy_62.
# Python3 program to find the# position of first rightmost# set bit in a given numberimport math # Function to find rightmost# set bit in given number.def getFirstSetBitPos(n):         return int(math.log2 (n & -n) + 1) # Driver Codeif __name__ == '__main__':         n = 12    print(getFirstSetBitPos(n)) # This code is contributed by nirajgusain5.
// C# program program to find the// position of first rightmost// set bit in a given numberusing 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 codepublic static void Main(String[] args){    int n = 12;    Console.Write( getFirstSetBitPos(n));         }} // This code is contributed by 29AjayKumar
<script> // Javascript program to find the// position of first rightmost// set bit in a given number // Function to find rightmost// set bit in given number.function getFirstSetBitPos(n){    return Math.log2(n & -n) + 1;} // Driver Code         let n = 12;    document.write( getFirstSetBitPos(n)); </script>
3
Time Complexity: O(log2n)Auxiliary Space: O(1)
Using XOR and & operator : 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. 
C++
Java
Python3
C#
PHP
Javascript
// C++ program to find the first// rightmost set bit using XOR operator#include <bits/stdc++.h>using namespace std; // function to find the rightmost set bitint 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 Codeint main(){    int n = 16;    // function call    cout << PositionRightmostSetbit(n);    return 0;}
// 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 = 16;         // function call        System.out.println(PositionRightmostSetbit(n));    }} // This code is contributed// by Smitha
# Python3 program to find# the first rightmost set# bit using XOR operator # function to find the# rightmost set bitdef 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 Coden = 16 # function callprint(PositionRightmostSetbit(n)) # This code is contributed# by Smitha
// C# program to find the// first rightmost set bit// using XOR operatorusing 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 = 16;         // function call        Console.WriteLine(            PositionRightmostSetbit(n));    }} // This code is contributed// by @ajit
<?php// PHP program to find the// first rightmost set bit// using XOR operator // function to find the// rightmost set bitfunction PositionRightmostSetbit($n){    // Position variable initialize    // with 1 m variable is used to    // check the set bit    $position = 1;    $m = 1;     while (!($n & $m))    {         // left shift        $m = $m << 1;        $position++;    }    return $position;} // Driver Code$n = 16; // function callecho PositionRightmostSetbit($n);     // This code is contributed by ajit?>
<script>     // Javascript program to find the first    // rightmost set bit using XOR operator     // function to find the rightmost set bit    function PositionRightmostSetbit(n)    {             // Position variable initialize with 1        // m variable is used to check the set bit        let position = 1;        let m = 1;         while ((n & m) == 0) {             // left shift            m = m << 1;            position++;        }        return position;    }     let n = 16;         // function call    document.write(PositionRightmostSetbit(n));         // This code is contributed by divyesh072019.</script>
5
Time Complexity: O(log2n)Auxiliary Space: O(1)
This approach has been contributed by mubashshir ahmad
Using Left Shift (<<) : Initialize pos with 1, iterate up to INT_SIZE(Here 32) and check whether bit is set or not, if bit is set then break the loop, else increment the pos.  
C++
Java
Python3
C#
PHP
Javascript
// C++ implementation of above approach#include <iostream>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 = 0;    int pos = Right_most_setbit(num);    cout << pos << endl;    return 0;}// This approach has been contributed by @yashasvi7
//Java implementation of above approachpublic 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);    }}  
# 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# implementation of above approachusing 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// PHP implementation of above approach function Right_most_setbit($num){    $pos = 1;    $INT_SIZE = 32;         // counting the position    // of first set bit    for ($i = 0; $i < $INT_SIZE; $i++)    {        if (!($num & (1 << $i)))            $pos++;        else            break;    }    return $pos;} // Driver code$num = 18;$pos = Right_most_setbit($num);echo $pos;echo ("\n") // This code is contributed// by Shivi_Aggarwal?>
<script> // Javascript implementation of above approachlet INT_SIZE = 32; function Right_most_setbit(num){    let pos = 1;         // Counting the position of first set bit    for(let i = 0; i < INT_SIZE; i++)    {        if ((num & (1 << i)) == 0)            pos++;        else            break;    }    return pos;} // Driver codelet num = 18;let pos = Right_most_setbit(num); document.write(pos); // This code is contributed by mukesh07 </script>
Output :  
 2
Time Complexity: O(1)Auxiliary Space: O(1)
Another Method Using right Shift(>>):
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.
C++
Java
Python3
C#
Javascript
// C++ program for above approach#include<bits/stdc++.h>using namespace std; // Program to find position of// rightmost set bitint 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 Codeint main(){  int n=18;     // Function call  int pos=Last_set_bit(n);   if(pos!=-1)    cout<<pos;  else    cout<<0;   return 0;}
// Java program for above approachimport java.io.*; class GFG{     // Function to find position of// rightmost set bitpublic 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 Codepublic 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
# Python program for above approach # Program to find position of# rightmost set bitdef 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 Coden = 18# Function callpos = PositionRightmostSetbit(n)if(pos != -1):  print(pos)else:  print(0) # This code is contributed by rohitsingh07052.
// C# program for above approachusing System; class GFG{     // Function to find position of// rightmost set bitpublic 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 Codepublic 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
<script> // Javascript program for above approach // Program to find position of// rightmost set bitfunction Last_set_bit(n){    let 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 codelet n = 18; // Function calllet pos = Last_set_bit(n); if (pos != -1){    document.write(pos);}else{    document.write(0);}     // This code is contributed by divyeshrabadiya07 </script>
2
Time Complexity: O(log2n)Auxiliary Space: O(1)
Mannuyou
Smitha Dinesh Semwal
jit_t
vivek kumar 9
ankthon
ukasp
Shivi_Aggarwal
SoumikMondal
arupjyoti_dutta
SaranshSharma
kagranir1970
RohitOberoi
divyesh072019
mukesh07
divyeshrabadiya07
mank1083
abhishekpal463
rohitsingh07052
yashasvi7
susmitakundugoaldanga
nirajgusain5
sanjoy_62
29AjayKumar
rishavmahato348
subham348
rohanthakurarmy
sweetyty
Amazon
Bit Magic
Amazon
Bit Magic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Little and Big Endian Mystery
Cyclic Redundancy Check and Modulo-2 Division
Binary representation of a given number
Program to find whether a given number is power of 2
Add two numbers without using arithmetic operators
Josephus problem | Set 1 (A O(n) Solution)
Bit Fields in C
Find the element that appears once
Bits manipulation (Important tactics)
Set, Clear and Toggle a given bit of a number in C