Given an integer n, Return the position of the first set bit from right to left in the binary representation n. If no set bits present , then return 0.
Note: Position of rightmost bit is 1.
Examples:
Input: n = 18
Output: 2
Explanation: Binary representation of 18 is 10010, hence position of first set bit from right is 2.Input: n = 19
Output: 1
Explanation: Binary representation of 19 is 10011, hence position of first set bit from right is 1.
Try It Yourself
Table of Content
Using 2's complement and log Operator - O(log n) time and O(1) space
The idea is to find the rightmost set bit using a property of 2's complement arithmetic. When we perform n & (~n + 1) or equivalently n & (-n), we get a number with only the rightmost set bit of n. Then we can use log2 to find its position.
#include <iostream>
#include <cmath>
using namespace std;
int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
// Get the rightmost set bit
int res = n & (~n + 1);
// Find position using log2
return log2(res) + 1;
}
int main() {
int n = 18;
cout << getFirstSetBit(n);
return 0;
}
import java.lang.Math;
class GfG {
static int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
// Get the rightmost set bit
int res = n & (~n + 1);
// Find position using log2
return (int)(Math.log(res) / Math.log(2)) + 1;
}
public static void main(String[] args) {
int n = 18;
System.out.println(getFirstSetBit(n));
}
}
import math
def getFirstSetBit(n):
# If no set bit
if n == 0:
return 0
# Get the rightmost set bit
res = n & (~n + 1)
# Find position using log2
return int(math.log2(res)) + 1
if __name__ == "__main__":
n = 18
print(getFirstSetBit(n))
using System;
class GfG {
static uint getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
// Get the rightmost set bit
int res = n & (~n + 1);
// Find position using log2
return (uint)(Math.Log(res) / Math.Log(2)) + 1;
}
static void Main() {
int n = 18;
Console.WriteLine(getFirstSetBit(n));
}
}
function getFirstSetBit(n) {
// If no set bit
if (n === 0) return 0;
// Get the rightmost set bit
let res = n & (~n + 1);
// Find position using log2
return Math.log2(res) + 1;
}
//Driver Code
let n = 18;
console.log(getFirstSetBit(n));
Output
2
Using left shift operator - O(1) time and O(1) space
The idea is to use a counter and iteratively left-shift 1 to check each bit position. Increment a position counter until we find a bit that is set.
#include <iostream>
using namespace std;
int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
int pos = 1;
// Left shift a mask and check each bit
while ((n & (1 << (pos - 1))) == 0) {
pos++;
}
return pos;
}
int main() {
int n = 18;
cout << getFirstSetBit(n);
return 0;
}
class GFG {
static int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
int pos = 1;
// Left shift a mask and check each bit
while ((n & (1 << (pos - 1))) == 0) {
pos++;
}
return pos;
}
public static void main(String[] args) {
int n = 18;
System.out.println(getFirstSetBit(n));
}
}
def getFirstSetBit(n):
# If no set bit
if n == 0:
return 0
pos = 1
# Left shift a mask and check each bit
while (n & (1 << (pos - 1))) == 0:
pos += 1
return pos
n = 18
print(getFirstSetBit(n))
using System;
class GFG {
static int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
int pos = 1;
// Left shift a mask and check each bit
while ((n & (1 << (pos - 1))) == 0) {
pos++;
}
return pos;
static void Main() {
int n = 18;
Console.WriteLine(getFirstSetBit(n));
}
}
function getFirstSetBit(n) {
// If no set bit
if (n === 0) return 0;
let pos = 1;
// Left shift a mask and check each bit
while ((n & (1 << (pos - 1))) === 0) {
pos++;
}
return pos;
}
let n = 18;
console.log(getFirstSetBit(n));
Output
2
Using right shift operator - O(1) time and O(1) space
The idea is to right-shift the number and check the least significant bit in each iteration. Increment a position counter until we find a bit that is set.
#include <bits/stdc++.h>
using namespace std;
int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
int res = 1;
// Right shift and check LSB
while (!(n & 1)) {
n = n >> 1;
res++;
}
return res;
}
int main() {
int n = 18;
cout << getFirstSetBit(n);
return 0;
}
// Java program to find the position of right most
// set bit in an integer.
class GfG {
static int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
int res = 1;
// Right shift and check LSB
while ((n & 1) == 0) {
n = n >> 1;
res++;
}
return res;
}
public static void main(String[] args) {
int n = 18;
System.out.println(getFirstSetBit(n));
}
}
def getFirstSetBit(n):
# If no set bit
if n == 0:
return 0
res = 1
# Right shift and check LSB
while (n & 1) == 0:
n = n >> 1
res += 1
return res
if __name__ == "__main__":
n = 18
print(getFirstSetBit(n))
using System;
class GfG {
static uint getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
uint res = 1;
// Right shift and check LSB
while ((n & 1) == 0) {
n = n >> 1;
res++;
}
return res;
}
static void Main() {
int n = 18;
Console.WriteLine(getFirstSetBit(n));
}
}
function getFirstSetBit(n) {
// If no set bit
if (n === 0) return 0;
let res = 1;
// Right shift and check LSB
while ((n & 1) === 0) {
n = n >> 1;
res++;
}
return res;
}
let n = 18;
console.log(getFirstSetBit(n));
Output
2
Using Built-In Library Functions - O(1) time and O(1) space
#include <bits/stdc++.h>
using namespace std;
int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
return __builtin_ffs(n);
}
int main() {
int n = 18;
cout << getFirstSetBit(n);
return 0;
}
// Java program to find the position of right most
// set bit in an integer.
class GfG {
static int getFirstSetBit(int n) {
// If no set bit
if (n == 0) return 0;
return Integer.numberOfTrailingZeros(n) + 1;
}
public static void main(String[] args) {
int n = 18;
System.out.println(getFirstSetBit(n));
}
}
# Python program to find the position of right most
# set bit in an integer.
def getFirstSetBit(n):
# If no set bit
if n == 0:
return 0
return (n & -n).bit_length()
if __name__ == "__main__":
n = 18
print(getFirstSetBit(n))
Output
2