Cách đơn giản nhất để kiểm tra xem một số có phải là lũy thừa của 2 trong C ++ hay không?

Tôi cần một chức năng như thế này:

// return true iff 'n' is a power of 2, e.g.
// is_power_of_2(16) => true  is_power_of_2(3) => false
bool is_power_of_2(int n);

Bất cứ ai có thể đề nghị làm thế nào tôi có thể viết điều này? Bạn có thể cho tôi biết một trang web tốt có thể tìm thấy loại thuật toán này không?

(n & (n - 1)) == 0là tốt nhất. Tuy nhiên, lưu ý rằng nó sẽ trả về true cho n = 0 một cách không chính xác, vì vậy nếu điều đó có thể xảy ra, bạn sẽ muốn kiểm tra nó một cách rõ ràng.

http://www.graphics.stanford.edu/~seander/bithacks.html có một bộ sưu tập lớn các thuật toán xoay bit thông minh, bao gồm cả thuật toán này.

Một lũy thừa của hai sẽ chỉ có một bit được đặt (đối với các số không có dấu). Cái gì đó như

bool powerOfTwo = !(x == 0) && !(x & (x - 1));

Sẽ hoạt động tốt; một ít hơn lũy thừa của hai đều là 1s trong các bit ít quan trọng hơn, vì vậy phải AND đến 0 theo chiều dọc bit.

Vì tôi đã giả sử các số không có dấu, nên kiểm tra == 0 (mà tôi ban đầu đã quên, xin lỗi) là đủ. Bạn có thể muốn kiểm tra> 0 nếu bạn đang sử dụng số nguyên có dấu.

Quyền hạn của hai trong hệ nhị phân trông như thế này:

1: 0001
2: 0010
4: 0100
8: 1000

Lưu ý rằng luôn có chính xác 1 bit được đặt. Ngoại lệ duy nhất là với một số nguyên có dấu. ví dụ: Một số nguyên có dấu 8 bit với giá trị -128 trông giống như:

10000000

Vì vậy, sau khi kiểm tra rằng số lớn hơn 0, chúng ta có thể sử dụng một mẹo nhỏ thông minh để kiểm tra một số đó và chỉ một bit được đặt.

bool is_power_of_2(int x) {
    return x > 0 && !(x & (x−1));
}

Để biết thêm thông tin chi tiết, hãy xem tại đây .

Cách tiếp cận # 1:

Chia số cho 2 ẩn để kiểm tra nó.

Thời gian phức tạp: O (log2n).

Cách tiếp cận # 2:

Bitwise VÀ số với số trước đó của nó phải bằng ZERO.

Thí dụ: Number = 8 Binary of 8: 1 0 0 0 Binary of 7: 0 1 1 1 và bitwise AND của cả hai số là 0 0 0 0 = 0.

Thời gian phức tạp: O (1).

Cách tiếp cận # 3:

Bitwise XOR số với số trước đó của nó phải là tổng của cả hai số.

Ví dụ: Number = 8 Binary of 8: 1 0 0 0 Binary of 7: 0 1 1 1 và bitwise XOR của cả hai số là 1 1 1 1 = 15.

Độ phức tạp về thời gian: O (1).

http://javaexplorer03.blogspot.in/2016/01/how-to-check-number-is-power-of-two.html

bool is_power_of_2(int i) {
    if ( i <= 0 ) {
        return 0;
    }
    return ! (i & (i-1));
}

đối với bất kỳ lũy thừa nào của 2, điều sau đây cũng được giữ nguyên.

n & (- n) == n

LƯU Ý: Điều kiện đúng với n = 0, mặc dù nó không phải là lũy thừa của 2.
Lý do tại sao điều này hoạt động là:
-n là phần bù 2s của n. -n sẽ có mọi bit ở bên trái của bit đặt ngoài cùng bên phải của n bị lật so với n. Đối với lũy thừa của 2, chỉ có một bit đặt.

Trong C ++ 20 có std::ispow2 , bạn có thể sử dụng chính xác mục đích này nếu bạn không cần tự thực hiện:

#include <bit>
static_assert(std::ispow2(16));
static_assert(!std::ispow2(15));

Đây có lẽ là nhanh nhất, nếu sử dụng GCC. Nó chỉ sử dụng một lệnh POPCNT cpu và một phép so sánh. Biểu diễn nhị phân của bất kỳ lũy thừa nào của 2 số, luôn chỉ có một bit được thiết lập, các bit khác luôn bằng 0. Vì vậy, chúng tôi đếm số bit thiết lập với POPCNT, và nếu nó bằng 1, số đó là lũy thừa của 2. Tôi không nghĩ có bất kỳ phương pháp nào có thể nhanh hơn. Và nó rất đơn giản, nếu bạn đã hiểu nó một lần:

if(1==__builtin_popcount(n))

Sau đó sẽ nhanh hơn câu trả lời được nhiều người bình chọn nhất do đoản mạch boolean và thực tế là so sánh chậm.

int isPowerOfTwo(unsigned int x)
{
  return x && !(x & (x – 1));
}

Nếu bạn biết rằng x không thể là 0 thì

int isPowerOfTwo(unsigned int x)
{
  return !(x & (x – 1));
}

return n > 0 && 0 == (1 << 30) % n;

Cách đơn giản nhất để kiểm tra xem một số có phải là lũy thừa của 2 trong C ++ hay không?

Nếu bạn có bộ xử lý Intel hiện đại với Hướng dẫn thao tác bit , thì bạn có thể thực hiện các thao tác sau. Nó bỏ qua mã C / C ++ thông thường vì những người khác đã trả lời nó, nhưng bạn cần nó nếu BMI không có sẵn hoặc không được kích hoạt.

bool IsPowerOf2_32(uint32_t x)
{
#if __BMI__ || ((_MSC_VER >= 1900) && defined(__AVX2__))
    return !!((x > 0) && _blsr_u32(x));
#endif
    // Fallback to C/C++ code
}

bool IsPowerOf2_64(uint64_t x)
{
#if __BMI__ || ((_MSC_VER >= 1900) && defined(__AVX2__))
    return !!((x > 0) && _blsr_u64(x));
#endif
    // Fallback to C/C++ code
}

Hỗ trợ BMI tín hiệu GCC, ICC và Clang với __BMI__. Nó có sẵn trong trình biên dịch của Microsoft trong Visual Studio 2015 trở lên khi AVX2 có sẵn và được kích hoạt . Đối với các tiêu đề bạn cần, hãy xem Tệp tiêu đề để biết bản chất của SIMD .

Tôi thường bảo vệ _blsr_u64bằng một _LP64_biên dịch trong trường hợp trên i686. Clang cần một chút cách giải quyết vì nó sử dụng một biểu tượng nội tại hơi khác nam:

#if defined(__GNUC__) && defined(__BMI__)
# if defined(__clang__)
#  ifndef _tzcnt_u32
#   define _tzcnt_u32(x) __tzcnt_u32(x)
#  endif
#  ifndef _blsr_u32
#    define  _blsr_u32(x)  __blsr_u32(x)
#  endif
#  ifdef __x86_64__
#   ifndef _tzcnt_u64
#    define _tzcnt_u64(x) __tzcnt_u64(x)
#   endif
#   ifndef _blsr_u64
#     define  _blsr_u64(x)  __blsr_u64(x)
#   endif
#  endif  // x86_64
# endif  // Clang
#endif  // GNUC and BMI

Bạn có thể cho tôi biết một trang web tốt có thể tìm thấy loại thuật toán này không?

Trang web này thường được trích dẫn: Bit Twiddling Hacks .

Đây không phải là cách nhanh nhất hoặc ngắn nhất, nhưng tôi nghĩ nó rất dễ đọc. Vì vậy, tôi sẽ làm một cái gì đó như thế này:

bool is_power_of_2(int n)
  int bitCounter=0;
  while(n) {
    if ((n & 1) == 1) {
      ++bitCounter;
    }
    n >>= 1;
  }
  return (bitCounter == 1);
}

Điều này hoạt động vì hệ nhị phân dựa trên lũy thừa của hai. Bất kỳ số nào chỉ có một bit được đặt phải là lũy thừa của hai.

Đây là một phương pháp khác, trong trường hợp này là sử dụng |thay vì &:

bool is_power_of_2(int x) {
    return x > 0 && (x<<1 == (x|(x-1)) +1));
}

Nó có thể thông qua c ++

int IsPowOf2(int z) {
double x=log2(z);
int y=x;
if (x==(double)y)
return 1;
else
return 0;
}

Tôi biết đây là một bài viết rất cũ, nhưng tôi nghĩ nó có thể thú vị khi đăng bài này ở đây.

Từ Code-Golf SE (vì vậy tất cả ghi công cho (những) người đã viết bài này): Giới thiệu ngôn ngữ

(Đoạn về C , đoạn con Độ dài đoạn 36 )

bool isPow2(const unsigned int num){return!!num&!(num&(num-1));}

Một cách khác để thực hiện (có thể không nhanh nhất) là xác định xem ln (x) / ln (2) có phải là một số nguyên hay không.

Đây là phương pháp dịch chuyển bit trong T-SQL (SQL Server):

SELECT CASE WHEN @X>0 AND (@X) & (@X-1)=0 THEN 1 ELSE 0 END AS IsPowerOfTwo

Nó nhanh hơn rất nhiều so với thực hiện một lôgarit bốn lần (lần đặt đầu tiên để nhận kết quả thập phân, bộ thứ hai để lấy bộ số nguyên và so sánh)