Implement Binary Counting Method to Generate Subsets in C++

The subsets of a set refers to all the possible combinations of choosing elements from the set. For example, if we have a set {1, 2}, the subsets are {}, {1}, {2}, and {1, 2}. In this article, we will learn how to generate subsets of a set using the Binary Counting Method in C++.

// Set of elements
int arr[] = {1, 2, 3};

// Subsets of the above set
{}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}

Binary Counting Method

The binary counting method is a technique used to generate all subsets of a set by using binary numbers. For a set of size n, there are 2ⁿ possible subsets. The idea behind this method is that, each subset maps to a binary number of n bits, where each bit represents whether a particular element is included (1) or excluded (0) in that subset.

To understand this better, let's consider a simple example. Suppose we have a set:

Set = {A, B, C}

Since the set has 3 elements, there are 2³ = 8 possible subsets. These 8 subsets correspond to the binary numbers from 000 to 111. Here's how each binary number maps to a subset:

You can read the binary numbers from left to right, in this way:

• The first bit (leftmost) maps to the first element A.
• The second bit maps to the second element B.
• The third bit (rightmost) maps to the third element C.

Meaning, if the bit is 1, that element is included in the subset. If it is 0, the element is not included.

Steps to Implement Binary Counting Method to Generate Subsets

To implement the Binary Counting Method to generate subsets of a set, follow these steps:

• Step 1: Take the set elements and number of elements in the set as input.
• Step 2: Calculate the total number of subsets using the formula 2ⁿ, where n is the number of elements in the set.
• Step 3: Use a loop with index i to iterate from 0 to 2ⁿ - 1. The binary value of each 'i' represents a subset.
• Step 4: Now use a 'j' loop (nested loop inside the 'i' loop) and iterate from 0 to n - 1 to check each bit of the binary representation of 'i'.
• Step 5: Check if the j-th bit in i is set using the expression (i & (1 << j)) != 0. If it is set, include the j-th element in the current subset.
• Step 6: Print the current subset.

C++ Code to Implement Binary Counting Method to Generate Subsets

Here is a C++ code that implements the Binary Counting Method to generate subsets of a set:

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

void generateSubsets(const vector<char>& set) {
    int n = set.size();
    int totalSubsets = 1 << n; // 2^n subsets

    for (int i = 0; i < totalSubsets; ++i) {
        cout << "{ ";
        for (int j = 0; j < n; ++j) {
            // Check if j-th bit is set in i
            if (i & (1 << j)) {
                cout << set[j] << " ";
            }
        }
        cout << "}" << endl;
    }
}

int main() {
    int n=3;
    vector<char> set = {'A', 'B', 'C'}; 

    cout << "The set is: { ";
    for (int i = 0; i < n; ++i) {
        cout << set[i] << " ";
    }
    cout << "}" << endl;

    cout << "Generating subsets using Binary Counting Method:" << endl;

    generateSubsets(set);
    return 0;
}

The output of the above code will be:

The set is: { A B C }
Generating subsets using Binary Counting Method:
{ }
{ A }
{ B }
{ A B }
{ C }
{ A C }
{ B C }
{ A B C }

Time and Space Complexity

Time Complexity: The time complexity of the Binary Counting Method to generate subsets is O(n * 2^n), where n is the number of elements in the set. This is because we have to iterate through all 2^n possible subsets, and for each subset, we may need to check all n elements to see if they are included.

Space Complexity: The space complexity is O(n), as we need to store the current subset being generated.