有没有一种优雅而又快速的方法来测试整数中的1位是否在连续区域中？

我需要测试位值1的位置（对于32位整数，从0到31）是否形成连续区域。例如：

00111111000000000000000000000000      is contiguous
00111111000000000000000011000000      is not contiguous

我希望此测试（即某些功能has_contiguous_one_bits(int)）具有可移植性。

一种明显的方法是遍历位置以找到第一个置位，然后找到第一个非置位并检查是否还有其他置位。

我想知道是否存在更快的方法？如果有快速的方法来找到最高和最低的设置位（但是从这个问题看来似乎没有任何可移植的位），那么可能的实现方法是

bool has_contiguous_one_bits(int val)
{
    auto h = highest_set_bit(val);
    auto l = lowest_set_bit(val);
    return val == (((1 << (h-l+1))-1)<<l);
}

只是为了好玩，这是带有连续位的前100个整数：

0 1 2 3 4 6 7 8 12 14 15 16 24 28 30 31 32 48 56 60 62 63 64 96 112 120 124 126 127 128 192 224 240 248 252 254 255 256 384 448 480 496 504 508 510 511 512 768 896 960 992 1008 1016 1020 1022 1023 1024 1536 1792 1920 1984 2016 2032 2040 2044 2046 2047 2048 3072 3584 3840 3968 4032 4064 4080 4088 4092 4094 4095 4096 6144 7168 7680 7936 8064 8128 8160 8176 8184 8188 8190 8191 8192 12288 14336 15360 15872 16128 16256 16320

它们（当然）是(1<<m)*(1<<n-1)带有非负m和的形式n。

static _Bool IsCompact(unsigned x)
{
    return (x & x + (x & -x)) == 0;
}

简要地：

x & -x给出设置的最低位x（如果为零，x则为零）。

x + (x & -x) 将连续的1的最低字符串转换为单个1（或换为零）。

x & x + (x & -x) 清除那些1位。

(x & x + (x & -x)) == 0 测试是否还有其他1位剩余。

更长：

-x等于~x+1，使用我们假设的二进制补码。将位翻转后~x，加1进位，以便将低1位~x和后0位翻转回去，然后停止。因此，-x直到并包括其前1的低位与的低位相同x，但所有高位均被翻转。（示例：~10011100gives01100011和加1得到01100100，所以低位100相同，但是高位10011被翻转到01100。）然后x & -x给我们两个位中唯一的一位，即最低的1位（00000100）。（如果x为零，x & -x则为零。）

将其加到x会导致所有连续的1进位，将其更改为0。它将在下一个较高的0位留下1（或通过高端传送，而使换行的总数为零）（10100000。）

当此值与AND时x，将1更改为0的位置（以及进位将0更改为1的位置）也将包含0。因此，仅当再高1位时结果也不为零。

实际上，不需要使用任何内部函数。

首先翻转第一个1之前的所有0，然后测试新值是否为mersenne数字。在这种算法中，零映射为true。

bool has_compact_bits( unsigned const x )
{
    // fill up the low order zeroes
    unsigned const y = x | ( x - 1 );
    // test if the 1's is one solid block
    return not ( y & ( y + 1 ) );
}

当然，如果要使用内在函数，请使用以下popcount方法：

bool has_compact_bits( unsigned const x )
{
    size_t const num_bits = CHAR_BIT * sizeof(unsigned);
    size_t const sum = __builtin_ctz(x) + __builtin_popcount(x) + __builtin_clz(z);
    return sum == num_bits;
}

实际上，您不需要计算前导零。正如pmg在评论中所建议的那样，利用了一个事实，即您正在寻找的数字是序列OEIS A023758的数字，即形式为2 ^ i-2 ^ j且i> = j的数字，您可能只计算结尾的零（即j-1），切换原始值中的那些位（相当于加2 ^ j-1），然后检查该值是否为2 ^ i-1形式。借助GCC / clang内部函数，

bool has_compact_bits(int val) {
    if (val == 0) return true; // __builtin_ctz undefined if argument is zero
    int j = __builtin_ctz(val) + 1;
    val |= (1 << j) - 1; // add 2^j - 1
    val &= (val + 1); // val set to zero if of the form (2^i - 1)
    return val == 0;
}

这个版本比您的版本和KamilCuk提出的版本以及Yuri Feldman提出的仅带有popcount的版本要快一些。

如果您使用的是C ++ 20，则可以通过替换__builtin_ctz为来获得可移植的功能std::countr_zero：

#include <bit>

bool has_compact_bits(int val) {
    int j = std::countr_zero(static_cast<unsigned>(val)) + 1; // ugly cast
    val |= (1 << j) - 1; // add 2^j - 1
    val &= (val + 1); // val set to zero if of the form (2^i - 1)
    return val == 0;
}

转换很丑陋，但是警告您在处理位时最好使用无符号类型。C ++ 20之前的版本是boost::multiprecision::lsb。

编辑：

由于没有为Yuri Feldman版本发出popcount指令，因此删除线链接的基准受到了限制。尝试使用来在我的PC上编译它们-march=westmere，我测量了以下时间的10亿次迭代，这些迭代具有相同的序列std::mt19937：

• 您的版本：5.7秒
• KamilCuk的第二个版本：4.7秒
• 我的版本：4.7 s
• Eric Postpischil的第一个版本：4.3秒
• 尤里·费尔德曼（Yuri Feldman）版本（显式使用__builtin_popcount）：4.1 s

因此，至少在我的体系结构上，最快的似乎是popcount。

编辑2：

我已经使用新的Eric Postpischil版本更新了基准测试。根据评论的要求，可以在此处找到我的测试代码。我添加了一个无操作循环来估计PRNG所需的时间。我还添加了KevinZ的两个版本。代码已在clang上使用-O3 -msse4 -mbmigetpopcnt和blsi指令进行了编译（感谢Peter Cordes）。

结果：至少在我的体系结构上，Eric Postpischil的版本与Yuri Feldman的版本完全一样快，并且比到目前为止提出的任何其他版本至少快两倍。

不确定速度快，但可以通过验证val^(val>>1)最多具有2位来进行单线处理。

这仅适用于无符号类型：0必需在顶部移入（逻辑移位），而不是在算术右移中移入符号位的副本。

#include <bitset>
bool has_compact_bits(unsigned val)
{
    return std::bitset<8*sizeof(val)>((val ^ (val>>1))).count() <= 2;
}

要拒绝0（即仅接受具有正好1个连续位组的输入），逻辑与val不为零。关于这个问题的其他答案被0认为是紧凑的。

bool has_compact_bits(unsigned val)
{
    return std::bitset<8*sizeof(val)>((val ^ (val>>1))).count() <= 2 and val;
}

C ++可通过std::bitset::count()或在C ++ 20中std::popcount可移植地公开popcount 。C仍然没有一种可移植的方法，可以可靠地将其编译为popcnt或类似目标上的可用指令。

CPU对此具有专用指令，速度非常快。在PC上，它们是BSR / BSF（于1985年在80386中引入），在ARM上，它们是CLZ / CTZ。

用1查找最低有效位的索引，将整数右移该数量。使用另一个查找最高有效位的索引，将您的整数与（1u <<（bsr + 1））-1比较。

不幸的是，仅仅35年的时间还不足以更新C ++语言以匹配硬件。要使用C ++中的这些指令，您将需要内部函数，这些内部函数不可移植，并且以略有不同的格式返回结果。使用预处理器#ifdef等来检测编译器，然后使用适当的内在函数。在MSVC它们是_BitScanForward，_BitScanForward64，_BitScanReverse，_BitScanReverse64。在GCC和clang中，它们是__builtin_clz和__builtin_ctz。

用零而不是零进行比较将节省一些操作：

bool has_compact_bits2(int val) {
    if (val == 0) return true;
    int h = __builtin_clz(val);
    // Clear bits to the left
    val = (unsigned)val << h;
    int l = __builtin_ctz(val);
    // Invert
    // >>l - Clear bits to the right
    return (~(unsigned)val)>>l == 0;
}

以下结果使指令比gcc10 -O3x86_64上的指令少，并在符号扩展名上使用：

bool has_compact_bits3(int val) {
    if (val == 0) return true;
    int h = __builtin_clz(val);
    val <<= h;
    int l = __builtin_ctz(val);
    return ~(val>>l) == 0;
}

测试在godbolt。

您可以重新定义要求：

• 设置N与上一个不同的位数（通过迭代这些位数）
• 如果N = 2并且第一位或最后一位为0，则答案为是
• 如果N = 1，则答案为是（因为所有1都在一侧）
• 如果N = 0则任意位为0，那么您就没有1，如果您认为答案为是或否，则取决于您
• 其他：答案是否定的

遍历所有位可能看起来像这样：

unsigned int count_bit_changes (uint32_t value) {
  unsigned int bit;
  unsigned int changes = 0;
  uint32_t last_bit = value & 1;
  for (bit = 1; bit < 32; bit++) {
    value = value >> 1;
    if (value & 1 != last_bit  {
      changes++;
      last_bit = value & 1;
    }
  }
  return changes;
}

但这肯定可以优化（例如，通过for在value达到时放弃循环，0这意味着不再存在值1的更高有效位）。

您可以执行以下计算顺序（假设val作为输入）：

uint32_t x = val;
x |= x >>  1;
x |= x >>  2;
x |= x >>  4;
x |= x >>  8;
x |= x >> 16;

以获得一个数字，其中所有零以下的最高有效位均1填充有一个零。

您还可以计算y = val & -val去除条中除最低有效1位之外的所有位val（例如7 & -7 == 1和12 & -12 == 4）。
警告：这将对失败val == INT_MIN，因此您必须单独处理这种情况，但这是立即发生的。

然后右移y一个位置，以使其比的实际最低有效位低一点val，并执行与以下相同的例程x：

uint32_t y = (val & -val) >> 1;
y |= y >>  1;
y |= y >>  2;
y |= y >>  4;
y |= y >>  8;
y |= y >> 16;

然后x - yor或x & ~yorx ^ y生成跨越整个长度的“紧凑”位掩码val。只需将其比较val以查看是否val“紧凑”即可。

我们可以利用gcc内置说明来检查是否：

设置位数

int __builtin_popcount（无符号int x）
返回x中的1位数字。

等于（a-b）：

a：最高设置位的索引（32-CTZ）（32，因为32位是无符号整数）。

int __builtin_clz（无符号int x）
返回x中从最高有效位开始的前导0位的数目。如果x为0，则结果不确定。

b：最低设置位（CLZ）的索引：

int __builtin_clz（无符号int x）
返回x中从最高有效位开始的前导0位的数目。如果x为0，则结果不确定。

例如，如果n = 0b0001100110; 我们将使用popcount获得4，但索引差（a-b）将返回6。

bool has_contiguous_one_bits(unsigned n) {
    return (32 - __builtin_clz(n) - __builtin_ctz(n)) == __builtin_popcount(n);
}

也可以写成：

bool has_contiguous_one_bits(unsigned n) {
    return (__builtin_popcount(n) + __builtin_clz(n) + __builtin_ctz(n)) == 32;
}

我认为它比当前最受好评的答案更优雅或更有效：

return (x & x + (x & -x)) == 0;

具有以下装配：

mov     eax, edi
neg     eax
and     eax, edi
add     eax, edi
test    eax, edi
sete    al

但它可能更容易理解。

好的，这是一个遍历位的版本

template<typename Integer>
inline constexpr bool has_compact_bits(Integer val) noexcept
{
    Integer test = 1;
    while(!(test & val) && test) test<<=1; // skip unset bits to find first set bit
    while( (test & val) && test) test<<=1; // skip set bits to find next unset bit
    while(!(test & val) && test) test<<=1; // skip unset bits to find an offending set bit
    return !test;
}

前两个循环找到了第一个紧凑区域。最后的循环检查该区域之外是否还有其他设置位。