Posted on by Kalkicode
Code Bit Logic

# Count the number of active and inactive bits of a number

The problem we're addressing is to count the number of active (set) and inactive (unset) bits in the binary representation of a given number. We want to determine how many bits are set to 1 and how many are set to 0 in the binary form of the number. This problem involves bitwise operations to analyze the individual bits of the number.

## Problem Statement and Description

Given an integer `num`, the task is to count the number of active (set) and inactive (unset) bits in its binary representation. We need to perform bitwise operations to examine each bit of the number and count how many of them are set to 1 and how many are set to 0.

## Example

Consider the number 17. In binary form, it is represented as 10001. This number contains 2 active bits (set to 1) and 3 inactive bits (set to 0). Therefore, the expected output for this example should be:

• Active Bits: 2
• Inactive Bits: 3

## Idea to Solve the Problem

The primary idea to solve this problem is to use bitwise operations to iterate through the bits of the given number. We'll use the bitwise AND operation to check whether a specific bit is set to 1 or not. Based on the result, we'll update the counters for active and inactive bits.

## Pseudocode

Here's the pseudocode for the algorithm:

``````function countSetUnsetBit(num):
if num < 0:
return

print "Number: ", num
activeBit = 0
inActiveBit = 0

while num > 0:
if num & 1 == 1:
activeBit += 1
else:
inActiveBit += 1
num = num >> 1

print "Active Bits: ", activeBit
print "Inactive Bits: ", inActiveBit``````

## Algorithm Explanation

1. The function `countSetUnsetBit(num)` takes an integer `num` as input.
2. It checks if the given number is negative (`num < 0`). If it is, the function returns without processing.
3. The function prints the given number.
4. It initializes two counters: `activeBit` for counting active bits (set to 1) and `inActiveBit` for counting inactive bits (set to 0).
5. The function enters a loop that continues until the number becomes 0.
6. In each iteration of the loop, it uses the bitwise AND operation `(num & 1)` to check whether the least significant bit of the number is set to 1.
7. If the result of the AND operation is 1, it means the bit is active (set to 1), and the `activeBit` counter is incremented. Otherwise, the `inActiveBit` counter is incremented.
8. The number is right-shifted by one position (`num = num >> 1`) to process the next bit in the next iteration.
9. After the loop completes, the counters `activeBit` and `inActiveBit` will contain the respective counts of active and inactive bits.
10. The function prints the results.

## Code Solution

``````// C Program
// Count the number of active and inactive bits of a number
#include <stdio.h>

// Count the number of set and unset bits of a number
void countSetUnsetBit(int num)
{
if(num < 0)
{
return;
}
// Display given number
printf("\n Number : %d",num);

int activeBit = 0;
int inActiveBit = 0;

while(num > 0)
{
if(num & 1==1)
{
activeBit++;
}
else
{
inActiveBit++;
}
num = num >> 1;
}
// Display calculated result
printf("\n Active Bits : %d",activeBit);
printf("\n Inactive Bits : %d\n",inActiveBit);
}
int main(int argc, char const *argv[])
{

// Test Cases
// 17 (10001)
countSetUnsetBit(17);
// 34 (100010)
countSetUnsetBit(34);
// 1 (1)
countSetUnsetBit(1);
// 7 (111)
countSetUnsetBit(7);
// 21 (10101)
countSetUnsetBit(21);
return 0;
}``````

#### Output

`````` Number : 17
Active Bits : 2
Inactive Bits : 3

Number : 34
Active Bits : 2
Inactive Bits : 4

Number : 1
Active Bits : 1
Inactive Bits : 0

Number : 7
Active Bits : 3
Inactive Bits : 0

Number : 21
Active Bits : 3
Inactive Bits : 2``````
``````/*
Java Program
Count the number of active and inactive bits of a number
*/
public class BitCounting
{
// Count the number of set and unset bits of a number
public void countSetUnsetBit(int num)
{
if (num < 0)
{
return;
}
// Display given number
System.out.print("\n Number : " + num );
int activeBit = 0;
int inActiveBit = 0;
while (num > 0)
{
if ((num & 1) == 1)
{
activeBit++;
}
else
{
inActiveBit++;
}
num = num >> 1;
}
// Display calculated result
System.out.print("\n Active Bits   : " + activeBit );
System.out.print("\n Inactive Bits : " + inActiveBit + "\n");
}
public static void main(String[] args)
{
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
}
}``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2``````
``````// Include header file
#include <iostream>

using namespace std;
/*
C++ Program
Count the number of active and inactive bits of a number
*/
class BitCounting
{
public:
// Count the number of set and unset bits of a number
void countSetUnsetBit(int num)
{
if (num < 0)
{
return;
}
// Display given number
cout << "\n Number : " << num;
int activeBit = 0;
int inActiveBit = 0;
while (num > 0)
{
if ((num &1) == 1)
{
activeBit++;
}
else
{
inActiveBit++;
}
num = num >> 1;
}
// Display calculated result
cout << "\n Active Bits   : " << activeBit;
cout << "\n Inactive Bits : " << inActiveBit << "\n";
}
};
int main()
{
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
return 0;
}``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2``````
``````// Include namespace system
using System;
/*
C# Program
Count the number of active and inactive bits of a number
*/
public class BitCounting
{
// Count the number of set and unset bits of a number
public void countSetUnsetBit(int num)
{
if (num < 0)
{
return;
}
// Display given number
Console.Write("\n Number : " + num);
int activeBit = 0;
int inActiveBit = 0;
while (num > 0)
{
if ((num & 1) == 1)
{
activeBit++;
}
else
{
inActiveBit++;
}
num = num >> 1;
}
// Display calculated result
Console.Write("\n Active Bits   : " + activeBit);
Console.Write("\n Inactive Bits : " + inActiveBit + "\n");
}
public static void Main(String[] args)
{
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
}
}``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2``````
``````<?php
/*
Php Program
Count the number of active and inactive bits of a number
*/
class BitCounting
{
// Count the number of set and unset bits of a number
public	function countSetUnsetBit(\$num)
{
if (\$num < 0)
{
return;
}
// Display given number
echo "\n Number : ". \$num;
\$activeBit = 0;
\$inActiveBit = 0;
while (\$num > 0)
{
if ((\$num & 1) == 1)
{
\$activeBit++;
}
else
{
\$inActiveBit++;
}
\$num = \$num >> 1;
}
// Display calculated result
echo "\n Active Bits   : ". \$activeBit;
echo "\n Inactive Bits : ". \$inActiveBit ."\n";
}
}

function main()
{
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
}
main();``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2``````
``````/*
Node Js Program
Count the number of active and inactive bits of a number
*/
class BitCounting
{
// Count the number of set and unset bits of a number
countSetUnsetBit(num)
{
if (num < 0)
{
return;
}
// Display given number
process.stdout.write("\n Number : " + num);
var activeBit = 0;
var inActiveBit = 0;
while (num > 0)
{
if ((num & 1) == 1)
{
activeBit++;
}
else
{
inActiveBit++;
}
num = num >> 1;
}
// Display calculated result
process.stdout.write("\n Active Bits   : " + activeBit);
process.stdout.write("\n Inactive Bits : " + inActiveBit + "\n");
}
}

function main()
{
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
}
main();``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2``````
``````#   Python 3 Program
#   Count the number of active and inactive bits of a number

class BitCounting :
#  Count the number of set and unset bits of a number
def countSetUnsetBit(self, num) :
if (num < 0) :
return

#  Display given number
print("\n Number : ", num, end = "")
activeBit = 0
inActiveBit = 0
while (num > 0) :
if ((num & 1) == 1) :
activeBit += 1
else :
inActiveBit += 1

num = num >> 1

#  Display calculated result
print("\n Active Bits   : ", activeBit, end = "")
print("\n Inactive Bits : ", inActiveBit )

def main() :
#  Test Cases
#  17 (10001)
#  34 (100010)
#  1 (1)
#  7 (111)
#  21 (10101)

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

#### Output

`````` Number :  17
Active Bits   :  2
Inactive Bits :  3

Number :  34
Active Bits   :  2
Inactive Bits :  4

Number :  1
Active Bits   :  1
Inactive Bits :  0

Number :  7
Active Bits   :  3
Inactive Bits :  0

Number :  21
Active Bits   :  3
Inactive Bits :  2``````
``````#   Ruby Program
#   Count the number of active and inactive bits of a number

class BitCounting
#  Count the number of set and unset bits of a number
def countSetUnsetBit(num)
if (num < 0)
return
end

#  Display given number
print("\n Number : ", num)
activeBit = 0
inActiveBit = 0
while (num > 0)
if ((num & 1) == 1)
activeBit += 1
else
inActiveBit += 1
end

num = num >> 1
end

#  Display calculated result
print("\n Active Bits   : ", activeBit)
print("\n Inactive Bits : ", inActiveBit ,"\n")
end

end

def main()
#  Test Cases
#  17 (10001)
#  34 (100010)
#  1 (1)
#  7 (111)
#  21 (10101)
end

main()``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2
``````
``````/*
Scala Program
Count the number of active and inactive bits of a number
*/
class BitCounting
{
// Count the number of set and unset bits of a number
def countSetUnsetBit(n: Int): Unit = {
var num = n;
if (num < 0)
{
return;
}
// Display given number
print("\n Number : " + num);
var activeBit: Int = 0;
var inActiveBit: Int = 0;
while (num > 0)
{
if ((num & 1) == 1)
{
activeBit += 1;
}
else
{
inActiveBit += 1;
}
num = num >> 1;
}
// Display calculated result
print("\n Active Bits   : " + activeBit);
print("\n Inactive Bits : " + inActiveBit + "\n");
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: BitCounting = new BitCounting();
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
}
}``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2``````
``````/*
Swift 4 Program
Count the number of active and inactive bits of a number
*/
class BitCounting
{
// Count the number of set and unset bits of a number
func countSetUnsetBit(_ n: Int)
{
var num = n;
if (num < 0)
{
return;
}
// Display given number
print("\n Number : ", num, terminator: "");
var activeBit: Int = 0;
var inActiveBit: Int = 0;
while (num > 0)
{
if ((num & 1) == 1)
{
activeBit += 1;
}
else
{
inActiveBit += 1;
}
num = num >> 1;
}
// Display calculated result
print("\n Active Bits   : ", activeBit, terminator: "");
print("\n Inactive Bits : ", inActiveBit );
}
}
func main()
{
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
}
main();``````

#### Output

`````` Number :  17
Active Bits   :  2
Inactive Bits :  3

Number :  34
Active Bits   :  2
Inactive Bits :  4

Number :  1
Active Bits   :  1
Inactive Bits :  0

Number :  7
Active Bits   :  3
Inactive Bits :  0

Number :  21
Active Bits   :  3
Inactive Bits :  2``````
``````/*
Kotlin Program
Count the number of active and inactive bits of a number
*/
class BitCounting
{
// Count the number of set and unset bits of a number
fun countSetUnsetBit(n: Int): Unit
{
var num = n;
if (num < 0)
{
return;
}
// Display given number
print("\n Number : " + num);
var activeBit: Int = 0;
var inActiveBit: Int = 0;
while (num > 0)
{
if ((num and 1) == 1)
{
activeBit += 1;
}
else
{
inActiveBit += 1;
}
num = num shr 1;
}
// Display calculated result
print("\n Active Bits   : " + activeBit);
print("\n Inactive Bits : " + inActiveBit + "\n");
}
}
fun main(args: Array <String> ): Unit
{
// Test Cases
// 17 (10001)
// 34 (100010)
// 1 (1)
// 7 (111)
// 21 (10101)
}``````

#### Output

`````` Number : 17
Active Bits   : 2
Inactive Bits : 3

Number : 34
Active Bits   : 2
Inactive Bits : 4

Number : 1
Active Bits   : 1
Inactive Bits : 0

Number : 7
Active Bits   : 3
Inactive Bits : 0

Number : 21
Active Bits   : 3
Inactive Bits : 2``````

## Resultant Output Explanation

For the given code and the provided test cases, let's break down the output:

1. For the number 17:

• Binary representation: 10001
• Active bits: 2 (bit positions 0 and 4)
• Inactive bits: 3 (bit positions 1, 2, and 3)
• The output is "Number: 17\nActive Bits: 2\nInactive Bits: 3".
2. For the number 34:

• Binary representation: 100010
• Active bits: 2 (bit positions 1 and 5)
• Inactive bits: 4 (bit positions 0, 2, 3, and 4)
• The output is "Number: 34\nActive Bits: 2\nInactive Bits: 4".
3. For the number 1:

• Binary representation: 1
• Active bits: 1 (bit position 0)
• Inactive bits: 0
• The output is "Number: 1\nActive Bits: 1\nInactive Bits: 0".
4. For the number 7:

• Binary representation: 111
• Active bits: 3 (bit positions 0, 1, and 2)
• Inactive bits: 0
• The output is "Number: 7\nActive Bits: 3\nInactive Bits: 0".
5. For the number 21:

• Binary representation: 10101
• Active bits: 3 (bit positions 0, 2, and 4)
• Inactive bits: 2 (bit positions 1 and 3)
• The output is "Number: 21\nActive Bits: 3\nInactive Bits: 2".

## Time Complexity

The time complexity of this algorithm is proportional to the number of bits in the binary representation of the input number. In the worst case, where all bits of the number are considered, the time complexity is O(log n), where `n` is the value of the input number.

## 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.

Categories
Relative Post