Skip to content
Related Articles

Related Articles

Improve Article

Position of rightmost set bit

  • Difficulty Level : Medium
  • Last Updated : 09 Jun, 2021

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

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 rightmost set bit as 1.

if N = 12 (1100) then it will return 4 (100)



Here log2 will return you, number of times we can express that number in power of two.

For all binary number containing only rightmost set bit as 1 like 2 , 4, 8, 16, 32….

We will find that position of right most set bit is always equals 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 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

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

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

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

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

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

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=Last_set_bit(n);
 
  if(pos!=-1)
    cout<<pos;
  else
    cout<<0;
 
  return 0;
}

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :