Print k^th least significant bit of a number

Least significant number

As we know, each number can be represented in the form of digits, and the number format can be anything like binary, decimal, hexadecimal, octal, etc. If we represent the number in the form of bits, then the leftmost digit is called a most significant bit, and the rightmost digit is called a least significant bit.

As we know, the leftmost bit has a higher value as it is multiplied with the highest power of its base value, so it has the most significance in determining the value.

The rightmost digit is multiplied with zero power of base value, so it has the most minor contribution in the calculation of value. That is why it is called the least significant bit (LSB).

For example:

Let's take the number 12, so in the binary format; we can represent 12 in the form of 0s and 1s.

So binary representation of 12 will be: 1100

And the most significant bit of 12 is one, and the least significant bit is 0.

Now, we can find any least significant bit if we have binary representation on any number.

Method 1:

We will be given a number in integer and a number representing k. So, if we want a k^th least significant bit, then we will simply get the binary representation of that particular number and store it into an array, then from the right-hand side k^th element of the array will represent the k^th least significant bit.

Java Code:

Import java.io.*;
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scn = new Scanner(System.in);
        int n=scn.nextInt();
        
        int k=scn.nextInt();
        int[] bits=new int[32];
        getBinaryBits(n,bits);
        System.out.println(bits[32-k]);
    }
    
    public static void getBinaryBits(int n,int[] bits){
        
        int idx=31;
        while(n>0){
            bits[idx--]=n%2;
            n=n/2;
        }
        
    }
}

Output:

Print kth least significant bit of a number

Explanation

In the above, we used an array of size 32 to store the binary representation of a number n. The function 'getBinaryBits' will store the binary representing the number in binary format using the division method.

For example, we take n=27 and k=2.

So 27 in binary representation would like that:

So k=2 means that the 2nd least significant bit is one that is present at the second last index.

In the above code, we use extra space to store the bits, so time and space complexity would be O(32) which is nearly constant.

Method 2:

Another approach is that we will shift the bits to the right k-1 times.

As we know, each time when we shift an element, the least significant bit disappears, so by doing this operation k-1 times, we will remove the first k-1 bits from the left side, and the bit at the right most position would represent our least significant bit.

Now to determine if the bit is 1 or 0, we will check if the number is even. Then, the bit at the right-most is 0. Otherwise, it is 1.

Java Code:

import java.io.*;
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scn = new Scanner(System.in);
        int n=scn.nextInt();
        
        int k=scn.nextInt();
        for(int i=1;i<=k-1;i++){
            n=n>>1;
        }
        if(n%2==0)
        System.out.println(0);
        else
        System.out.println(1);
    }
}

The time complexity of the above code would be O(K), and the space complexity would be O(1).

Method 3:

This approach says that we will get the number where the k^th bit will be one and the other bits will be zero. Now, if that number is bitwise AND with n, and if the result is zero, then it represents that the k^th bit of n is zero. Otherwise, the k^th bit of n is one.

To get the number that has the k^th set bit and the other bit is zero, we will shift the 1 (k-1) times left.

Java code:

import java.io.*;
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scn = new Scanner(System.in);
        int n=scn.nextInt();
        
        int k=scn.nextInt();
        int prodNum=1<<(k-1); 
        int result= n&prodNum;
        if(result==0)
        System.out.println(0);
        else
        System.out.println(1);
    }
}

Explanation:

Let's take n=16, and k=3, so we will rotate 1 (k-1), or we can say two times left.