# Print kth least significant bit number

You have given a number and you have to find out the k^{th} least significant bit of this number. K will be given to you. The bit will be from the number’s binary form.

**Input-** Number = 10, K = 2

**Output-** 1

**Explanation-** If we convert the number to binary then it will be 1010. So, we find the second least significant bit is 1.

**Input-** Number = 2, K = 2

**Output-** 1

**Explanation-** If we convert the number to binary then it will be 11. So, we find the second least significant bit is 1.

**Input-** Number = 8, K = 1

**Output-** 0

**Explanation-** If we convert the number to binary then it will be 1000. So, we find the first least significant bit is 0.

**Input-** Number = 0, K = 1

**Output-** 0

**Explanation-** If we convert the number to binary then it will be 0. So, we find the first least significant bit is 0.

Note:

What is the least significant bit?Every digits of a number can be called as bit. In binary representation of a number, the last digit is least significant because it adds lowest value to the number.

### Algorithm:

**Step 1:** Start

**Step 2:** Two values are taken from the user

**Step 3:** A function is called. This function takes two input values.

**Step 4:** We calculate the value by using bit operator.

**Step 5:** The answer value will be returned.

**Step 6:** The returned value will be printed.

**Step 7:** Stop.

**Explanation of Algorithm**

First we shift the number ‘1’ (K-1) times left using bit operation. This process will give a number with all unset bits but the ‘K’^{th} bit. After that logical AND of the shifted number with given number will be done. All bits except the ‘K’^{th} bit will yield 0, and ‘K’^{th} bit will depend on the number. It happens because, 1 AND 1 is 1. 0 AND 1 is 0.

**Code:**

**Program in C++**

```
// Finding kth least significant bit using C++ program
#include <bits/stdc++.h>
using namespace std;
//The function to check whether set or not
bool LEASTBITFIND(int num, int K)
{
return (num & (1 << (K-1)));
}
//Main function to implement the code
int main()
{
int num = 10, K = 4;
//Calling the other function
cout << LEASTBITFIND(num, K);
return 0;
}
```

**Program in Java**

```
// Finding kth least significant bit using java program
import java .io.*;
class bno {
// The function to check whether set or not
static boolean LEASTBITFIND(int num, int K)
{
boolean x = (num & (1 << (K-1))) != 0;
return (x);
}
// Main function to implement the code
public static void main(String[] args)
{
int num = 10, K = 4;
//Calling the other function
if(LEASTBITFIND(num, K))
System.out.println("1") ;
else
System.out.println("0");
}
}
```

**Program in Python**

```
# Finding kth least significant bit using python program
# The function to check whether set or not
def LEASTBITFIND(num, K):
return bool(num & (1 << (K - 1) ))
# Main function to implement the code
num, k = 10, 4
res = LEASTBITFIND(num, k)
if res :
print(1)
else:
print(0)
```

**Program in C#**

```
// Finding kth least significant bit using c# program
using System;
class bno {
// The function to check whether set or not
static bool LEASTBITFIND(int num, int K)
{
bool x = (num & (1 << (K-1))) != 0;
return (x);
}
// Main function to implement the code
static void Main()
{
int num = 10, K = 4;
//Calling the other function
if(LEASTBITFIND(num, K))
Console.Write("1") ;
else
Console.Write("0");
}
}
<?php
```

**Program in PHP**

```
// Finding kth least significant bit using PHP program
// The function to check whether set or not
function LEASTBITFIND($num, $K)
{
return ($num & (1 << ($K - 1)));
}
// Main function to implement the code
$num = 10;
$K = 4;
$r = LEASTBITFIND($num, $K);
if($r)
echo '1';
else
echo '0';
?>
<script>
```

**Program in JavaScript**

```
// Finding kth least significant bit using JavaScript program
// The function to check whether set or not
function LEASTBITFIND(num, K)
{
let x = (num & (1 << (K-1))) != 0;
return (x);
}
let num = 10, K = 4;
//Calling the other function
if(LEASTBITFIND(num, K))
document.write("1") ;
else
document.write("0");
</script>
```

**Output: **

1

### Complexity Analysis

**Time complexity-** Here, we don’t use any loop or recursion. So, the time complexity will be constant. Complexity will be **O(1).**

**Space complexity-** In this solution, we use constant memory. So, space complexity will be **O(1).**