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++
#include <iostream>
#include <math.h>
using namespace std;
class gfg
{
public :
unsigned int getFirstSetBitPos( int n)
{
return log2(n & -n) + 1;
}
};
int main()
{
gfg g;
int n = 12;
cout << g.getFirstSetBitPos(n);
return 0;
}
|
C
#include <math.h>
#include <stdio.h>
unsigned int getFirstSetBitPos( int n)
{
return log2(n & -n) + 1;
}
int main()
{
int n = 12;
printf ( "%u" , getFirstSetBitPos(n));
getchar ();
return 0;
}
|
Java
class GFG {
public static int getFirstSetBitPos( int n)
{
return ( int )((Math.log10(n & -n)) / Math.log10( 2 )) + 1 ;
}
public static void main(String[] args)
{
int n = 12 ;
System.out.println(getFirstSetBitPos(n));
}
}
|
Python3
import math
def getFirstSetBitPos(n):
return math.log2(n& - n) + 1
n = 12
print ( int (getFirstSetBitPos(n)))
|
C#
using System;
class GFG {
public static int getFirstSetBitPos( int n)
{
return ( int )((Math.Log10(n & -n))
/ Math.Log10(2)) + 1;
}
public static void Main()
{
int n = 12;
Console.WriteLine(getFirstSetBitPos(n));
}
}
|
PHP
<?php
function getFirstSetBitPos( $n )
{
return ceil (log(( $n & -
$n ) + 1, 2));
}
$n = 12;
echo getFirstSetBitPos( $n );
?>
|
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++
#include <bits/stdc++.h>
using namespace std;
int getFirstSetBitPos( int n)
{
return ffs(n);
}
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++
#include <bits/stdc++.h>
using namespace std;
int PositionRightmostSetbit( int n)
{
int position = 1;
int m = 1;
while (!(n & m)) {
m = m << 1;
position++;
}
return position;
}
int main()
{
int n = 16;
cout << PositionRightmostSetbit(n);
return 0;
}
|
Java
class GFG {
static int PositionRightmostSetbit( int n)
{
int position = 1 ;
int m = 1 ;
while ((n & m) == 0 ) {
m = m << 1 ;
position++;
}
return position;
}
public static void main(String[] args)
{
int n = 16 ;
System.out.println(PositionRightmostSetbit(n));
}
}
|
Python3
def PositionRightmostSetbit(n):
position = 1
m = 1
while ( not (n & m)) :
m = m << 1
position + = 1
return position
n = 16
print (PositionRightmostSetbit(n))
|
C#
using System;
class GFG {
static int PositionRightmostSetbit( int n)
{
int position = 1;
int m = 1;
while ((n & m) == 0) {
m = m << 1;
position++;
}
return position;
}
static public void Main()
{
int n = 16;
Console.WriteLine(
PositionRightmostSetbit(n));
}
}
|
PHP
<?php
function PositionRightmostSetbit( $n )
{
$position = 1;
$m = 1;
while (!( $n & $m ))
{
$m = $m << 1;
$position ++;
}
return $position ;
}
$n = 16;
echo PositionRightmostSetbit( $n );
?>
|
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++
#include <iostream>
using namespace std;
#define INT_SIZE 32
int Right_most_setbit( int num)
{
int pos = 1;
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;
}
|
Java
public class GFG {
static int INT_SIZE = 32 ;
static int Right_most_setbit( int num)
{
int pos = 1 ;
for ( int i = 0 ; i < INT_SIZE; i++) {
if ((num & ( 1 << i))== 0 )
pos++;
else
break ;
}
return pos;
}
public static void main(String[] args) {
int num = 18 ;
int pos = Right_most_setbit(num);
System.out.println(pos);
}
}
|
Python3
INT_SIZE = 32
def Right_most_setbit(num) :
pos = 1
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)
|
C#
using System;
class GFG {
static int INT_SIZE = 32;
static int Right_most_setbit( int num)
{
int pos = 1;
for ( int i = 0; i < INT_SIZE; i++)
{
if ((num & (1 << i))== 0)
pos++;
else
break ;
}
return pos;
}
static public void Main ()
{
int num = 18;
int pos = Right_most_setbit(num);
Console.WriteLine(pos);
}
}
|
PHP
<?php
function Right_most_setbit( $num )
{
$pos = 1;
$INT_SIZE = 32;
for ( $i = 0; $i < $INT_SIZE ; $i ++)
{
if (!( $num & (1 << $i )))
$pos ++;
else
break ;
}
return $pos ;
}
$num = 18;
$pos = Right_most_setbit( $num );
echo $pos ;
echo ( "\n" )
?>
|
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++
#include<bits/stdc++.h>
using namespace std;
int PositionRightmostSetbit( int n)
{
int p=1;
while (n > 0)
{
if (n&1){
return p;
}
p++;
n=n>>1;
}
return -1;
}
int main()
{
int n=18;
int pos=Last_set_bit(n);
if (pos!=-1)
cout<<pos;
else
cout<<0;
return 0;
}
|
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.