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


 

 

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)


Program: 
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output



3

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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

//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);
    }
}  

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
    }
}

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output

2

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

filter_none

edit
close

play_arrow

link
brightness_4
code

//CPP 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;
}

chevron_right


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.




My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :


18


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.