如何检查一个数字是不是是2的幂
Posted
技术标签:
【中文标题】如何检查一个数字是不是是2的幂【英文标题】：How to check if a number is a power of 2如何检查一个数字是否是2的幂 【发布时间】：2010-10-10 15:51:42 【问题描述】：今天我需要一个简单的算法来检查一个数字是否是 2 的幂。
算法需要是：
-
简单
更正任何
ulong 值。
我想出了这个简单的算法：
private bool IsPowerOfTwo(ulong number)
if (number == 0)
return false;
for (ulong power = 1; power > 0; power = power << 1)
// This for loop used shifting for powers of 2, meaning
// that the value will become 0 after the last shift
// (from binary 1000...0000 to 0000...0000) then, the 'for'
// loop will break out.
if (power == number)
return true;
if (power > number)
return false;
return false;
但后来我想：如何检查 log2 x 是否完全是一个整数？当我检查 2^63+1 时，Math.Log() 由于四舍五入而恰好返回 63。所以我检查了 2 的 63 次方是否等于原始数字，因为计算是在 doubles 中完成的，而不是确切的数字。
private bool IsPowerOfTwo_2(ulong number)
double log = Math.Log(number, 2);
double pow = Math.Pow(2, Math.Round(log));
return pow == number;
这为给定的错误值返回了true：9223372036854775809。
有更好的算法吗？
【问题讨论】：
我认为(x & (x - 1)) 的解决方案可能会在X 是两个幂的和时返回误报，例如8 + 16.
所有数字都可以写成2的幂，这就是为什么我们可以用二进制表示任何数字。此外，您的示例不会返回误报，因为 11000 & 10111 = 10000 != 0。
@JoeBrown 它没有任何误报。事实上，该表达式返回任何两个 2 的幂之和中的较大者。
现在在 .net 6 中非常容易***.com/a/69711480/6527049
【参考方案1】：
这个问题有一个简单的技巧：
bool IsPowerOfTwo(ulong x)
return (x & (x - 1)) == 0;
注意，此函数将报告true 为0，这不是2 的幂。如果你想排除它，方法如下：
bool IsPowerOfTwo(ulong x)
return (x != 0) && ((x & (x - 1)) == 0);
说明
首先是来自 MSDN 定义的按位二进制 & 运算符：
二进制 & 运算符是为整数类型和 bool 预定义的。为了 整数类型， & 计算其操作数的逻辑按位与。 对于 bool 操作数， & 计算其操作数的逻辑与；那 也就是说，当且仅当它的两个操作数都为真时，结果才为真。
现在让我们看看这一切是如何发生的：
该函数返回布尔值 (true / false) 并接受一个 unsigned long 类型的传入参数（在本例中为 x）。为简单起见，让我们假设有人传递了值 4 并像这样调用函数：
bool b = IsPowerOfTwo(4)
现在我们将每次出现的 x 替换为 4：
return (4 != 0) && ((4 & (4-1)) == 0);
我们已经知道 4 != 0 评估为真，到目前为止一切顺利。但是呢：
((4 & (4-1)) == 0)
当然是这样翻译的：
((4 & 3) == 0)
但是4&3到底是什么？
4 的二进制表示是 100，3 的二进制表示是 011（记住 & 采用这些数字的二进制表示）。所以我们有：
100 = 4
011 = 3
想象一下这些值像基本加法一样堆叠起来。 & 运算符表示如果两个值都等于 1，则结果为 1，否则为 0。因此，1 & 1 = 1、1 & 0 = 0、0 & 0 = 0 和 0 & 1 = 0。所以我们做数学：
100
011
----
000
结果只是 0。所以我们回过头来看看我们的 return 语句现在翻译成什么：
return (4 != 0) && ((4 & 3) == 0);
现在翻译为：
return true && (0 == 0);
return true && true;
我们都知道true && true 就是true，这表明对于我们的示例，4 是 2 的幂。
【讨论】：
@Kripp：数字将是二进制形式 1000...000。当您对其进行 -1 时，它将采用 0111...111 的形式。因此，这两个数字的二进制结果是 000000。这不会发生在非二次方的情况下，因为例如 1010100 会变成 1010011，从而导致（续...） ... 在二进制和之后产生一个 1010000。唯一的误报是 0，这就是我要使用的原因：return (x != 0) && ((x & (x - 1)) == 0); Kripp，考虑 (2:1, 10:1) (4:3, 100:11) (8:7, 1000:111) (16:15, 10000:1111) 查看模式? @ShuggyCoUk：二进制补码是负数的表示方式。由于这是一个无符号整数，负数的表示是不相关的。这种技术只依赖于非负整数的二进制表示。 @SoapBox - 什么更常见？不是二的幂的零或非零数字？这是一个没有更多上下文就无法回答的问题。而且真的，真的无论如何都无所谓。【参考方案2】：一些记录和解释这个和其他一些小技巧的网站是：
http://graphics.stanford.edu/~seander/bithacks.html (http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2) http://bits.stephan-brumme.com/ (http://bits.stephan-brumme.com/isPowerOfTwo.html)还有他们的祖父the book "Hacker's Delight" by Henry Warren, Jr.：
http://www.hackersdelight.org/正如Sean Anderson's page 解释的那样，表达式((x & (x - 1)) == 0) 错误地表示0 是2 的幂。他建议使用：
(!(x & (x - 1)) && x)
纠正这个问题。
【讨论】：
0 是 2 的幂... 2 ^ -inf = 0。;) ;) ;) 由于这是一个带有 C# 标记的线程，值得指出的是，自 @ 以来，最后一个表达式（Sean Anderson 的）在 C# 中是非法的987654331@ 只能应用于布尔类型，而&& 还要求两个操作数都是布尔型-（除了用户定义的运算符使其他事情成为可能，但这与ulong 无关。）
catonmat.net/low-level-bit-hacks 用 8 位示例解释了一些相关的 bithacks。例如用y = x & (-x) 隔离最右边的 1 位。该测试只是清除最低设置位的一种特殊情况。【参考方案3】：
return (i & -i) == i
【讨论】：
任何提示为什么这会或不会起作用？我只在 java 中检查了它的正确性，那里只有签名的整数/长整数。如果它是正确的，这将是更好的答案。更快+更小 它利用了二进制补码表示法的一个特性：计算一个数字的负值，您执行按位否定并将结果加 1。设置的i 的最低有效位也将设置在-i 中。其下方的位将为 0（在两个值中），而其上方的位将相互反转。因此i & -i 的值将是i 中的最低有效设置位（它是2 的幂）。如果i 具有相同的值，那么这是唯一设置的位。当 i 为 0 时它会失败，原因与 i & (i - 1) == 0 相同。
如果i 是无符号类型，则二进制补码与它无关。您只是在利用模算术和按位与的属性。
如果i==0（返回(0&0==0)，即true），这将不起作用。应该是return i && ( (i&-i)==i )【参考方案4】：
bool IsPowerOfTwo(ulong x)
return x > 0 && (x & (x - 1)) == 0;
【讨论】：
这个解决方案更好，因为如果负数能够传入，它也可以处理负数。（如果是long而不是ulong） 在这种情况下，为什么小数会作为 2 的幂传递？【参考方案5】：以下已接受答案的附录可能对某些人有用：
以二进制表示时，2 的幂总是看起来像 1 后跟 n 个零，其中 n 大于或等于 0。例如：
Decimal Binary
1 1 (1 followed by 0 zero)
2 10 (1 followed by 1 zero)
4 100 (1 followed by 2 zeroes)
8 1000 (1 followed by 3 zeroes)
. .
. .
. .
等等。
当我们从这些数字中减去1 时，它们变成0 后跟n 个1，n 再次与上面相同。例如：
Decimal Binary
1 - 1 = 0 0 (0 followed by 0 one)
2 - 1 = 1 01 (0 followed by 1 one)
4 - 1 = 3 011 (0 followed by 2 ones)
8 - 1 = 7 0111 (0 followed by 3 ones)
. .
. .
. .
等等。
来到关键点
当我们对数字
x进行按位与运算时会发生什么，这是一个 2 的幂，x - 1?
x 的一个与x - 1 的零对齐，x 的所有零与x - 1 的零对齐，导致按位与结果为 0。 这就是我们为什么上面提到的单行答案是正确的。
进一步增加上述已接受答案的美感 -
所以，我们现在有一处房产可供使用：
当我们从任何数字中减去 1 时，在二进制表示中，最右边的 1 将变为 0，而最右边的 1 左侧的所有零现在都将变为 1。
这个属性的一个非常棒的用途是找出 - 给定数字的二进制表示中有多少个 1？ 为给定整数 x 执行此操作的简短代码是：
byte count = 0;
for ( ; x != 0; x &= (x - 1)) count++;
Console.Write("Total ones in the binary representation of x = 0", count);
可以从上面解释的概念证明的数字的另一个方面是“每个正数都可以表示为 2 的幂和吗？”。
是的，每个正数都可以表示为 2 的幂的和。对于任何数字，都采用它的二进制表示。例如：取号码117。
The binary representation of 117 is 1110101
Because 1110101 = 1000000 + 100000 + 10000 + 0000 + 100 + 00 + 1
we have 117 = 64 + 32 + 16 + 0 + 4 + 0 + 1
【讨论】：
@Michi：我是否在某处声称 0 是正数？还是 2 的幂？ 是的，以 0 为例，并在二进制表示中对其进行数学运算。它会造成混乱。【参考方案6】：这是一个简单的C++ 解决方案：
bool IsPowerOfTwo( unsigned int i )
return std::bitset<32>(i).count() == 1;
【讨论】：
在 gcc 上，它编译成一个名为__builtin_popcount 的 gcc 内置函数。不幸的是，一个处理器系列还没有一条汇编指令来执行此操作（x86），因此它是最快的位计数方法。在任何其他架构上，这是一条汇编指令。
@deft_code 较新的 x86 微架构支持 popcnt
lea eax, [rdi-1] + test/jnz 实现i & (i-1) == 0 比popcnt / cmp/je 便宜一些，特别是如果您不需要处理i==0 的情况，因为不算数。
感谢您提及 C++ 并将其链接到 C++ 的***页面。如果没有它，那真的会很混乱。 /s【参考方案7】：
发布问题后，我想到了以下解决方案：
我们需要检查其中一个二进制数字是否为 1。因此，我们只需将数字一次右移一位，如果等于 1，则返回 true。如果在任何时候我们得到一个奇数 ((number & 1) == 1)，我们就知道结果是 false。这证明（使用基准）比处理（大）真值的原始方法稍快，而处理假值或小值的速度要快得多。
private static bool IsPowerOfTwo(ulong number)
while (number != 0)
if (number == 1)
return true;
if ((number & 1) == 1)
// number is an odd number and not 1 - so it's not a power of two.
return false;
number = number >> 1;
return false;
当然，Greg 的解决方案要好得多。
【讨论】：
【参考方案8】： bool IsPowerOfTwo(int n)
if (n > 1)
while (n%2 == 0)
n >>= 1;
return n == 1;
这里有一个通用算法，用于判断一个数是否是另一个数的幂。
bool IsPowerOf(int n,int b)
if (n > 1)
while (n % b == 0)
n /= b;
return n == 1;
【讨论】：
【参考方案9】：bool isPow2 = ((x & ~(x-1))==x)? !!x : 0;
【讨论】：
这是c#吗？我猜这是c++，因为x 作为布尔值返回。
我确实把它写成 C++。让它 C# 是微不足道的： bool isPow2 = ((x & ~(x-1))==x)? x!=0：假；【参考方案10】：
return ((x != 0) && !(x & (x - 1)));
如果 x 是 2 的幂，则其唯一的 1 位位于 n 位置。这意味着x – 1 在n 的位置上有一个0。要了解原因，请回想二进制减法的工作原理。当x减1时，借位一直传播到位置n； n 位变为 0，所有低位变为 1。现在，由于 x 与 x – 1 没有共同的 1 位，x & (x – 1) 为 0，!(x & (x – 1)) 为真。
【讨论】：
【参考方案11】：bool isPowerOfTwo(int x_)
register int bitpos, bitpos2;
asm ("bsrl %1,%0": "+r" (bitpos):"rm" (x_));
asm ("bsfl %1,%0": "+r" (bitpos2):"rm" (x_));
return bitpos > 0 && bitpos == bitpos2;
【讨论】：
如果您试图排除x_ == 0，bitpos > 0 不是一个有意义的测试。 x_ = 1 的输入有一个设置位，并导致 BSF 和 BSR 产生0 的位位置结果。您没有初始化您的"+r" 读写输出，因此您对x_ == 0 没有任何保证行为。 （BSF 和 BSR 在输入 = 0 时保持目标未修改；AMD 记录了这一点，英特尔实现了它，但只将结果记录为未定义的值。）也许 bitpos = 0，bitpos2 = 32 在 asm 语句有用之前，所以它们不匹配输入=0。
我还建议从输入约束中删除"m"。您希望编译器选择一个寄存器，因为您要读取它两次。第二个 asm 语句可能会被安排成 output=input 最初这样编译器可以根据需要选择相同的输入和输出寄存器。【参考方案12】：
int isPowerOfTwo(unsigned int x)
return ((x != 0) && ((x & (~x + 1)) == x));
这真的很快。检查所有 2^32 个整数大约需要 6 分 43 秒。
【讨论】：
【参考方案13】：对于任何 2 的幂，以下也成立。
n&(-n)==n
注意： n=0 失败，因此需要检查它 这样做的原因是： -n 是 n 的 2s 补码。 -n 将与 n 相比，将 n 的最右边设置位左侧的每一位翻转。对于 2 的幂，只有一个设置位。
【讨论】：
这个答案是 7 年前的posted。【参考方案14】：判断给定数是否为 2 的幂。
#include <math.h>
int main(void)
int n,logval,powval;
printf("Enter a number to find whether it is s power of 2\n");
scanf("%d",&n);
logval=log(n)/log(2);
powval=pow(2,logval);
if(powval==n)
printf("The number is a power of 2");
else
printf("The number is not a power of 2");
getch();
return 0;
【讨论】：
或者，在 C# 中： return x == Math.Pow(2, Math.Log(x, 2)); 坏了。遭受主要的浮点舍入问题。如果你想使用浮点数，请使用frexp 而不是讨厌的 log 东西。【参考方案15】：
如果一个数字仅包含 1 个设置位，则它是 2 的幂。我们可以使用这个属性和泛型函数countSetBits 来判断一个数是否是2 的幂。
这是一个 C++ 程序：
int countSetBits(int n)
int c = 0;
while(n)
c += 1;
n = n & (n-1);
return c;
bool isPowerOfTwo(int n)
return (countSetBits(n)==1);
int main()
int i, val[] = 0,1,2,3,4,5,15,16,22,32,38,64,70;
for(i=0; i<sizeof(val)/sizeof(val[0]); i++)
printf("Num:%d\tSet Bits:%d\t is power of two: %d\n",val[i], countSetBits(val[i]), isPowerOfTwo(val[i]));
return 0;
我们不需要明确地检查 0 是否是 2 的幂，因为它也会为 0 返回 False。
输出
Num:0 Set Bits:0 is power of two: 0
Num:1 Set Bits:1 is power of two: 1
Num:2 Set Bits:1 is power of two: 1
Num:3 Set Bits:2 is power of two: 0
Num:4 Set Bits:1 is power of two: 1
Num:5 Set Bits:2 is power of two: 0
Num:15 Set Bits:4 is power of two: 0
Num:16 Set Bits:1 is power of two: 1
Num:22 Set Bits:3 is power of two: 0
Num:32 Set Bits:1 is power of two: 1
Num:38 Set Bits:3 is power of two: 0
Num:64 Set Bits:1 is power of two: 1
Num:70 Set Bits:3 is power of two: 0
【讨论】：
当函数的返回类型为“ulong”时，将 c 作为“int”返回？使用while 而不是if？我个人看不出原因，但它似乎有效。编辑： - 不......它会返回 1 大于 0!?
@JamesKhoury 我正在编写一个 c++ 程序，所以我错误地返回了一个 int。然而，这是一个小错别字，不值得投反对票。但是我无法理解您评论的其余部分“使用 while 而不是 if”和“对于大于 0 的任何内容将返回 1”的原因。我添加了主存根来检查输出。 AFAIK它的预期输出。如果我错了，请纠正我。【参考方案16】：
这是我设计的另一种方法，在这种情况下使用| 而不是&：
bool is_power_of_2(ulong x)
if(x == (1 << (sizeof(ulong)*8 -1) ) return true;
return (x > 0) && (x<<1 == (x|(x-1)) +1));
【讨论】：
这里需要(x > 0) 位吗？
@configurator，是的，否则 is_power_of_2(0) 将返回 true【参考方案17】：
现在在 .Net 6 中非常容易。
using System.Numerics;
bool isPow2 = BitOperations.IsPow2(64); // sets true
Here 是文档。
【讨论】：
【参考方案18】：示例
0000 0001 Yes
0001 0001 No
算法
使用位掩码，除以NUM二进制变量
IF R > 0 AND L > 0: Return FALSE
否则，NUM 变为非零值
IF NUM = 1: Return TRUE
否则，请转到步骤 1
复杂性
时间 ~ O(log(d)) 其中d 是二进制位数
【讨论】：
【参考方案19】：改进@user134548的答案，不用比特算术：
public static bool IsPowerOfTwo(ulong n)
if (n % 2 != 0) return false; // is odd (can't be power of 2)
double exp = Math.Log(n, 2);
if (exp != Math.Floor(exp)) return false; // if exp is not integer, n can't be power
return Math.Pow(2, exp) == n;
这适用于：
IsPowerOfTwo(9223372036854775809)
【讨论】：
浮点运算比简单的按位表达式要慢得多【参考方案20】：Mark Gravell 建议 this 如果你有 .NET Core 3，System.Runtime.Intrinsics.X86.Popcnt.PopCount
public bool IsPowerOfTwo(uint i)
return Popcnt.PopCount(i) == 1
单指令，比(x != 0) && ((x & (x - 1)) == 0) 更快，但便携性较差。
【讨论】：
你确定它比(x != 0) && ((x & (x - 1)) == 0)快吗？我对此表示怀疑，尤其是。在 popcnt 不可用的旧系统上
不是更快。我刚刚在现代 Intel CPU 上对此进行了测试，并验证了反汇编中使用的 POPCNT（在 C 代码中，而不是 .NET 中授予）。 POPCNT 通常对位计数更快，但对于单个位打开的情况，位旋转技巧仍然快 10%。
糟糕，我收回了。我正在循环测试我是否认为分支预测是“作弊”。 POPCNT 确实是在单个时钟周期内运行的单条指令，如果有的话会更快。【参考方案21】：
.NET 6 中只有一个衬里
// IsPow2 evaluates whether the specified Int32 value is a power of two.
Console.WriteLine(BitOperations.IsPow2(128)); // True
【讨论】：
【参考方案22】：在 C 语言中，我测试了 i && !(i & (i - 1) 技巧并将其与 __builtin_popcount(i) 进行了比较，在 Linux 上使用 gcc，并带有 -mpopcnt 标志以确保使用 CPU 的 POPCNT 指令。我的测试程序计算了 0 到 2^31 之间的整数个数，它们是 2 的幂。
起初我认为i && !(i & (i - 1) 的速度快了 10%，尽管我验证了在我使用__builtin_popcount 的反汇编中使用了 POPCNT。
但是，我意识到我已经包含了一个 if 语句，并且分支预测在 bit twiddling 版本上可能做得更好。正如预期的那样，我删除了 if 并且 POPCNT 以更快的速度结束。
结果：
Intel(R) Core(TM) i7-4771 CPU 最高 3.90GHz
Timing (i & !(i & (i - 1))) trick
30
real 0m13.804s
user 0m13.799s
sys 0m0.000s
Timing POPCNT
30
real 0m11.916s
user 0m11.916s
sys 0m0.000s
AMD Ryzen Threadripper 2950X 16 核处理器最高 3.50GHz
Timing (i && !(i & (i - 1))) trick
30
real 0m13.675s
user 0m13.673s
sys 0m0.000s
Timing POPCNT
30
real 0m13.156s
user 0m13.153s
sys 0m0.000s
请注意，这里的 Intel CPU 似乎比 AMD 稍慢一点，但 POPCNT 快得多； AMD POPCNT 没有提供那么多的提升。
popcnt_test.c:
#include "stdio.h"
// Count # of integers that are powers of 2 up to 2^31;
int main()
int n;
for (int z = 0; z < 20; z++)
n = 0;
for (unsigned long i = 0; i < 1<<30; i++)
#ifdef USE_POPCNT
n += (__builtin_popcount(i)==1); // Was: if (__builtin_popcount(i) == 1) n++;
#else
n += (i && !(i & (i - 1))); // Was: if (i && !(i & (i - 1))) n++;
#endif
printf("%d\n", n);
return 0;
运行测试：
gcc popcnt_test.c -O3 -o test.exe
gcc popcnt_test.c -O3 -DUSE_POPCNT -mpopcnt -o test-popcnt.exe
echo "Timing (i && !(i & (i - 1))) trick"
time ./test.exe
echo
echo "Timing POPCNT"
time ./test-opt.exe
【讨论】：
【参考方案23】：我看到很多答案都建议返回 n && !(n & (n - 1)) 但根据我的经验，如果输入值为负数，它会返回错误值。 我将在这里分享另一种简单的方法，因为我们知道两个数字的幂只有一个设置位，所以我们将简单地计算设置位的数量，这将花费 O(log N) 时间。
while (n > 0)
int count = 0;
n = n & (n - 1);
count++;
return count == 1;
查看这篇文章到count no. of set bits
【讨论】：
【参考方案24】：这也是另一种方法
package javacore;
import java.util.Scanner;
public class Main_exercise5
public static void main(String[] args)
// Local Declaration
boolean ispoweroftwo = false;
int n;
Scanner input = new Scanner (System.in);
System.out.println("Enter a number");
n = input.nextInt();
ispoweroftwo = checkNumber(n);
System.out.println(ispoweroftwo);
public static boolean checkNumber(int n)
// Function declaration
boolean ispoweroftwo= false;
// if not divisible by 2, means isnotpoweroftwo
if(n%2!=0)
ispoweroftwo=false;
return ispoweroftwo;
else
for(int power=1; power>0; power=power<<1)
if (power==n)
return true;
else if (power>n)
return false;
return ispoweroftwo;
【讨论】：
【参考方案25】：在这种方法中，您可以检查整数中是否只有1个设置位，并且整数> 0（c++）。
bool is_pow_of_2(int n)
int count = 0;
for(int i = 0; i < 32; i++)
count += (n>>i & 1);
return count == 1 && n > 0;
【讨论】：
【参考方案26】：如果数字是 2 的幂，最大为 64 值，则返回此值（您可以在 for 循环条件中更改它（“6”表示 2^6 为 64）；
const isPowerOfTwo = (number) =>
let result = false;
for (let i = 1; i <= 6; i++)
if (number === Math.pow(2, i))
result = true;
return result;
;
console.log(isPowerOfTwo(16));
console.log(isPowerOfTwo(10));【讨论】：
【参考方案27】：private static bool IsPowerOfTwo(ulong x)
var l = Math.Log(x, 2);
return (l == Math.Floor(l));
【讨论】：
试试这个号码 9223372036854775809。它有效吗？我认为不会，因为舍入错误。 @configurator 922337203685477580_9_ 在我看来不像 2 的幂；) @Kirschstein：这个数字给了他一个误报。 Kirschstein：在我看来也不像。虽然它看起来确实像一个函数......以上是关于如何检查一个数字是不是是2的幂的主要内容，如果未能解决你的问题，请参考以下文章