วิธีที่ง่ายที่สุดในการทดสอบว่าตัวเลขเป็นเลขยกกำลัง 2 ใน C ++ อย่างไร

ฉันต้องการฟังก์ชั่นเช่นนี้:

// 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);

ใครช่วยแนะนำว่าฉันจะเขียนสิ่งนี้ได้อย่างไร คุณช่วยบอกฉันว่ามีเว็บไซต์ดีๆที่สามารถหาอัลกอริทึมประเภทนี้ได้ไหม

(n & (n - 1)) == 0ดีที่สุด อย่างไรก็ตามโปรดทราบว่าค่านี้จะคืนค่าจริงสำหรับ n = 0 อย่างไม่ถูกต้องดังนั้นหากเป็นไปได้คุณจะต้องตรวจสอบอย่างชัดเจน

http://www.graphics.stanford.edu/~seander/bithacks.htmlมีชุดอัลกอริทึมที่ชาญฉลาดจำนวนมากรวมถึงอัลกอริทึมนี้ด้วย

กำลังของสองจะมีชุดบิตเพียงชุดเดียว (สำหรับตัวเลขที่ไม่ได้ลงชื่อ) สิ่งที่ต้องการ

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

จะทำงานได้ดี; หนึ่งน้อยกว่ากำลังของสองคือ 1 ทั้งหมดในบิตที่มีนัยสำคัญน้อยกว่าดังนั้นต้อง AND ถึง 0 บิต

เนื่องจากฉันสมมติว่าเป็นตัวเลขที่ไม่ได้ลงชื่อการทดสอบ == 0 (ซึ่งตอนแรกฉันลืมไปแล้วขออภัย) ก็เพียงพอแล้ว คุณอาจต้องการการทดสอบ> 0 หากคุณใช้จำนวนเต็มที่ลงชื่อ

พลังของสองในไบนารีมีลักษณะดังนี้:

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

โปรดทราบว่าจะมีการตั้งค่า 1 บิตเสมอ ข้อยกเว้นเพียงประการเดียวคือจำนวนเต็มที่ลงนาม เช่นจำนวนเต็มที่ลงนาม 8 บิตที่มีค่า -128 ดูเหมือนว่า:

10000000

ดังนั้นหลังจากตรวจสอบว่าจำนวนมากกว่าศูนย์เราสามารถใช้การแฮ็กเล็กน้อยที่ชาญฉลาดเพื่อทดสอบว่ามีการตั้งค่าหนึ่งบิตเพียงหนึ่งบิต

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

สำหรับ twiddling บิตเพิ่มเติมโปรดดูที่นี่

แนวทาง # 1:

หารตัวเลขด้วย 2 อย่างชัดเจนเพื่อตรวจสอบ

ความซับซ้อนของเวลา: O (log2n)

แนวทาง # 2:

Bitwise AND ตัวเลขที่มีตัวเลขก่อนหน้าควรเท่ากับศูนย์

ตัวอย่าง: Number = 8 Binary ของ 8: 1 0 0 0 Binary ของ 7: 0 1 1 1 และ bitwise AND ของตัวเลขทั้งสองคือ 0 0 0 0 = 0

ความซับซ้อนของเวลา: O (1)

แนวทาง # 3:

Bitwise XOR ตัวเลขที่มีหมายเลขก่อนหน้าควรเป็นผลรวมของตัวเลขทั้งสอง

ตัวอย่าง: Number = 8 Binary of 8: 1 0 0 0 Binary of 7: 0 1 1 1 และ bitwise XOR ของทั้งสองตัวเลขคือ 1 1 1 1 = 15

ความซับซ้อนของเวลา: 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));
}

สำหรับอำนาจใด ๆ ของ 2 สิ่งต่อไปนี้จะถือด้วย

n & (- n) == น

หมายเหตุ: เงื่อนไขนี้เป็นจริงสำหรับ n = 0 แม้ว่าจะไม่ใช่กำลังของ 2
ก็ตามเหตุผลว่าทำไมจึงใช้ได้:
-n คือส่วนเติมเต็ม 2s ของ n -n จะมีบิตทุกบิตทางด้านซ้ายของชุดด้านขวาสุดของ n พลิกเทียบกับ n สำหรับพาวเวอร์ของ 2 มีบิตชุดเดียวเท่านั้น

ซึ่งอาจเร็วที่สุดหากใช้ GCC ใช้เฉพาะคำสั่ง POPCNT cpu และการเปรียบเทียบหนึ่งรายการ การแทนค่าเลขฐานสองของเลขยกกำลัง 2 จำนวนมีเพียงชุดบิตเดียวเสมอส่วนบิตอื่น ๆ จะเป็นศูนย์เสมอ ดังนั้นเราจึงนับจำนวนบิตที่กำหนดด้วย POPCNT และถ้ามันเท่ากับ 1 จำนวนนั้นจะเป็น 2 ฉันไม่คิดว่าจะมีวิธีใดที่เร็วกว่านี้ได้ และมันง่ายมากถ้าคุณเข้าใจมันสักครั้ง:

if(1==__builtin_popcount(n))

ใน C ++ 20 มีสิ่งstd::ispow2ที่คุณสามารถใช้เพื่อจุดประสงค์นี้หากคุณไม่จำเป็นต้องใช้งานด้วยตัวเอง:

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

ต่อไปนี้จะเร็วกว่าคำตอบที่ได้รับการโหวตมากที่สุดเนื่องจากการลัดวงจรแบบบูลีนและข้อเท็จจริงที่ว่าการเปรียบเทียบช้า

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

ถ้าคุณรู้ว่า x ไม่สามารถเป็น 0 ได้

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

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

วิธีที่ง่ายที่สุดในการทดสอบว่าตัวเลขเป็นเลขยกกำลัง 2 ใน C ++ อย่างไร

หากคุณมีโปรเซสเซอร์ Intel ที่ทันสมัยพร้อมคำแนะนำในการจัดการบิตคุณสามารถดำเนินการดังต่อไปนี้ มันละเว้นรหัส C / C ++ ตรงเพราะคนอื่นตอบไปแล้ว แต่คุณต้องใช้ถ้า BMI ไม่พร้อมใช้งานหรือเปิดใช้งาน

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
}

GCC, ICC และ Clang signal BMI รองรับด้วย__BMI__. มันมีอยู่ในคอมไพเลอร์ไมโครซอฟท์ใน Visual Studio 2015 และสูงกว่าเมื่อAVX2 สามารถใช้ได้และเปิดใช้งาน สำหรับส่วนหัวที่คุณต้องการโปรดดูที่ไฟล์ส่วนหัวสำหรับ SIMD ภายในintrinsics

ฉันมักจะป้องกัน_blsr_u64ด้วย_LP64_ในกรณีที่รวบรวมบน i686 เสียงดังต้องการวิธีแก้ปัญหาเล็กน้อยเนื่องจากใช้ชื่อสัญลักษณ์ภายในที่แตกต่างกันเล็กน้อย:

#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

คุณช่วยบอกฉันได้ไหมว่ามีเว็บไซต์ดีๆที่สามารถหาอัลกอริทึมประเภทนี้ได้

เว็บไซต์นี้มักจะอ้าง: Bit twiddling Hacks

นี่ไม่ใช่วิธีที่เร็วที่สุดหรือสั้นที่สุด แต่ฉันคิดว่ามันอ่านง่ายมาก ดังนั้นฉันจะทำสิ่งนี้:

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

สิ่งนี้ใช้ได้ผลเนื่องจากไบนารีขึ้นอยู่กับกำลังสอง ตัวเลขใด ๆ ที่มีเพียงชุดบิตเดียวจะต้องเป็นเลขยกกำลังสอง

นี่เป็นอีกวิธีหนึ่งในกรณีนี้โดยใช้|แทน&:

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

เป็นไปได้ผ่าน c ++

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

ฉันรู้ว่านี่เป็นโพสต์เก่ามากแต่ฉันคิดว่ามันน่าสนใจที่จะโพสต์ที่นี่

จากCode-Golf SE (เพื่อให้เครดิตกับผู้ที่เขียนสิ่งนี้): Showcase of Languages

(ย่อหน้าเกี่ยวกับC , อนุวรรคยาว 36 ข้อมูลโค้ด )

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

อีกวิธีที่จะไป (อาจจะไม่เร็วที่สุด) คือการกำหนดว่า ln (x) / ln (2) เป็นจำนวนเต็มหรือไม่

นี่คือวิธีการบิตกะใน T-SQL (SQL Server):

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

เร็วกว่าการทำลอการิทึมสี่เท่า (ชุดแรกเพื่อให้ได้ผลลัพธ์ทศนิยมชุดที่ 2 เพื่อรับชุดจำนวนเต็มและเปรียบเทียบ)