Skip to content
Related Articles

Related Articles

Position of rightmost set bit

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 08 Jun, 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
Recommended Practice
Find first set bit
Try It!

Algorithm: (Example 12(1100))
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 (0100)
2  Do a bit-wise & with original no, this will return no with the
required 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++ 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
?>
Javascript



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



// 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;
}
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 = 12;
    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 = 12
    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 = 12;
    Console.Write( getFirstSetBitPos(n));
         
}
}
 
// This code is contributed by 29AjayKumar
Javascript



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



// 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)
{
      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 = 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
?>
Javascript



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



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



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



<script>
 
// Javascript implementation of above approach
let 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 code
let num = 18;
let pos = Right_most_setbit(num);
 
document.write(pos);
 
// This code is contributed by mukesh07
 
</script>
Output :  
 2
Time Complexity: O(log2n)
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++



// C++ program for above approach
#include<bits/stdc++.h>
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



<script>
 
// Javascript program for above approach
 
// Program to find position of
// rightmost set bit
function 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 code
let n = 18;
 
// Function call
let pos = Last_set_bit(n);
 
if (pos != -1)
{
    document.write(pos);
}
else
{
    document.write(0);
}
     
// This code is contributed by divyeshrabadiya07
 
</script>
Output
2
Time Complexity: O(log2n)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Find most significant set bit of a number
Next

Position of rightmost different bit
Recommended Articles
Page :
Find array elements with rightmost set bit at the position of the rightmost set bit in K
09, Feb 21
Position of rightmost bit with first carry in sum of two binary
22, Dec 17
Position of rightmost common bit in two numbers
08, Sep 17
Get the position of rightmost unset bit
13, Jul 17
Position of rightmost different bit
29, Jun 17
Turn off the rightmost set bit | Set 2
27, Apr 20
Rank the array according to rightmost set bit and least set bits
23, Jan 22
Set the rightmost unset bit
05, Jun 18
Set the rightmost off bit
13, Oct 18
Number formed by flipping all bits to the left of rightmost set bit
19, Jun 20
Count numbers up to N whose rightmost set bit is K
25, Dec 20
Number formed by the rightmost set bit in N
08, Jul 19
Turn off the rightmost set bit
02, Jul 10
Set the rightmost unset bit
01, Jul 17
Inserting M into N such that m starts at bit j and ends at bit i | Set-2
29, Aug 18
Minimum bit flips such that every K consecutive bits contain at least one set bit
11, Jun 20
Count bases which contains a set bit as the Most Significant Bit in the representation of N
18, Jun 21
Position of leftmost set bit in given binary string where all 1s appear at end
09, Feb 22
Position of the K-th set bit in a number
13, Mar 19
Find position of the only set bit
30, Mar 13
Check whether the bit at given position is set or unset
30, Dec 17
Print leftmost and rightmost nodes of a Binary Tree
09, Apr 16
Inserting m into n such that m starts at bit j and ends at bit i.
11, May 17
Find X in range [1, N] of bit size A[i] such that X^2's bit size is not present in Array
16, Mar 22
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!