# Remove the most significant set bit of a number

Here given code implementation process.

``````// C Program
// Remove the most significant set bit of a number
#include <stdio.h>

// Remove a most significant bit of given number
void removeSignificantBit(int num)
{
if (num <= 0)
{
return;
}
int r = num >> 1;
r = r | (r >> 1);
r = r | (r >> 2);
r = r | (r >> 4);
r = r | (r >> 8);
r = r | (r >> 16);
// Remove most significant bit
int value = r & num;
// Display calculated result
printf(" Number : %d \n", num);
printf(" Result : %d \n", value);
}
int main()
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
removeSignificantBit(320);
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
removeSignificantBit(1000);
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
removeSignificantBit(54);
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
removeSignificantBit(5);
return 0;
}``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````/*
Java Program
Remove the most significant set bit of a number
*/
public class SignificantBit
{
// Remove a most significant bit of given number
public void removeSignificantBit(int num)
{
if (num <= 0)
{
return;
}
int r = num >> 1;
r = r | (r >> 1);
r = r | (r >> 2);
r = r | (r >> 4);
r = r | (r >> 8);
r = r | (r >> 16);
// Remove most significant bit
int value = r & num;
// Display calculated result
System.out.print(" Number : " + num + " \n");
System.out.print(" Result : " + value + " \n");
}
public static void main(String[] args)
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}
}``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````// Include header file
#include <iostream>

using namespace std;
/*
C++ Program
Remove the most significant set bit of a number
*/
class SignificantBit
{
public:
// Remove a most significant bit of given number
void removeSignificantBit(int num)
{
if (num <= 0)
{
return;
}
int r = num >> 1;
r = r | (r >> 1);
r = r | (r >> 2);
r = r | (r >> 4);
r = r | (r >> 8);
r = r | (r >> 16);
// Remove most significant bit
int value = r #
// Display calculated result
cout << " Number : " << num << " \n";
cout << " Result : " << value << " \n";
}
};
int main()
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
return 0;
}``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````// Include namespace system
using System;
/*
Csharp Program
Remove the most significant set bit of a number
*/
public class SignificantBit
{
// Remove a most significant bit of given number
public void removeSignificantBit(int num)
{
if (num <= 0)
{
return;
}
int r = num >> 1;
r = r | (r >> 1);
r = r | (r >> 2);
r = r | (r >> 4);
r = r | (r >> 8);
r = r | (r >> 16);
// Remove most significant bit
int value = r & num;
// Display calculated result
Console.Write(" Number : " + num + " \n");
Console.Write(" Result : " + value + " \n");
}
public static void Main(String[] args)
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}
}``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````package main
import "fmt"
/*
Go Program
Remove the most significant set bit of a number
*/
type SignificantBit struct {}
func getSignificantBit() * SignificantBit {
var me *SignificantBit = &SignificantBit {}
return me
}
// Remove a most significant bit of given number
func(this SignificantBit) removeSignificantBit(num int) {
if num <= 0 {
return
}
var r int = num >> 1
r = r | (r >> 1)
r = r | (r >> 2)
r = r | (r >> 4)
r = r | (r >> 8)
r = r | (r >> 16)
// Remove most significant bit
var value int = r & num
// Display calculated result
fmt.Print(" Number : ", num, " \n")
fmt.Print(" Result : ", value, " \n")
}
func main() {
var task * SignificantBit = getSignificantBit()
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````<?php
/*
Php Program
Remove the most significant set bit of a number
*/
class SignificantBit
{
// Remove a most significant bit of given number
public	function removeSignificantBit(\$num)
{
if (\$num <= 0)
{
return;
}
\$r = \$num >> 1;
\$r = \$r | (\$r >> 1);
\$r = \$r | (\$r >> 2);
\$r = \$r | (\$r >> 4);
\$r = \$r | (\$r >> 8);
\$r = \$r | (\$r >> 16);
// Remove most significant bit
\$value = \$r & \$num;
// Display calculated result
echo(" Number : ".\$num.
" \n");
echo(" Result : ".\$value.
" \n");
}
}

function main()
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}
main();``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````/*
Node JS Program
Remove the most significant set bit of a number
*/
class SignificantBit
{
// Remove a most significant bit of given number
removeSignificantBit(num)
{
if (num <= 0)
{
return;
}
var r = num >> 1;
r = r | (r >> 1);
r = r | (r >> 2);
r = r | (r >> 4);
r = r | (r >> 8);
r = r | (r >> 16);
// Remove most significant bit
var value = r & num;
// Display calculated result
process.stdout.write(" Number : " + num + " \n");
process.stdout.write(" Result : " + value + " \n");
}
}

function main()
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}
main();``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````#    Python 3 Program
#    Remove the most significant set bit of a number
class SignificantBit :
#  Remove a most significant bit of given number
def removeSignificantBit(self, num) :
if (num <= 0) :
return

r = num >> 1
r = r | (r >> 1)
r = r | (r >> 2)
r = r | (r >> 4)
r = r | (r >> 8)
r = r | (r >> 16)
#  Remove most significant bit
value = r & num
#  Display calculated result
print(" Number : ", num ," ")
print(" Result : ", value ," ")

def main() :
#  Test A
#  320 = (101000000)
#  Remove ↑
#  ---------------------
#           1000000)
#  Result : 64
#  Test B
#  (1000) = (1111101000)
#   Remove   ↑
#             111101000
#  ---------------------
#  Result : 488
#  Test C
#  (54) = (110110)
#  Remove  ↑
#           10110
#  ---------------------
#  Result : 22
#  Test D
#  5    = (101)
#  Remove  ↑
#           01
#  ---------------------
#  Result : 1

if __name__ == "__main__": main()``````

#### Output

`````` Number :  320
Result :  64
Number :  1000
Result :  488
Number :  54
Result :  22
Number :  5
Result :  1``````
``````#    Ruby Program
#    Remove the most significant set bit of a number
class SignificantBit
#  Remove a most significant bit of given number
def removeSignificantBit(num)
if (num <= 0)
return
end

r = num >> 1
r = r | (r >> 1)
r = r | (r >> 2)
r = r | (r >> 4)
r = r | (r >> 8)
r = r | (r >> 16)
#  Remove most significant bit
value = r & num
#  Display calculated result
print(" Number : ", num ," \n")
print(" Result : ", value ," \n")
end

end

def main()
#  Test A
#  320 = (101000000)
#  Remove ↑
#  ---------------------
#           1000000)
#  Result : 64
#  Test B
#  (1000) = (1111101000)
#   Remove   ↑
#             111101000
#  ---------------------
#  Result : 488
#  Test C
#  (54) = (110110)
#  Remove  ↑
#           10110
#  ---------------------
#  Result : 22
#  Test D
#  5    = (101)
#  Remove  ↑
#           01
#  ---------------------
#  Result : 1
end

main()``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1
``````
``````/*
Scala Program
Remove the most significant set bit of a number
*/
class SignificantBit()
{
// Remove a most significant bit of given number
def removeSignificantBit(num: Int): Unit = {
if (num <= 0)
{
return;
}
var r: Int = num >> 1;
r = r | (r >> 1);
r = r | (r >> 2);
r = r | (r >> 4);
r = r | (r >> 8);
r = r | (r >> 16);
// Remove most significant bit
var value: Int = r & num;
// Display calculated result
print(" Number : " + num + " \n");
print(" Result : " + value + " \n");
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: SignificantBit = new SignificantBit();
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}
}``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````
``````/*
Swift 4 Program
Remove the most significant set bit of a number
*/
class SignificantBit
{
// Remove a most significant bit of given number
func removeSignificantBit(_ num: Int)
{
if (num <= 0)
{
return;
}
var r: Int = num >> 1;
r = r | (r >> 1);
r = r | (r >> 2);
r = r | (r >> 4);
r = r | (r >> 8);
r = r | (r >> 16);
// Remove most significant bit
let value: Int = r & num;
// Display calculated result
print(" Number : ", num );
print(" Result : ", value );
}
}
func main()
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}
main();``````

#### Output

`````` Number :  320
Result :  64
Number :  1000
Result :  488
Number :  54
Result :  22
Number :  5
Result :  1``````
``````/*
Kotlin Program
Remove the most significant set bit of a number
*/
class SignificantBit
{
// Remove a most significant bit of given number
fun removeSignificantBit(num: Int): Unit
{
if (num <= 0)
{
return;
}
var r: Int = num shr 1;
r = r or(r shr 1);
r = r or(r shr 2);
r = r or(r shr 4);
r = r or(r shr 8);
r = r or(r shr 16);
// Remove most significant bit
val value: Int = r and num;
// Display calculated result
print(" Number : " + num + " \n");
print(" Result : " + value + " \n");
}
}
fun main(args: Array < String > ): Unit
{
// Test A
// 320 = (101000000)
// Remove ↑
// ---------------------
//          1000000)
// Result : 64
// Test B
// (1000) = (1111101000)
//  Remove   ↑
//            111101000
// ---------------------
// Result : 488
// Test C
// (54) = (110110)
// Remove  ↑
//          10110
// ---------------------
// Result : 22
// Test D
// 5    = (101)
// Remove  ↑
//          01
// ---------------------
// Result : 1
}``````

#### Output

`````` Number : 320
Result : 64
Number : 1000
Result : 488
Number : 54
Result : 22
Number : 5
Result : 1``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.