Invert k most significant bits of number
Here given code implementation process.
// C Program
// Invert k most significant bits of number
#include <stdio.h>
void changeKmostBit(int num, int k)
{
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
int value = (r + 1);
int result = 0;
int bit = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value & num) == 0)
{
result = result + value;
}
bit--;
}
else if ((value & num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value >> 1;
}
printf("\n Number : %d K : %d \n", num, k);
// Display calculated result
printf(" Result : %d\n", result);
}
int main()
{
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
changeKmostBit(7, 1);
return 0;
}Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3/*
Java Program
Invert k most significant bits of number
*/
public class BitManipulation
{
public void changeKmostBit(int num, int k)
{
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
int value = (r + 1);
int result = 0;
int bit = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value & num) == 0)
{
result = result + value;
}
bit--;
}
else if ((value & num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value >> 1;
}
System.out.println("\n Number : " + num + " K : " + k);
// Display calculated result
System.out.println(" Result : " + result);
}
public static void main(String[] args)
{
BitManipulation task = new BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task.changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task.changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task.changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task.changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task.changeKmostBit(7, 1);
}
}Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3// Include header file
#include <iostream>
using namespace std;
/*
C++ Program
Invert k most significant bits of number
*/
class BitManipulation
{
public: void changeKmostBit(int num, int k)
{
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
int value = (r + 1);
int result = 0;
int bit = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value &num) == 0)
{
result = result + value;
}
bit--;
}
else if ((value &num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value >> 1;
}
cout << "\n Number : "
<< num << " K : "
<< k << endl;
// Display calculated result
cout << " Result : "
<< result << endl;
}
};
int main()
{
BitManipulation *task = new BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task->changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task->changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task->changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task->changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task->changeKmostBit(7, 1);
return 0;
}Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3// Include namespace system
using System;
/*
Csharp Program
Invert k most significant bits of number
*/
public class BitManipulation
{
public void changeKmostBit(int num, int k)
{
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
int value = (r + 1);
int result = 0;
int bit = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value & num) == 0)
{
result = result + value;
}
bit--;
}
else if ((value & num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value >> 1;
}
Console.WriteLine("\n Number : " + num + " K : " + k);
// Display calculated result
Console.WriteLine(" Result : " + result);
}
public static void Main(String[] args)
{
BitManipulation task = new BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task.changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task.changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task.changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task.changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task.changeKmostBit(7, 1);
}
}Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3package main
import "fmt"
/*
Go Program
Invert k most significant bits of number
*/
type BitManipulation struct {}
func getBitManipulation() * BitManipulation {
var me *BitManipulation = &BitManipulation {}
return me
}
func(this BitManipulation) changeKmostBit(num, k int) {
if num <= 0 || k < 1 {
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)
// Find most significant set bit
var value int = (r + 1)
var result int = 0
var bit int = k
for (value > 0) {
if bit > 0 {
// When need to change bits
if (value & num) == 0 {
result = result + value
}
bit--
} else if (value & num) == value {
// Collect the value of remaining active bits
result = result + value
}
value = value >> 1
}
fmt.Println("\n Number : ", num, " K : ", k)
// Display calculated result
fmt.Println(" Result : ", result)
}
func main() {
var task * BitManipulation = getBitManipulation()
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task.changeKmostBit(321, 4)
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task.changeKmostBit(616, 6)
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task.changeKmostBit(54, 2)
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task.changeKmostBit(9, 4)
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task.changeKmostBit(7, 1)
}Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3<?php
/*
Php Program
Invert k most significant bits of number
*/
class BitManipulation
{
public function changeKmostBit($num, $k)
{
if ($num <= 0 || $k < 1)
{
return;
}
$r = $num >> 1;
$r = $r | ($r >> 1);
$r = $r | ($r >> 2);
$r = $r | ($r >> 4);
$r = $r | ($r >> 8);
$r = $r | ($r >> 16);
// Find most significant set bit
$value = ($r + 1);
$result = 0;
$bit = $k;
while ($value > 0)
{
if ($bit > 0)
{
// When need to change bits
if (($value & $num) == 0)
{
$result = $result + $value;
}
$bit--;
}
else if (($value & $num) == $value)
{
// Collect the value of remaining active bits
$result = $result + $value;
}
$value = $value >> 1;
}
echo("\n Number : ".$num.
" K : ".$k.
"\n");
// Display calculated result
echo(" Result : ".$result.
"\n");
}
}
function main()
{
$task = new BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
$task->changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
$task->changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
$task->changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
$task->changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
$task->changeKmostBit(7, 1);
}
main();Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3/*
Node JS Program
Invert k most significant bits of number
*/
class BitManipulation
{
changeKmostBit(num, k)
{
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
var value = (r + 1);
var result = 0;
var bit = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value & num) == 0)
{
result = result + value;
}
bit--;
}
else if ((value & num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value >> 1;
}
console.log("\n Number : " + num + " K : " + k);
// Display calculated result
console.log(" Result : " + result);
}
}
function main()
{
var task = new BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task.changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task.changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task.changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task.changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task.changeKmostBit(7, 1);
}
main();Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3# Python 3 Program
# Invert k most significant bits of number
class BitManipulation :
def changeKmostBit(self, num, k) :
if (num <= 0 or k < 1) :
return
r = num >> 1
r = r | (r >> 1)
r = r | (r >> 2)
r = r | (r >> 4)
r = r | (r >> 8)
r = r | (r >> 16)
# Find most significant set bit
value = (r + 1)
result = 0
bit = k
while (value > 0) :
if (bit > 0) :
# When need to change bits
if ((value & num) == 0) :
result = result + value
bit -= 1
elif ((value & num) == value) :
# Collect the value of remaining active bits
result = result + value
value = value >> 1
print("\n Number : ", num ," K : ", k)
# Display calculated result
print(" Result : ", result)
def main() :
task = BitManipulation()
# Test A
# num = 321 k = 4
# 321 = (101000001)
# ↑↑↑↑ Change bits
# ---------------------
# 010100001)
# Result : 161
task.changeKmostBit(321, 4)
# Test B
# (616) = (1001101000) k = 6
# ↑↑↑↑↑↑ Change bits
# 0110011000
# ---------------------
# Result : 408
task.changeKmostBit(616, 6)
# Test C
# (54) = (110110) k = 2
# ↑↑ Change bits
# 000110
# ---------------------
# Result : 6
task.changeKmostBit(54, 2)
# Test D
# 9 = (1001) k = 4
# ↑↑↑↑ Change bits
# 0110
# ---------------------
# Result : 6
task.changeKmostBit(9, 4)
# Test E
# 7 = (111) k = 1
# ↑ Change bits
# 011
# ---------------------
# Result : 3
task.changeKmostBit(7, 1)
if __name__ == "__main__": main()Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3# Ruby Program
# Invert k most significant bits of number
class BitManipulation
def changeKmostBit(num, k)
if (num <= 0 || k < 1)
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)
# Find most significant set bit
value = (r + 1)
result = 0
bit = k
while (value > 0)
if (bit > 0)
# When need to change bits
if ((value & num) == 0)
result = result + value
end
bit -= 1
elsif ((value & num) == value)
# Collect the value of remaining active bits
result = result + value
end
value = value >> 1
end
print("\n Number : ", num ," K : ", k, "\n")
# Display calculated result
print(" Result : ", result, "\n")
end
end
def main()
task = BitManipulation.new()
# Test A
# num = 321 k = 4
# 321 = (101000001)
# ↑↑↑↑ Change bits
# ---------------------
# 010100001)
# Result : 161
task.changeKmostBit(321, 4)
# Test B
# (616) = (1001101000) k = 6
# ↑↑↑↑↑↑ Change bits
# 0110011000
# ---------------------
# Result : 408
task.changeKmostBit(616, 6)
# Test C
# (54) = (110110) k = 2
# ↑↑ Change bits
# 000110
# ---------------------
# Result : 6
task.changeKmostBit(54, 2)
# Test D
# 9 = (1001) k = 4
# ↑↑↑↑ Change bits
# 0110
# ---------------------
# Result : 6
task.changeKmostBit(9, 4)
# Test E
# 7 = (111) k = 1
# ↑ Change bits
# 011
# ---------------------
# Result : 3
task.changeKmostBit(7, 1)
end
main()Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3
/*
Scala Program
Invert k most significant bits of number
*/
class BitManipulation()
{
def changeKmostBit(num: Int, k: Int): Unit = {
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
var value: Int = (r + 1);
var result: Int = 0;
var bit: Int = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value & num) == 0)
{
result = result + value;
}
bit -= 1;
}
else if ((value & num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value >> 1;
}
println("\n Number : " + num + " K : " + k);
// Display calculated result
println(" Result : " + result);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: BitManipulation = new BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task.changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task.changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task.changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task.changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task.changeKmostBit(7, 1);
}
}Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3/*
Swift 4 Program
Invert k most significant bits of number
*/
class BitManipulation
{
func changeKmostBit(_ num: Int, _ k: Int)
{
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
var value: Int = (r + 1);
var result: Int = 0;
var bit: Int = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value & num) == 0)
{
result = result + value;
}
bit -= 1;
}
else if ((value & num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value >> 1;
}
print("\n Number : ", num ," K : ", k);
// Display calculated result
print(" Result : ", result);
}
}
func main()
{
let task: BitManipulation = BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task.changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task.changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task.changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task.changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task.changeKmostBit(7, 1);
}
main();Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3/*
Kotlin Program
Invert k most significant bits of number
*/
class BitManipulation
{
fun changeKmostBit(num: Int, k: Int): Unit
{
if (num <= 0 || k < 1)
{
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);
// Find most significant set bit
var value: Int = (r + 1);
var result: Int = 0;
var bit: Int = k;
while (value > 0)
{
if (bit > 0)
{
// When need to change bits
if ((value and num) == 0)
{
result = result + value;
}
bit -= 1;
}
else if ((value and num) == value)
{
// Collect the value of remaining active bits
result = result + value;
}
value = value shr 1;
}
println("\n Number : " + num + " K : " + k);
// Display calculated result
println(" Result : " + result);
}
}
fun main(args: Array < String > ): Unit
{
val task: BitManipulation = BitManipulation();
// Test A
// num = 321 k = 4
// 321 = (101000001)
// ↑↑↑↑ Change bits
// ---------------------
// 010100001)
// Result : 161
task.changeKmostBit(321, 4);
// Test B
// (616) = (1001101000) k = 6
// ↑↑↑↑↑↑ Change bits
// 0110011000
// ---------------------
// Result : 408
task.changeKmostBit(616, 6);
// Test C
// (54) = (110110) k = 2
// ↑↑ Change bits
// 000110
// ---------------------
// Result : 6
task.changeKmostBit(54, 2);
// Test D
// 9 = (1001) k = 4
// ↑↑↑↑ Change bits
// 0110
// ---------------------
// Result : 6
task.changeKmostBit(9, 4);
// Test E
// 7 = (111) k = 1
// ↑ Change bits
// 011
// ---------------------
// Result : 3
task.changeKmostBit(7, 1);
}Output
Number : 321 K : 4
Result : 161
Number : 616 K : 6
Result : 408
Number : 54 K : 2
Result : 6
Number : 9 K : 4
Result : 6
Number : 7 K : 1
Result : 3
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.
New Comment