如何使用按位运算符实现模式2 ^ n-1

Question

While programming with bitwise operations I had a doubt. That is,in my project at one point of time I need to set bits like this, if I type '1' it means the 1st bit is set. If I type '2' it means the first 2 bits are set.

So,

1-1 2-11 3-111 4-1111

Likewise it goes. From this I analyze the following pattern.That is 1-1,11-3,111-7,1111-15.

That is 2^1-1=1,2^2-1=3,2^3-1=7,...

Now I need to write bitwise operations for this format in a single Line.

Any help is appreciated.

Answer 1

So far we've had "the main two answers" that you usually get to this question. They're different in their edge conditions. Assuming 32bit unsigned integers to take something common, the (1u<<n)-1 answer can handle 0 through 31, and the 0xFFFFFFFF>>(32-n) answer can handle 1 through 32.

A question that often arises then is, can we have 0 through 32?

And you can, but naturally it is more complicated, especially if you don't accept conditionals. The full range is easy to make by combining either approach with a ternary operator, but without that, there are still ways.

Note that n=32 is the only case in which the bit 0b00100000 is set in n .

So one thing we can do is extract that bit, invert it, and shift it left (being careful not to execute an undefined shift), like this:

((n >> 5 ^ 1) << (n & 31)) - 1

Now if n < 32 , it simplifies to the old (1u << n) - 1 . If n == 32 , it simplifies to (0 << irrelevant) - 1 , where irrelevant happens to be 0 but we could have chosen anything from 0 through 31.

In some languages (notably C# and Java), shifting by the width of an integer or more is defined and the & 31 can be removed. In some assembly languages, for example PowerPC, shifting by the width of an integer results in 0, in that case the assembly level equivalent of (1u << n) - 1 would work as-is.

In other assembly languages there may be other tricks, often using special instructions that have no direct equivalent in high level languages. For example on x86 with BMI1:

or rax, -1
shl ecx, 8
bextr rax, rax, rcx

Or on x86 with BMI2:

or rax, -1
bzhi rax, rax, rcx

Answer 2

1 << n gives 2 ^ n , so you may need this one for 2 ^ n - 1 :

static inline unsigned int test(int n)
{
    return (1u << n) - 1;
}

Answer 3

With an unsigned int (let's say 32 bits), you can get the value from bitcount as follows:

value = 0xffffffffU >> (32-bitcount);

For example, let's use a bitcount of 3:

  0xffffffff >> (32-bitcount)
= 0xffffffff >> 29
= 0x00000007

The following program shows this in action:

#include <stdio.h>

int cvt (int bc) {
    return 0xffffffffU >> (32-bc);
}

int main (void) {
    for (int bc = 1; bc <= 32; bc++)
        printf ("%2d: 0x%08x %u\n", bc, cvt (bc), cvt (bc));
    return 0;
}

The output of that program shows that each subsequent bitcount adds one more 1-bit on the right:

 1: 0x00000001 1
 2: 0x00000003 3
 3: 0x00000007 7
 4: 0x0000000f 15
 5: 0x0000001f 31
 6: 0x0000003f 63
 7: 0x0000007f 127
 8: 0x000000ff 255
 9: 0x000001ff 511
10: 0x000003ff 1023
11: 0x000007ff 2047
12: 0x00000fff 4095
13: 0x00001fff 8191
14: 0x00003fff 16383
:
30: 0x3fffffff 1073741823
31: 0x7fffffff 2147483647
32: 0xffffffff 4294967295