我想编写一个返回最接近 2 的下一个幂的函数。例如，如果我的输入是 789，则输出应该是 1024。有没有什么方法可以在不使用任何循环而只使用一些位运算符的情况下实现这一点？
Naveen
问问题
235392 次
31 回答
189
检查Bit Twiddling Hacks。你需要得到以 2 为底的对数，然后加 1。32 位值的示例：
向上取整到 2 的次幂
unsigned int v; // compute the next highest power of 2 of 32-bit v v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++;
扩展到其他宽度应该是显而易见的。
于 2009-01-21T17:30:53.647 回答
85
next = pow(2, ceil(log(x)/log(2)));
这可以通过找到你要提高 2 来得到 x 的数字来工作（取数字的对数，然后除以所需基数的对数，更多信息请参见维基百科）。然后用 ceil 将其四舍五入以获得最接近的整数幂。
这是一种比其他地方链接的按位方法更通用（即更慢！）的方法，但是很高兴了解数学，是吗？
于 2009-01-21T17:35:46.833 回答
68
我认为这也有效：
int power = 1;
while(power < x)
power*=2;
答案是power。
于 2012-09-20T04:46:22.680 回答
53
unsigned long upper_power_of_two(unsigned long v)
{
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
于 2009-01-21T17:39:19.107 回答
40
如果你使用 GCC，你可能想看看Lockless Inc.的Optimizing the next_pow2()builtin_clz() function汇编指令bsr（位扫描反向），就像它在另一个答案的链接到 gamedev 站点中描述的一样。此代码可能比先前答案中描述的更快。
顺便说一句，如果你不打算使用汇编指令和 64 位数据类型，你可以使用这个
/**
* return the smallest power of two value
* greater than x
*
* Input range: [2..2147483648]
* Output range: [2..2147483648]
*
*/
__attribute__ ((const))
static inline uint32_t p2(uint32_t x)
{
#if 0
assert(x > 1);
assert(x <= ((UINT32_MAX/2) + 1));
#endif
return 1 << (32 - __builtin_clz (x - 1));
}
于 2012-04-13T14:59:37.463 回答
19
还有一个，虽然我用的是循环，但是这比数学操作数快多了
两个“地板”选项的幂：
int power = 1;
while (x >>= 1) power <<= 1;
两个“ceil”选项的幂：
int power = 2;
x--; // <<-- UPDATED
while (x >>= 1) power <<= 1;
更新
如评论中所述ceil，其结果错误的地方存在错误。
以下是完整的功能：
unsigned power_floor(unsigned x) {
int power = 1;
while (x >>= 1) power <<= 1;
return power;
}
unsigned power_ceil(unsigned x) {
if (x <= 1) return 1;
int power = 2;
x--;
while (x >>= 1) power <<= 1;
return power;
}
于 2014-07-19T20:46:54.403 回答
13
对于任何无符号类型，以 Bit Twiddling Hacks 为基础：
#include <climits>
#include <type_traits>
template <typename UnsignedType>
UnsignedType round_up_to_power_of_2(UnsignedType v) {
static_assert(std::is_unsigned<UnsignedType>::value, "Only works for unsigned types");
v--;
for (size_t i = 1; i < sizeof(v) * CHAR_BIT; i *= 2) //Prefer size_t "Warning comparison between signed and unsigned integer"
{
v |= v >> i;
}
return ++v;
}
那里没有真正的循环，因为编译器在编译时知道迭代次数。
于 2015-01-13T05:31:42.707 回答
9
对于 IEEE 浮点数，你可以做这样的事情。
int next_power_of_two(float a_F){
int f = *(int*)&a_F;
int b = f << 9 != 0; // If we're a power of two this is 0, otherwise this is 1
f >>= 23; // remove factional part of floating point number
f -= 127; // subtract 127 (the bias) from the exponent
// adds one to the exponent if were not a power of two,
// then raises our new exponent to the power of two again.
return (1 << (f + b));
}
如果您需要整数解决方案并且能够使用内联汇编，BSR 将为您提供 x86 上整数的 log2。它计算设置了多少正确位，恰好等于该数字的 log2。其他处理器（通常）具有类似的指令，例如 CLZ，并且根据您的编译器，可能有一个内在函数可以为您完成工作。
于 2009-01-21T18:15:42.433 回答
9
在标准c++20中，这包含在<bit>. 答案很简单
#include <bit>
unsigned long upper_power_of_two(unsigned long v)
{
return std::bit_ceil(v);
}
注意：
我给出的解决方案是c++，而不是c，我会回答这个问题，但它作为这个问题的副本被关闭了！
于 2021-04-06T19:50:36.947 回答
6
在 x86 中，您可以使用 sse4 位操作指令来加快速度。
//assume input is in eax
mov ecx,31
popcnt edx,eax //cycle 1
lzcnt eax,eax //cycle 2
sub ecx,eax
mov eax,1
cmp edx,1 //cycle 3
jle @done //cycle 4 - popcnt says its a power of 2, return input unchanged
shl eax,cl //cycle 5
@done: rep ret //cycle 5
在 c 中，您可以使用匹配的内在函数。
或无跳跃，它通过避免由于跳跃而导致的错误预测来加速事情，但通过延长依赖链来减慢事情的速度。对代码计时，看看哪个最适合您。
//assume input is in eax
mov ecx,31
popcnt edx,eax //cycle 1
lzcnt eax,eax
sub ecx,eax
mov eax,1 //cycle 2
cmp edx,1
mov edx,0 //cycle 3
cmovle ecx,edx //cycle 4 - ensure eax does not change
shl eax,cl
@done: rep ret //cycle 5
于 2016-03-31T15:49:08.747 回答
5
/*
** http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
*/
#define __LOG2A(s) ((s &0xffffffff00000000) ? (32 +__LOG2B(s >>32)): (__LOG2B(s)))
#define __LOG2B(s) ((s &0xffff0000) ? (16 +__LOG2C(s >>16)): (__LOG2C(s)))
#define __LOG2C(s) ((s &0xff00) ? (8 +__LOG2D(s >>8)) : (__LOG2D(s)))
#define __LOG2D(s) ((s &0xf0) ? (4 +__LOG2E(s >>4)) : (__LOG2E(s)))
#define __LOG2E(s) ((s &0xc) ? (2 +__LOG2F(s >>2)) : (__LOG2F(s)))
#define __LOG2F(s) ((s &0x2) ? (1) : (0))
#define LOG2_UINT64 __LOG2A
#define LOG2_UINT32 __LOG2B
#define LOG2_UINT16 __LOG2C
#define LOG2_UINT8 __LOG2D
static inline uint64_t
next_power_of_2(uint64_t i)
{
#if defined(__GNUC__)
return 1UL <<(1 +(63 -__builtin_clzl(i -1)));
#else
i =i -1;
i =LOG2_UINT64(i);
return 1UL <<(1 +i);
#endif
}
如果您不想冒险进入未定义行为的领域，则输入值必须介于 1 和 2^63 之间。该宏对于在编译时设置常量也很有用。
于 2013-11-27T07:21:26.347 回答
5
这是我在 C 中的解决方案。希望这会有所帮助！
int next_power_of_two(int n) {
int i = 0;
for (--n; n > 0; n >>= 1) {
i++;
}
return 1 << i;
}
于 2018-10-29T07:32:33.417 回答
4
为了完整起见，这里是沼泽标准 C 中的浮点实现。
double next_power_of_two(double value) {
int exp;
if(frexp(value, &exp) == 0.5) {
// Omit this case to round precise powers of two up to the *next* power
return value;
}
return ldexp(1.0, exp);
}
于 2013-12-29T00:24:29.070 回答
4
用于整数输入的 C/C++ 中高效的 Microsoft（例如 Visual Studio 2017）特定解决方案。通过在检查最高有效 1 位的位置之前递减来处理输入与两个值的幂完全匹配的情况。
inline unsigned int ExpandToPowerOf2(unsigned int Value)
{
unsigned long Index;
_BitScanReverse(&Index, Value - 1);
return (1U << (Index + 1));
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#if defined(WIN64) // The _BitScanReverse64 intrinsic is only available for 64 bit builds because it depends on x64
inline unsigned long long ExpandToPowerOf2(unsigned long long Value)
{
unsigned long Index;
_BitScanReverse64(&Index, Value - 1);
return (1ULL << (Index + 1));
}
#endif
这会为英特尔处理器生成 5 个左右的内联指令，类似于以下内容：
dec eax
bsr rcx, rax
inc ecx
mov eax, 1
shl rax, cl
显然，Visual Studio C++ 编译器没有针对编译时值进行优化，但它不像那里有很多指令。
编辑：
如果您希望输入值 1 产生 1（2 的零次方），则对上述代码的小修改仍会生成没有分支的直通指令。
inline unsigned int ExpandToPowerOf2(unsigned int Value)
{
unsigned long Index;
_BitScanReverse(&Index, --Value);
if (Value == 0)
Index = (unsigned long) -1;
return (1U << (Index + 1));
}
只生成更多指令。诀窍是 Index 可以被一个测试替换，然后是一个 cmove 指令。
于 2018-07-31T20:17:29.610 回答
1
您可能会发现以下说明有助于实现您的目的：
于 2019-10-16T11:00:40.993 回答
1
C# 中的可移植解决方案：
int GetNextPowerOfTwo(int input) {
return 1 << (int)Math.Ceiling(Math.Log2(input));
}
Math.Ceiling(Math.Log2(value))计算二的下一个幂的指数，通过1 <<位移计算实际值。
如果您拥有 .NET Core 3 或更高版本，则更快的解决方案：
uint GetNextPowerOfTwoFaster(uint input) {
return (uint)1 << (sizeof(uint) * 8 - System.Numerics.BitOperations.LeadingZeroCount(input - 1));
}
如果可用，这将System.Numerics.BitOperations.LeadingZeroCount()使用硬件指令：
更新：
RoundUpToPowerOf2()即将在 .NET 6 中出现！内部实现与上面的 .NET Core 3 解决方案基本相同。
这是社区更新。
于 2020-10-23T03:25:09.067 回答
1
试图为此制定一个“终极”解决方案。以下代码
针对 C 语言（不是 C++），
如果编译器支持任何代码，则使用编译器内置程序生成高效代码（CLZ 或 BSR 指令），
是可移植的（标准 C 和无程序集），除了内置的，并且
解决所有未定义的行为。
如果您使用 C++ 编写，您可以适当地调整代码。请注意，C++20 引入了std::bit_ceil，它的作用完全相同，只是在某些条件下行为可能未定义。
#include <limits.h>
#ifdef _MSC_VER
# if _MSC_VER >= 1400
/* _BitScanReverse is introduced in Visual C++ 2005 and requires
<intrin.h> (also introduced in Visual C++ 2005). */
#include <intrin.h>
#pragma intrinsic(_BitScanReverse)
#pragma intrinsic(_BitScanReverse64)
# define HAVE_BITSCANREVERSE 1
# endif
#endif
/* Macro indicating that the compiler supports __builtin_clz().
The name HAVE_BUILTIN_CLZ seems to be the most common, but in some
projects HAVE__BUILTIN_CLZ is used instead. */
#ifdef __has_builtin
# if __has_builtin(__builtin_clz)
# define HAVE_BUILTIN_CLZ 1
# endif
#elif defined(__GNUC__)
# if (__GNUC__ > 3)
# define HAVE_BUILTIN_CLZ 1
# elif defined(__GNUC_MINOR__)
# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# define HAVE_BUILTIN_CLZ 1
# endif
# endif
#endif
/**
* Returns the smallest power of two that is not smaller than x.
*/
unsigned long int next_power_of_2_long(unsigned long int x)
{
if (x <= 1) {
return 1;
}
x--;
#ifdef HAVE_BITSCANREVERSE
if (x > (ULONG_MAX >> 1)) {
return 0;
} else {
unsigned long int index;
(void) _BitScanReverse(&index, x);
return (1UL << (index + 1));
}
#elif defined(HAVE_BUILTIN_CLZ)
if (x > (ULONG_MAX >> 1)) {
return 0;
}
return (1UL << (sizeof(x) * CHAR_BIT - __builtin_clzl(x)));
#else
/* Solution from "Bit Twiddling Hacks"
<http://www.graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2>
but converted to a loop for smaller code size.
("gcc -O3" will unroll this.) */
{
unsigned int shift;
for (shift = 1; shift < sizeof(x) * CHAR_BIT; shift <<= 1) {
x |= (x >> shift);
}
}
return (x + 1);
#endif
}
unsigned int next_power_of_2(unsigned int x)
{
if (x <= 1) {
return 1;
}
x--;
#ifdef HAVE_BITSCANREVERSE
if (x > (UINT_MAX >> 1)) {
return 0;
} else {
unsigned long int index;
(void) _BitScanReverse(&index, x);
return (1U << (index + 1));
}
#elif defined(HAVE_BUILTIN_CLZ)
if (x > (UINT_MAX >> 1)) {
return 0;
}
return (1U << (sizeof(x) * CHAR_BIT - __builtin_clz(x)));
#else
{
unsigned int shift;
for (shift = 1; shift < sizeof(x) * CHAR_BIT; shift <<= 1) {
x |= (x >> shift);
}
}
return (x + 1);
#endif
}
unsigned long long next_power_of_2_long_long(unsigned long long x)
{
if (x <= 1) {
return 1;
}
x--;
#if (defined(HAVE_BITSCANREVERSE) && \
ULLONG_MAX == 18446744073709551615ULL)
if (x > (ULLONG_MAX >> 1)) {
return 0;
} else {
/* assert(sizeof(__int64) == sizeof(long long)); */
unsigned long int index;
(void) _BitScanReverse64(&index, x);
return (1ULL << (index + 1));
}
#elif defined(HAVE_BUILTIN_CLZ)
if (x > (ULLONG_MAX >> 1)) {
return 0;
}
return (1ULL << (sizeof(x) * CHAR_BIT - __builtin_clzll(x)));
#else
{
unsigned int shift;
for (shift = 1; shift < sizeof(x) * CHAR_BIT; shift <<= 1) {
x |= (x >> shift);
}
}
return (x + 1);
#endif
}
于 2021-07-01T03:25:55.280 回答
1
用于 C++14 的 clp2 的 constexpr 版本
#include <iostream>
#include <type_traits>
// Closest least power of 2 minus 1. Returns 0 if n = 0.
template <typename UInt, std::enable_if_t<std::is_unsigned<UInt>::value,int> = 0>
constexpr UInt clp2m1(UInt n, unsigned i = 1) noexcept
{ return i < sizeof(UInt) * 8 ? clp2m1(UInt(n | (n >> i)),i << 1) : n; }
/// Closest least power of 2 minus 1. Returns 0 if n <= 0.
template <typename Int, std::enable_if_t<std::is_integral<Int>::value && std::is_signed<Int>::value,int> = 0>
constexpr auto clp2m1(Int n) noexcept
{ return clp2m1(std::make_unsigned_t<Int>(n <= 0 ? 0 : n)); }
/// Closest least power of 2. Returns 2^N: 2^(N-1) < n <= 2^N. Returns 0 if n <= 0.
template <typename Int, std::enable_if_t<std::is_integral<Int>::value,int> = 0>
constexpr auto clp2(Int n) noexcept
{ return clp2m1(std::make_unsigned_t<Int>(n-1)) + 1; }
/// Next power of 2. Returns 2^N: 2^(N-1) <= n < 2^N. Returns 1 if n = 0. Returns 0 if n < 0.
template <typename Int, std::enable_if_t<std::is_integral<Int>::value,int> = 0>
constexpr auto np2(Int n) noexcept
{ return clp2m1(std::make_unsigned_t<Int>(n)) + 1; }
template <typename T>
void test(T v) { std::cout << clp2(v) << std::endl; }
int main()
{
test(-5); // 0
test(0); // 0
test(8); // 8
test(31); // 32
test(33); // 64
test(789); // 1024
test(char(260)); // 4
test(unsigned(-1) - 1); // 0
test<long long>(unsigned(-1) - 1); // 4294967296
return 0;
}
于 2021-09-15T07:28:01.913 回答
0
许多处理器架构支持log base 2或非常相似的操作—— count leading zeros. 许多编译器都有它的内在函数。见https://en.wikipedia.org/wiki/Find_first_set
于 2013-10-04T21:52:25.900 回答
0
假设你有一个好的编译器并且它可以在我上面做一些之前的操作，但无论如何这有效！！！
// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
#define SH1(v) ((v-1) | ((v-1) >> 1)) // accidently came up w/ this...
#define SH2(v) ((v) | ((v) >> 2))
#define SH4(v) ((v) | ((v) >> 4))
#define SH8(v) ((v) | ((v) >> 8))
#define SH16(v) ((v) | ((v) >> 16))
#define OP(v) (SH16(SH8(SH4(SH2(SH1(v))))))
#define CB0(v) ((v) - (((v) >> 1) & 0x55555555))
#define CB1(v) (((v) & 0x33333333) + (((v) >> 2) & 0x33333333))
#define CB2(v) ((((v) + ((v) >> 4) & 0xF0F0F0F) * 0x1010101) >> 24)
#define CBSET(v) (CB2(CB1(CB0((v)))))
#define FLOG2(v) (CBSET(OP(v)))
测试代码如下：
#include <iostream>
using namespace std;
// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
#define SH1(v) ((v-1) | ((v-1) >> 1)) // accidently guess this...
#define SH2(v) ((v) | ((v) >> 2))
#define SH4(v) ((v) | ((v) >> 4))
#define SH8(v) ((v) | ((v) >> 8))
#define SH16(v) ((v) | ((v) >> 16))
#define OP(v) (SH16(SH8(SH4(SH2(SH1(v))))))
#define CB0(v) ((v) - (((v) >> 1) & 0x55555555))
#define CB1(v) (((v) & 0x33333333) + (((v) >> 2) & 0x33333333))
#define CB2(v) ((((v) + ((v) >> 4) & 0xF0F0F0F) * 0x1010101) >> 24)
#define CBSET(v) (CB2(CB1(CB0((v)))))
#define FLOG2(v) (CBSET(OP(v)))
#define SZ4 FLOG2(4)
#define SZ6 FLOG2(6)
#define SZ7 FLOG2(7)
#define SZ8 FLOG2(8)
#define SZ9 FLOG2(9)
#define SZ16 FLOG2(16)
#define SZ17 FLOG2(17)
#define SZ127 FLOG2(127)
#define SZ1023 FLOG2(1023)
#define SZ1024 FLOG2(1024)
#define SZ2_17 FLOG2((1ul << 17)) //
#define SZ_LOG2 FLOG2(SZ)
#define DBG_PRINT(x) do { std::printf("Line:%-4d" " %10s = %-10d\n", __LINE__, #x, x); } while(0);
uint32_t arrTble[FLOG2(63)];
int main(){
int8_t n;
DBG_PRINT(SZ4);
DBG_PRINT(SZ6);
DBG_PRINT(SZ7);
DBG_PRINT(SZ8);
DBG_PRINT(SZ9);
DBG_PRINT(SZ16);
DBG_PRINT(SZ17);
DBG_PRINT(SZ127);
DBG_PRINT(SZ1023);
DBG_PRINT(SZ1024);
DBG_PRINT(SZ2_17);
return(0);
}
输出：
Line:39 SZ4 = 2
Line:40 SZ6 = 3
Line:41 SZ7 = 3
Line:42 SZ8 = 3
Line:43 SZ9 = 4
Line:44 SZ16 = 4
Line:45 SZ17 = 5
Line:46 SZ127 = 7
Line:47 SZ1023 = 10
Line:48 SZ1024 = 10
Line:49 SZ2_16 = 17
于 2016-08-19T02:10:58.007 回答
0
我正在尝试获得最接近 2 的较低幂并制作此功能。可能对您有所帮助。只需将最接近的较低数字乘以 2 即可获得 2 的最接近的上幂
int nearest_upper_power(int number){
int temp=number;
while((number&(number-1))!=0){
temp<<=1;
number&=temp;
}
//Here number is closest lower power
number*=2;
return number;
}
于 2017-01-16T22:23:03.527 回答
0
改编了 Paul Dixon 对 Excel 的回答，效果很好。
=POWER(2,CEILING.MATH(LOG(A1)/LOG(2)))
于 2018-09-25T08:01:24.320 回答
0
@YannDroneaud 答案的变体对 有效x==1，仅适用于 x86 平台、编译器、gcc 或 clang：
__attribute__ ((const))
static inline uint32_t p2(uint32_t x)
{
#if 0
assert(x > 0);
assert(x <= ((UINT32_MAX/2) + 1));
#endif
int clz;
uint32_t xm1 = x-1;
asm(
"lzcnt %1,%0"
:"=r" (clz)
:"rm" (xm1)
:"cc"
);
return 1 << (32 - clz);
}
于 2018-10-09T16:39:07.280 回答
0
如果输入是常量表达式，这就是我用来使其成为常量表达式的方法。
#define uptopow2_0(v) ((v) - 1)
#define uptopow2_1(v) (uptopow2_0(v) | uptopow2_0(v) >> 1)
#define uptopow2_2(v) (uptopow2_1(v) | uptopow2_1(v) >> 2)
#define uptopow2_3(v) (uptopow2_2(v) | uptopow2_2(v) >> 4)
#define uptopow2_4(v) (uptopow2_3(v) | uptopow2_3(v) >> 8)
#define uptopow2_5(v) (uptopow2_4(v) | uptopow2_4(v) >> 16)
#define uptopow2(v) (uptopow2_5(v) + 1) /* this is the one programmer uses */
例如，像这样的表达式：
uptopow2(sizeof (struct foo))
会很好地减少到一个常数。
于 2019-02-15T20:19:51.913 回答
0
g++ 编译器提供了一个计算前导零的内置函数 __builtin_clz：
所以我们可以这样做：
int nextPowerOfTwo(unsigned int x) {
return 1 << sizeof(x)*8 - __builtin_clz(x);
}
int main () {
std::cout << nextPowerOfTwo(7) << std::endl;
std::cout << nextPowerOfTwo(31) << std::endl;
std::cout << nextPowerOfTwo(33) << std::endl;
std::cout << nextPowerOfTwo(8) << std::endl;
std::cout << nextPowerOfTwo(91) << std::endl;
return 0;
}
结果：
8
32
64
16
128
但请注意，对于x == 0，__builtin_clzreturn 是未定义的。
于 2021-04-26T02:49:55.530 回答
-1
如果你需要 OpenGL 相关的东西：
/* Compute the nearest power of 2 number that is
* less than or equal to the value passed in.
*/
static GLuint
nearestPower( GLuint value )
{
int i = 1;
if (value == 0) return -1; /* Error! */
for (;;) {
if (value == 1) return i;
else if (value == 3) return i*4;
value >>= 1; i *= 2;
}
}
于 2009-01-21T17:40:57.400 回答
-1
将其转换为浮点数，然后使用 .hex() 显示标准化的 IEEE 表示。
>>> float(789).hex()
'0x1.8a80000000000p+9'
然后只需提取指数并加 1。
>>> int(float(789).hex().split('p+')[1]) + 1
10
并将 2 提高到这个幂。
>>> 2 ** (int(float(789).hex().split('p+')[1]) + 1)
1024
于 2019-10-24T08:02:40.370 回答
-2
import sys
def is_power2(x):
return x > 0 and ((x & (x - 1)) == 0)
def find_nearest_power2(x):
if x <= 0:
raise ValueError("invalid input")
if is_power2(x):
return x
else:
bits = get_bits(x)
upper = 1 << (bits)
lower = 1 << (bits - 1)
mid = (upper + lower) // 2
if (x - mid) > 0:
return upper
else:
return lower
def get_bits(x):
"""return number of bits in binary representation"""
if x < 0:
raise ValueError("invalid input: input should be positive integer")
count = 0
while (x != 0):
try:
x = x >> 1
except TypeError as error:
print(error, "input should be of type integer")
sys.exit(1)
count += 1
return count
于 2020-02-25T01:55:38.517 回答
-2
如果你想要一个单行模板。这里是
int nxt_po2(int n) { return 1 + (n|=(n|=(n|=(n|=(n|=(n-=1)>>1)>>2)>>4)>>8)>>16); }
或者
int nxt_po2(int n) { return 1 + (n|=(n|=(n|=(n|=(n|=(n-=1)>>(1<<0))>>(1<<1))>>(1<<2))>>(1<<3))>>(1<<4)); }
于 2020-05-01T08:56:43.307 回答
-2
from math import ceil, log2
pot_ceil = lambda N: 0x1 << ceil(log2(N))
测试：
for i in range(10):
print(i, pot_ceil(i))
输出：
1 1
2 2
3 4
4 4
5 8
6 8
7 8
8 8
9 16
10 16
于 2021-10-22T10:00:36.193 回答