มีวิธีที่สวยงามและรวดเร็วในการทดสอบให้ 1 บิตในจำนวนเต็มอยู่ในพื้นที่ที่ติดกันหรือไม่?

ฉันต้องการทดสอบว่าตำแหน่ง (จาก 0 ถึง 31 สำหรับจำนวนเต็ม 32 บิต) ที่มีค่าบิต 1 เป็นพื้นที่ที่ต่อเนื่องกันหรือไม่ ตัวอย่างเช่น:

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)ที่มีไม่ใช่เชิงลบและmn

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

สั้น ๆ :

x & -xให้บิตต่ำสุดที่ตั้งค่าเป็นx(หรือศูนย์ถ้าxเป็นศูนย์)

x + (x & -x) แปลงสตริงต่ำสุดของ 1s ที่ติดต่อกันเป็น 1 เดียว (หรือรวมเป็นศูนย์)

x & x + (x & -x) ล้าง 1 บิตเหล่านั้น

(x & x + (x & -x)) == 0 ทดสอบว่ามี 1 บิตเหลืออยู่หรือไม่

อีกต่อไป:

-xเท่ากับ~x+1โดยใช้สองส่วนเติมเต็มซึ่งเราถือว่า หลังจากพลิกบิต~xแล้วการเพิ่ม 1 การดำเนินการเพื่อให้กลับด้าน 1 บิตต่ำ~xและ 0 บิตแรก แต่จะหยุด ดังนั้นบิตที่ต่ำ-xถึงและรวมถึง 1 แรกจะเหมือนกับบิตต่ำของxแต่บิตที่สูงกว่าทั้งหมดจะถูกพลิก (ตัวอย่าง: ~10011100ให้01100011และการเพิ่ม 1 ให้01100100ดังนั้นค่าต่ำ100จึงเท่ากัน แต่ค่าสูง10011จะถูกปัดไป01100) จากนั้นx & -xให้บิตเดียวที่เป็น 1 ในทั้งสองซึ่งต่ำสุดคือ 1 บิต ( 00000100) (ถ้าxเป็นศูนย์แสดงว่าx & -xเป็นศูนย์)

การเพิ่มสิ่งนี้เพื่อxทำให้เกิดการพกพาตลอด 1 วินาทีที่ต่อเนื่องกันโดยเปลี่ยนเป็น 0 มันจะเหลือ 1 ไว้ที่ 0 บิตที่สูงกว่าถัดไป (หรือนำไปสู่ระดับไฮเอนด์โดยปล่อยให้รวมเป็นศูนย์) ( 10100000.)

เมื่อเป็น AND ด้วยxจะมี 0 ในตำแหน่งที่ 1s เปลี่ยนเป็น 0s (และตำแหน่งที่ carry เปลี่ยน 0 เป็น a 1) ดังนั้นผลลัพธ์จะไม่เป็นศูนย์หากมีอีก 1 บิตที่สูงขึ้น

จริงๆแล้วไม่จำเป็นต้องใช้เนื้อแท้ใด ๆ

ก่อนอื่นให้พลิก 0 ทั้งหมดก่อน 1 ตัวแรกจากนั้นทดสอบว่าค่าใหม่เป็นตัวเลขเมอร์เซนหรือไม่ ในอัลโกนี้ศูนย์จะถูกแมปกับจริง

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

แน่นอนว่าหากคุณต้องการใช้อินทรินนิกส์นี่คือวิธีการป๊อปนับ:

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 intrinsics

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 พร้อมป๊อปเคานต์เท่านั้น

หากคุณใช้ 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;
}

การแคสต์นั้นน่าเกลียด แต่ขอเตือนคุณว่าควรใช้งานประเภทที่ไม่ได้ลงชื่อเมื่อจัดการกับบิต Pre-C ++ 20 ทางเลือกคือboost::multiprecision::lsb.

แก้ไข:

เกณฑ์มาตรฐานของลิงก์ขีดฆ่าถูก จำกัด โดยข้อเท็จจริงที่ว่าไม่มีการแสดงคำสั่งป๊อปเคานต์สำหรับเวอร์ชัน Yuri Feldman พยายามรวบรวมไว้ในพีซีของฉันด้วย-march=westmereฉันได้วัดเวลาต่อไปนี้สำหรับการทำซ้ำ 1 พันล้านครั้งโดยมีลำดับที่เหมือนกันจากstd::mt19937:

• เวอร์ชันของคุณ: 5.7 วินาที
• เวอร์ชันที่สองของ KamilCuk: 4.7 วินาที
• เวอร์ชันของฉัน: 4.7 วินาที
• เวอร์ชันแรกของ Eric Postpischil: 4.3 วินาที
• เวอร์ชันของ Yuri Feldman (โดยใช้อย่างชัดเจน__builtin_popcount): 4.1 วินาที

ดังนั้นอย่างน้อยที่สุดในสถาปัตยกรรมของฉันสิ่งที่เร็วที่สุดน่าจะเป็นสถาปัตยกรรมที่มีป๊อปเคานต์

แก้ไข 2:

ฉันได้อัปเดตเกณฑ์มาตรฐานของฉันด้วยเวอร์ชันใหม่ของ Eric Postpischil ตามที่ร้องขอในความคิดเห็นที่รหัสของการทดสอบของฉันสามารถพบได้ที่นี่ ฉันได้เพิ่มลูปแบบไม่ต้องใช้เพื่อประมาณเวลาที่ PRNG ต้องการ ฉันได้เพิ่มทั้งสองเวอร์ชันโดย KevinZ รหัสได้รับการรวบรวมในเสียงดัง-O3 -msse4 -mbmiเพื่อรับpopcntและ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 ++ portably exposes popcount ผ่านstd::bitset::count()หรือใน C ++ 20 std::popcountผ่าน C ยังไม่มีวิธีแบบพกพาที่สามารถรวบรวมคำสั่ง popcnt หรือคำสั่งที่คล้ายกันได้อย่างน่าเชื่อถือสำหรับเป้าหมายที่มีอยู่

ซีพียูมีคำสั่งเฉพาะสำหรับสิ่งนั้นเร็วมาก บนพีซีเป็น BSR / BSF (เปิดตัวใน 80386 ในปี 1985) บน ARM คือ CLZ / CTZ

ใช้หนึ่งเพื่อค้นหาดัชนีของบิตชุดที่มีนัยสำคัญน้อยที่สุดเลื่อนจำนวนเต็มไปทางขวาตามจำนวนนั้น ใช้อีกอันหนึ่งเพื่อหาดัชนีของบิตชุดที่สำคัญที่สุดเปรียบเทียบจำนวนเต็มของคุณกับ (1u << (bsr + 1)) - 1

น่าเสียดายที่ 35 ปีไม่เพียงพอที่จะอัปเดตภาษา C ++ ให้เข้ากับฮาร์ดแวร์ ในการใช้คำแนะนำเหล่านี้จาก C ++ คุณจะต้องมีอินทรินส์ซึ่งไม่ใช่แบบพกพาและส่งคืนผลลัพธ์ในรูปแบบที่แตกต่างกันเล็กน้อย ใช้ตัวประมวลผลล่วงหน้า#ifdefฯลฯ เพื่อตรวจหาคอมไพเลอร์แล้วใช้อินทรินซิคที่เหมาะสม ใน MSVC พวกเขามี_BitScanForward, _BitScanForward64, ,_BitScanReverse _BitScanReverse64ใน GCC และส่งเสียงดังพวกเขา__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 -O3บน x86_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 ให้ตอบว่าใช่ (เพราะ 1s ทั้งหมดอยู่ด้านเดียว)
• ถ้า 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ทีละตำแหน่งเพื่อให้ต่ำกว่า LSB จริงเล็กน้อยvalและทำกิจวัตรเดียวกันกับx:

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

จากนั้นx - yหรือx & ~yหรือx ^ yสร้างมาสก์บิต 'กะทัดรัด' ที่ครอบคลุมความยาวทั้งหมดของval. เพียงเปรียบเทียบvalเพื่อดูว่าval"กะทัดรัด" หรือไม่

เราสามารถใช้คำแนะนำในตัว gccเพื่อตรวจสอบว่า:

จำนวนชุดบิต

int __builtin_popcount (ไม่ได้ลงชื่อ int x)
ส่งกลับจำนวน 1 บิตใน x

เท่ากับ (a - b):

ก : ดัชนีของบิตชุดสูงสุด (32 - CTZ) (32 เพราะ 32 บิตในจำนวนเต็มไม่ได้ลงชื่อ)

int __builtin_clz (int x ที่ไม่ได้ลงนาม)
ส่งกลับจำนวนของ 0 บิตนำหน้าใน x โดยเริ่มต้นที่ตำแหน่งบิตที่สำคัญที่สุด ถ้า x เป็น 0 ผลลัพธ์จะไม่ถูกกำหนด

b : ดัชนีของบิตชุดต่ำสุด (CLZ):

int __builtin_clz (int x ที่ไม่ได้ลงนาม)
ส่งกลับจำนวนของ 0 บิตนำหน้าใน x โดยเริ่มต้นที่ตำแหน่งบิตที่สำคัญที่สุด ถ้า x เป็น 0 ผลลัพธ์จะไม่ถูกกำหนด

ตัวอย่างเช่นถ้า n = 0b0001100110; เราจะได้รับ 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;
}

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