Position of rightmost set bit

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

I/P    18,   Binary Representation 010010
O/P   2
I/P    19,   Binary Representation 010011
O/P   1

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Algorithm: (Example 18(010010))
Let I/P be 12 (1100)

1. Take two's complement of the given no as all bits are reverted
except the first '1' from right to left (10111)

2  Do an bit-wise & with original no, this will return no with the
required one only (00010)

3  Take the log2 of the no, you will get position -1 (1)

4  Add 1 (2)

Program:

C++

// 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 code 
int main() 
{ 
    gfg g; 
    int n = 12; 
    cout << g.getFirstSetBitPos(n); 
    return 0; 
} 
  
// This code is contributed by SoM15242 

C

// 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 code 
int main() 
{ 
    int n = 12; 
    printf("%u", getFirstSetBitPos(n)); 
    getchar(); 
    return 0; 
} 

Java

// Java Code for Position of rightmost set bit 
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 = 12; 
        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 = 12
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 = 12; 
        Console.WriteLine(getFirstSetBitPos(n)); 
    } 
} 
  
// This code is contributed by Sam007 

PHP

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

Output:

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 above example, ffs(n) returns the rightmost set bit index which is 3.

C++

// 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 function 
int main() 
{ 
    int n = 12; 
    cout << getFirstSetBitPos(n) << endl; 
    return 0; 
} 

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

// 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 bit 
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)) { 
  
        // left shift 
        m = m << 1; 
        position++; 
    } 
    return position; 
} 
// Driver Code 
int main() 
{ 
    int n = 16; 
    // 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 = 16; 
  
        // 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 = 16
  
# 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 = 16; 
  
        // function call 
        Console.WriteLine( 
            PositionRightmostSetbit(n)); 
    } 
} 
  
// This code is contributed 
// by @ajit 

PHP

<?php 
// PHP 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 
    $position = 1; 
    $m = 1; 
  
    while (!($n & $m))  
    { 
  
        // left shift 
        $m = $m << 1; 
        $position++; 
    } 
    return $position; 
} 
  
// Driver Code 
$n = 16; 
  
// function call 
echo PositionRightmostSetbit($n); 
      
// This code is contributed by ajit 
?> 

Output:

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

// C++ implementation of above approach 
#include <iostream> 
using namespace std; 
#define INT_SIZE 32 
  
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))) 
            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 @vivek kumar9 

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

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