查找无符号整数中的某些位模式

Question

I am reviewing for an exam and have a practice problem that I'm stuck on.

I need to write the function find_sequence(unsigned int num, unsigned int patter) {}.

I have tried comparing num & (pattern << i) == (pattern << i) and other things like that but it keeps saying there is a pattern when there isn't. I see why it is doing that but I can not fix it.

The num I'm using is unsigned int a = 82937 and I'm searching for pattern unsigned int b = 0x05 .

Pattern:         00000000000000000000000000000101
Original bitmap: 00000000000000010100001111111001

The code so far:

int find_sequence(unsigned int num, unsigned int pattern)
{
        for (int i=0; i<32; i++)
        {
                if ((num & (pattern << i)) == (pattern << i))
                {
                        return i;
                }
        }

        return -9999;
}

int
main()
{
    unsigned int a = 82937;
    unsigned int b = 0x05;

    printf("Pattern: ");
    printBits(b);
    printf("\n");

    printf("Original bitmap: ");
    printBits(a);
    printf("\n");

    int test = find_sequence(a, b);
    printf("%d\n", test);

    return 0;
}

Here is what I have so far. This keeps returning 3, and I see why but I do not know how to avoid it.

Answer 1

    for (int i=0; i<32; i++)
    {
            if ((num & (pattern << i)) == (pattern << i))

is bad: - it works only when pattern consists of 1 entirely - you generate at the end of the loop pattern << 31 which is 0 when pattern is even. Condition will hold every time then.

Knowing the length of the pattern would simplify the loop above; just go until 32 - size . When not given by the API, the length can be calculated either by a clz() function or manually by looping over the bits.

Now, you can generate the mask as mask = (1u << length) - 1u (note: you have to handle the length == 32 case in a special way) and write

for (int i=0; i < (32 - length); i++)
{
        if ((num & (mask << i)) == (pattern << i))

or

for (int i=0; i < (32 - length); i++)
{
        if (((num >> i) & mask) == pattern)

Answer 2

((num & (pattern << i)) == (pattern << i)) won't give you the desire results.

Let's say you pattern is 0b101 and the value is 0b1111 , then

   0101   pattern
   1111   value
 & ----
   0101   pattern

Even though the value has not the pattern 0b101 , the check would return true.

You've got to create a mask where all bits of the pattern (until the most significant bit) are 1 and the rest are 0. So for the pattern 0b101 the mask must be b111 .

So first you need to calculate the position of the most significant bit of the pattern, then create the mask and then you can apply (bitwise AND) the mask to the value. If the result is the same as the pattern, then you've found your pattern:

int find_sequence(unsigned int num, unsigned int pattern)
{
    unsigned int copy = pattern;

    // checking edge cases
    if(num == 0 && pattern == 0)
        return 0;

    if(num == 0)
        return -1;

    // calculating msb of pattern
    int msb = -1;
    while(copy)
    {
        msb++;
        copy >>= 1;
    }

    printf("msb of pattern at pos: %d\n", msb);

    // creating mask
    unsigned int mask = (1U << msb + 1) - 1;

    int pos = 0;
    while(num)
    {

        if((num & mask) == pattern)
            return pos;

        num >>= 1;
        pos++;
    }

    return -1;
}

Using this function I get the value 14, where your 0b101 pattern is found in a .

Answer 3

In this case you could make a bitmask that 0's out all the spaces you aren't looking for so in this case

Pattern: 00000000000000000000000000000101

Bitmask: 00000000000000000000000000000111

So in the case of the number you are looking at

Original: 00000000000000010100001111111001

If you and that with this bitmask you end of with

Number after &: 00000000000000000000000000000001

And compare the new number with your pattern to see if equal.

Then >> the original number

Original: 00000000000000010100001111111001

Right shifted: 00000000000000001010000111111100

And repeat the & and compare to check the next 3 numbers in the sequence.