Bir sayının 2'nin gücü olup olmadığı nasıl kontrol edilir

Bugün bir sayının 2'nin gücü olup olmadığını kontrol etmek için basit bir algoritmaya ihtiyacım vardı.

Algoritmanın olması gerekir:

1. Basit
2. Herhangi bir ulongdeğer için düzeltin .

Bu basit algoritmayı buldum:

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

Ama sonra düşündüm, tam olarak yuvarlak bir sayı olup olmadığını kontrol etmeye ne dersiniz ? Ama 2 ^ 63 + 1 için kontrol ettiğimde , yuvarlama nedeniyle tam olarak 63 döndü. Bu nedenle, güç 63'ün 2'sinin orijinal sayıya eşit olup olmadığını kontrol ettim - ve çünkü hesaplama tam sayılarda değil s cinsinden yapılır :log2 xMath.Logdouble

private bool IsPowerOfTwo_2(ulong number)
{
    double log = Math.Log(number, 2);
    double pow = Math.Pow(2, Math.Round(log));
    return pow == number;
}

Bu iade trueverilen yanlış değeri için: 9223372036854775809.

Daha iyi bir algoritma var mı?

Bu sorun için basit bir hile var:

bool IsPowerOfTwo(ulong x)
{
    return (x & (x - 1)) == 0;
}

Not, bu işlev trueiçin 0bir güç değil, rapor verecektir 2. Bunu hariç tutmak istiyorsanız, şu şekilde:

bool IsPowerOfTwo(ulong x)
{
    return (x != 0) && ((x & (x - 1)) == 0);
}

açıklama

Her şeyden önce, bit tanımı ikili ve operatör MSDN tanımından:

İkili ve operatörler, integral tipleri ve bool için önceden tanımlanmıştır. İntegral türler için & mantıksal bitsel VE işlenenlerinin mantıksal hesaplar. Bool işlenenleri için & işlenenlerinin mantıksal AND'ini hesaplar; yani, sonuç yalnızca ve her iki işleneninin de doğru olması durumunda doğrudur.

Şimdi bunların nasıl oynandığına bir göz atalım:

İşlev boolean (true / false) döndürür ve unsigned long türünde bir gelen parametre kabul eder (bu durumda x). Basitlik uğruna, birisinin 4 değerini geçtiğini ve işlevi şöyle çağırdığını varsayalım:

bool b = IsPowerOfTwo(4)

Şimdi x'in her oluşumunu 4 ile değiştiriyoruz:

return (4 != 0) && ((4 & (4-1)) == 0);

Biz zaten biliyoruz ki 4! = 0 gerçek doğrular, şimdiye kadar iyi. Ama ne hakkında:

((4 & (4-1)) == 0)

Bu elbette bununla ilgilidir:

((4 & 3) == 0)

Ama tam olarak nedir 4&3?

4'ün ikili gösterimi 100'dür ve 3'ün ikili gösterimi 011'dir (bu sayıların ikili gösterimini & alır). Böylece sahibiz:

100 = 4
011 = 3

Bu değerlerin, temel toplama gibi yığıldığını düşünün. &Operatör aksi takdirde 0. Yani olduğunu her iki değer 1'e eşit olup olmadığını o zaman sonuç 1 olduğunu söylüyor 1 & 1 = 1, 1 & 0 = 0, 0 & 0 = 0ve 0 & 1 = 0. Bu yüzden matematiği yapıyoruz:

100
011
----
000

Sonuç sadece 0'dır. Bu yüzden geri dönüp iade beyanımızın ne anlama geldiğine bakıyoruz:

return (4 != 0) && ((4 & 3) == 0);

Şimdi şu anlama gelir:

return true && (0 == 0);

return true && true;

Hepimiz true && truebunun basit olduğunu biliyoruz trueve bu, örneğimiz için 4'ün 2'nin gücü olduğunu gösterir.

Bunu belgeleyen ve açıklayan bazı siteler ve diğer bit salaklar:

• 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 )

Ve onların büyükbabası Henry Warren, Jr.'ın "Hacker's Delight" adlı kitabı :

• http://www.hackersdelight.org/

As Sean Anderson'ın sayfa açıklar ifadesi ((x & (x - 1)) == 0)yanlış 0 O kullanımına işaret 2'in üssü olduğunu gösterir:

(!(x & (x - 1)) && x)

bu sorunu düzeltmek için.

return (i & -i) == i

bool IsPowerOfTwo(ulong x)
{
    return x > 0 && (x & (x - 1)) == 0;
}

Bu konuyla ilgili olarak yakın zamanda http://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/ adresinde bir makale yazdım . Bit sayımı, logaritmaların doğru şekilde nasıl kullanılacağı, klasik "x &&! (X & (x - 1))" kontrolü ve diğerlerini kapsar.

İşte basit bir C ++ çözümü:

bool IsPowerOfTwo( unsigned int i )
{
    return std::bitset<32>(i).count() == 1;
}

Kabul edilen cevaba aşağıdaki ek, bazı insanlar için yararlı olabilir:

İkili güç, ikili olarak ifade edildiğinde, her zaman 1 gibi görünür, ardından n sıfır gelir, burada n, sıfırdan büyük veya ona eşittir. Örn:

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)
.        .
.        .
.        .

ve bunun gibi.

Biz çıkardığınızda 1sayıların bu tür, onlar haline n olanlar tarafından takip 0 ve yine n yukarıda aynıdır. Ör:

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)
.          .
.          .
.          .

ve bunun gibi.

En önemli nokta

Bit şeklinde VE bir sayı xolan 2'nin gücü olan ve ne yaptığımızda ne olur x - 1?

Birinin xsıfırı ile hizalanır x - 1ve sıfırların tümü xile hizalanır x - 1, bu da bitsel AND'in 0 ile sonuçlanmasına neden olur. Ve yukarıda belirtilen tek satır cevabının doğru olması bu şekilde olur.

Yukarıda kabul edilen cevabın güzelliğine ek olarak -

Şimdi elimizde bir mülk var:

Herhangi bir sayıdan 1 çıkardığımızda, ikili gösterimde en sağdaki 1 0 olur ve en sağdaki 1'den önceki tüm sıfırlar şimdi 1 olur

Bu özelliğin harika bir kullanımı bulmak - Belirli bir sayının ikili gösteriminde kaç tane 1 var? Belirli bir tamsayı için bunu yapmanın kısa ve tatlı kodu x:

byte count = 0;
for ( ; x != 0; x &= (x - 1)) count++;
Console.Write("Total ones in the binary representation of x = {0}", count);

Sayıların yukarıda açıklanan kavramdan kanıtlanabilecek bir diğer yönü de "Her pozitif sayı 2'nin gücü toplamı olarak temsil edilebilir mi?" .

Evet, her pozitif sayı 2'nin güçlerinin toplamı olarak temsil edilebilir. Herhangi bir sayı için ikili temsilini alın. Örn: Numara al 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

Soruyu gönderdikten sonra aşağıdaki çözümü düşündüm:

İkili rakamlardan birinin tam olup olmadığını kontrol etmeliyiz. Bu yüzden sayıyı bir seferde bir basamak sağa kaydırırız ve true1'e eşitse geri döneriz. Herhangi bir noktada tek bir sayı gelirsek ( (number & 1) == 1), sonucun olduğunu biliyoruz false. Bu, (bir kıyaslama kullanarak) (büyük) gerçek değerler için orijinal yöntemden biraz daha hızlı ve yanlış veya küçük değerler için çok daha hızlı olduğunu kanıtladı.

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

Elbette Greg'in çözümü çok daha iyi.

    bool IsPowerOfTwo(int n)
    {
        if (n > 1)
        {
            while (n%2 == 0)
            {
                n >>= 1;
            }
        }
        return n == 1;
    }

Ve işte bir sayının başka bir sayının gücü olup olmadığını öğrenmek için genel bir algoritma.

    bool IsPowerOf(int n,int b)
    {
        if (n > 1)
        {
            while (n % b == 0)
            {
                n /= b;
            }
        }
        return n == 1;
    }

bool isPow2 = ((x & ~(x-1))==x)? !!x : 0;

Verilen sayının 2 gücü olup olmadığını bulun.

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

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

int isPowerOfTwo(unsigned int x)
{
    return ((x != 0) && ((x & (~x + 1)) == x));
}

Bu gerçekten hızlı. Tüm 2 ^ 32 tam sayılarının kontrol edilmesi yaklaşık 6 dakika 43 saniye sürer.

return ((x != 0) && !(x & (x - 1)));

Eğer xikisinin bir güçtür, onun yalnız 1 bit pozisyonunda n. Bu x – 1, 0 konumunda demektir n. Nedenini görmek için ikili çıkarma işleminin nasıl çalıştığını hatırlayın. 1 çıkarılırken x, borçlanma pozisyonuna kadar yayılır n; bit n0 olur ve tüm alt bitler 1 olur. Şimdi, x1 bit ile ortak olmadığı için x – 1, x & (x – 1)0 ve !(x & (x – 1))doğrudur.

Bir sayı, yalnızca 1 set biti içeriyorsa 2'nin gücüdür. countSetBitsBir sayının 2 gücü olup olmadığını bulmak için bu özelliği ve genel işlevi kullanabiliriz.

Bu bir C ++ programıdır:

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'ın 2 için bir Güç olup olmadığını açıkça kontrol etmemiz gerekmez, çünkü 0 için False değerini de döndürür.

ÇIKTI

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

İşte bu durumda |yerine kullanarak, başka bir yöntem geliştirdi &:

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

2'nin herhangi bir gücü için aşağıdakiler de geçerlidir.

n (- N) == N

NOT: n = 0 için başarısız, bu yüzden kontrol etmeniz gerekir
Neden bu çalışır:
-n n 2s tamamlayıcısıdır. -n, n ile karşılaştırıldığında, her bir bitin sağındaki n ayarlanmış bitin soluna sahip olacaktır. 2 gücü için sadece bir set biti vardır.

Misal

0000 0001    Yes
0001 0001    No

Algoritma

1. Bir bit maskesi kullanarak NUM, değişkeni ikili dosyaya bölün

2. IF R > 0 AND L > 0: Return FALSE

3. Aksi takdirde, NUMsıfır olmayan kişi olur

4. IF NUM = 1: Return TRUE

5. Aksi takdirde, Adım 1'e gidin

karmaşa

Zaman ~ ikili basamak sayısı O(log(d))nereded

@ User134548'in yanıtını aritmetik olmadan iyileştirme:

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

Bu, aşağıdakiler için iyi çalışır:

IsPowerOfTwo(9223372036854775809)

Mark önerdi Gravell bu .NET Çekirdek 3, varsa System.Runtime.Intrinsics.X86.Popcnt.PopCount

public bool IsPowerOfTwo(uint i)
{
    return Popcnt.PopCount(i) == 1
}

Tek komut, daha hızlı (x != 0) && ((x & (x - 1)) == 0)ama daha az taşınabilir.

C'de, i && !(i & (i - 1)hile test ettim __builtin_popcount(i)ve CPU'da gcc kullanarak, CPU'nun POPCNT talimatını kullandığınızdan emin olmak için -mpopcnt bayrağıyla karşılaştırdım. Test programım 0 ile 2 ^ 31 arasında tam sayı olan iki sayıyı saydı.

İlk başta i && !(i & (i - 1)POPCNT'nin kullandığım demontajda kullanıldığını doğrulasam da,% 10 daha hızlı olduğunu düşündüm __builtin_popcount.

Bununla birlikte, bir if ifadesi eklediğimi fark ettim ve şube tahmini muhtemelen biraz dönen versiyonda daha iyi gidiyordu. İf'yi kaldırdım ve POPCNT beklendiği gibi daha hızlı sona erdi.

Sonuçlar:

Intel (R) Core (TM) i7-4771 CPU maksimum 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 Çekirdekli İşlemci max 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

Burada Intel CPU'nun biraz twiddling ile AMD'den biraz daha yavaş göründüğünü, ancak çok daha hızlı bir POPCNT'ye sahip olduğunu unutmayın; AMD POPCNT fazla bir destek sağlamaz.

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

Testleri çalıştırın:

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

Görüyorum ki birçok cevap n &&! (N & (n - 1)) döndürmeyi öneriyor ama benim girişime göre negatif değerler yanlış değerler veriyor. Burada bir başka basit yaklaşım paylaşacağım, çünkü iki sayının gücünün sadece bir set biti olduğunu biliyoruz, bu yüzden O (log N) zamanını alacak set bit sayısını sayarız.

while (n > 0) {
    int count = 0;
    n = n & (n - 1);
    count++;
}
return count == 1;

Hayır saymak için bu makaleye göz atın . set bitlerinin

private static bool IsPowerOfTwo(ulong x)
{
    var l = Math.Log(x, 2);
    return (l == Math.Floor(l));
}

Java 2'deki bir güçse, bu program "true" değerini ve 2'nin bir gücü değilse "false" değerini döndürür.

// To check if the given number is power of 2

import java.util.Scanner;

public class PowerOfTwo {
    int n;
    void solve() {
        while(true) {
//          To eleminate the odd numbers
            if((n%2)!= 0){
                System.out.println("false");
                break;
            }
//  Tracing the number back till 2
            n = n/2;
//  2/2 gives one so condition should be 1
            if(n == 1) {
                System.out.println("true");
                break;
            }
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        PowerOfTwo obj = new PowerOfTwo();
        obj.n = in.nextInt();
        obj.solve();
    }

}

OUTPUT : 
34
false

16
true