Bitwise Operations in C/C++: Testing Bit Subsets in Arrays

I recently had a question about bitwise operations in C or C++ and turned to Grok, an AI assistant from xAI, for help. Here’s how our conversation unfolded, with some neat solutions for testing bit patterns across variables and arrays.

Part 1: Testing Two Unsigned Chars

I started by asking: "In C or C++, given two unsigned char variables, say X1 and X2, is there one of the bit handling operators that you could use to test that all bits that are set in X1 would be set in X2?"

Grok explained that you can use the bitwise AND operator (`&`) combined with a comparison. The trick is to check if `X1 & X2` equals `X1`. If it does, all bits set in `X1` are also set in `X2`. Here’s the logic:

• The `&` operator performs a bitwise AND, setting a bit in the result only if it’s set in both `X1` and `X2`.
• If `X1 & X2 == X1`, then every bit set in `X1` must be set in `X2`.
• If any bit in `X1` is not set in `X2`, the result differs from `X1`, and the test fails.

Grok provided this example:

#include <stdio.h>

int main() {
    unsigned char X1 = 0b00001101; // 13 in decimal
    unsigned char X2 = 0b00011101; // 29 in decimal

    if ((X1 & X2) == X1) {
        printf("All bits set in X1 are set in X2\n");
    } else {
        printf("Not all bits set in X1 are set in X2\n");
    }

    return 0;
}

<p>In this case, `X1 & X2 = 0b00001101`, which matches `X1`, so the test passes. Simple and elegant!</p>
<h2>Part 2: Scaling to Arrays</h2>
<p>Next, I asked: "Suppose I had two arrays of 100 unsigned char and wanted to test if all of the bits set in the one were also set in the other... I could loop through the 100 pairs as you describe and kick out of the loop at the first test to fail... But, is there a faster way to do that, possibly with a single command and not the loop?"</p>
<p>Grok agreed that a loop would work but offered faster alternatives by processing multiple bytes at once. Here are the two main approaches:</p>
<h3>Option 1: Process in 64-Bit Chunks</h3>
<p>By treating the arrays as blocks of memory and casting them to `uint64_t` (64-bit integers), you can check 8 bytes at a time. This reduces the 100 iterations to just 13 (12 chunks of 8 bytes plus 4 leftovers). Here’s the code:</p>
c