Як перевірити, чи число є потужністю 2

Сьогодні мені знадобився простий алгоритм для перевірки, чи число є потужністю 2.

Алгоритм повинен бути:

1. Простий
2. Правильно для будь-якого ulongзначення.

Я придумав такий простий алгоритм:

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

Але тоді я подумав, як щодо перевірки, чи точно кругле число? Але коли я перевірив 2 ^ 63 + 1, повернув рівно 63 через округлення. Тому я перевірив, чи 2 до потужності 63 дорівнює початковому числу - і це так, тому що обчислення проводиться в s, а не в точних числах: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;
}

Повертається trueдля даного неправильного значення: 9223372036854775809.

Чи є кращий алгоритм?

Для цієї проблеми є проста хитрість:

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

Зауважте, ця функція буде звітувати trueдля 0, що не є силою 2. Якщо ви хочете виключити це, ось як:

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

Пояснення

Перш за все, бітовий та бінарний оператор з визначення MSDN:

Двійкові та оператори заздалегідь визначені для інтегральних типів та bool. Для інтегральних типів & обчислює логічний розряд І його операндів. Для операндів bool & обчислює логічний І його операндів; тобто результат істинний тоді і лише тоді, коли обидва його операнди є істинними.

Тепер давайте розглянемо, як це все відбувається:

Функція повертає булеву (true / false) і приймає один вхідний параметр типу unsigned long (x, в даному випадку). Припустимо для простоти припустимо, що хтось передав значення 4 і назвав функцію так:

bool b = IsPowerOfTwo(4)

Тепер ми замінюємо кожне виникнення x на 4:

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

Ну, ми вже знаємо, що 4! = 0 дорівнює справжньому, поки що добре. А як же:

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

Це означає це, звичайно,:

((4 & 3) == 0)

Але що саме таке 4&3?

Двійкове представлення 4 дорівнює 100, а двійкове представлення 3 - 011 (згадайте & приймає двійкове подання цих чисел). Отже, у нас є:

100 = 4
011 = 3

Уявіть, що ці значення складаються так, як елементарне додавання. &Оператор каже , що , якщо обидва значення рівні 1 , то результат буде 1, в іншому випадку він дорівнює 0. Таким чином 1 & 1 = 1, 1 & 0 = 0, 0 & 0 = 0і 0 & 1 = 0. Отже, ми робимо математику:

100
011
----
000

Результат просто 0. Отже, ми повертаємося назад і дивимось, що зараз означає наше повернення:

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

Що зараз перекладається на:

return true && (0 == 0);

return true && true;

Ми всі знаємо, що true && trueце просто true, і це показує, що для нашого прикладу 4 - це сила 2.

Деякі сайти, які документують та пояснюють це та інші хакерські хакі:

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

І онука з них, книга "Хакерське захоплення" Генрі Уоррена, молодшого :

• http://www.hackersdelight.org/

Як пояснює сторінка Шона Андерсона , вираз ((x & (x - 1)) == 0)неправильно вказує на те, що 0 є силою 2. Він пропонує використовувати:

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

щоб виправити цю проблему.

return (i & -i) == i

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

Я написав статтю про це нещодавно на веб- сайті http://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/ . Він охоплює підрахунок бітів, як правильно використовувати логарифми, класичну перевірку "x &&! (X & (x - 1))") та інші.

Ось просте рішення C ++ :

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

Наступний додаток до прийнятої відповіді може бути корисним для деяких людей:

Потужність двох, виражена у двійковій формі, завжди буде виглядати як 1, а потім n нулів, де n більше або дорівнює 0. Наприклад:

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

і так далі.

Коли ми віднімаємо 1від подібних чисел, вони стають 0, а потім n і знову n - те саме, що вище. Наприклад:

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

і так далі.

Наближається до суті

Що відбувається, коли ми робимо порозрядне І числа x, яке є потужністю 2, і x - 1?

Один з xузгоджується з нулем x - 1та всіма нулямиx вирівнюються з одиницями x - 1, призводячи до побітового І, і призводять до 0. І саме так ми маємо відповідь на один рядок, згаданий вище, правильно.

Подальше додавання до краси прийнятої відповіді вище -

Отже, у нас зараз є власність:

Коли ми віднімемо 1 від будь-якого числа, то у двійковому поданні найправіший 1 стане 0 і всі нулі до цього самого правого 1 тепер стануть 1

Одне дивовижне використання цієї властивості полягає у з'ясуванні - скільки 1-х присутні у двійковому поданні даного числа? Короткий і солодкий код для цього для заданого цілого числа x:

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

Ще один аспект чисел, який можна довести з поясненої вище концепції, - це "Чи можна кожне додатне число представити як суму потужностей 2?" .

Так, кожне додатне число може бути представлене як сума повноважень 2. Для будь-якого числа візьміть його двійкове подання. Наприклад: Візьміть номер 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

Після розміщення питання я подумав про наступне рішення:

Нам потрібно перевірити, чи точно одна з двійкових цифр одна. Таким чином, ми просто зміщуємо число праворуч на одну цифру за один раз і повертаємосяtrue якщо воно дорівнює 1. Якщо в будь-який момент ми потрапили на непарне число ( (number & 1) == 1), ми знаємо, що результат є false. Це виявилося (використовуючи орієнтир) трохи швидше, ніж оригінальний метод для (великих) справжніх значень і набагато швидше для помилкових або малих значень.

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

Звичайно, рішення Грега набагато краще.

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

І ось загальний алгоритм з'ясування того, чи є число силою іншого числа.

    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;

Знайдіть, чи задане число є силою 2.

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

Це дійсно швидко. Щоб перевірити всі 2 ^ 32 цілі числа, потрібно 6 хвилин і 43 секунди.

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

Якщо xпотужність дві, його самотній 1 біт знаходиться в положенні n. Це означає, що x – 1має 0 n. Щоб зрозуміти, чому, згадайте, як працює двійкове віднімання. Віднімаючи 1 з x, запозичення поширюється повністю до позиції n; біт nстає 0, а всі нижчі біти стають 1. Тепер, оскільки xне має спільного 1 біта x – 1, x & (x – 1)це 0, і !(x & (x – 1))це правда.

Число є потужністю 2, якщо воно містить лише 1 набір бітів. Ми можемо використовувати цю властивість та загальну функціюcountSetBits щоб виявити, чи є число потужністю 2 чи ні.

Це програма C ++:

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 є потужністю 2, оскільки він також повертає False для 0.

ВИХІД

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

Ось ще один метод, який я розробив, в даному випадку використовуючи |замість &:

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, також виконується наступне

n & (- n) == n

ПРИМІТКА: не вдається n = 0, тому потрібно перевірити це.
Причина, чому це працює:
-n є 2s доповненням n. -n матиме кожен біт ліворуч від правого встановленого біта n перевернутого в порівнянні з n. Для потужностей 2 існує лише один встановлений біт.

Приклад

0000 0001    Yes
0001 0001    No

Алгоритм

1. Використовуючи трохи маски, розділіть NUMзмінну на двійкові

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

3. Інакше NUMстає тим, що не є нульовим

4. IF NUM = 1: Return TRUE

5. В іншому випадку перейдіть до кроку 1

Складність

Час ~, O(log(d))де dкількість двійкових цифр

Поліпшення відповіді @ user134548, без арифметики бітів:

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

Це добре працює для:

IsPowerOfTwo(9223372036854775809)

Марк Гравелл запропонував це, якщо у вас є .NET Core 3, System.Runtime.Intrinsics.X86.Popcnt.PopCount

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

Один інструкція, швидше, (x != 0) && ((x & (x - 1)) == 0)але менш портативна.

У С я випробував i && !(i & (i - 1)трюк і порівняв його__builtin_popcount(i) , використовуючи gcc на Linux, із прапорцем -mpopcnt, щоб обов'язково використовувати інструкцію CPOP POPCNT. Моя тестова програма підраховувала число цілих чисел від 0 до 2 ^ 31, які були потужністю два.

Спочатку я подумав, що i && !(i & (i - 1)це на 10% швидше, хоча я перевірив, що POPCNT використовувався в розбиранні, де я використовував__builtin_popcount .

Однак я зрозумів, що я включив оператор if і передбачення гілок, ймовірно, краще в бітовій версії. Я видалив, якщо і POPCNT закінчився швидше, як очікувалося.

Результати:

Процесор Intel (R) Core (TM) i7-4771 CPU макс. 3,90 ГГц

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-ядерний процесор макс. 3,50 ГГц

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

Зауважте, що тут процесор Intel здається трохи повільнішим, ніж AMD, з бітним подвійним процесом, але має набагато швидший POPCNT; AMD POPCNT не дає стільки збільшення.

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

Виконати тести:

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

Я бачу, що багато відповідей пропонують повернути n&&! (N & (n - 1)), але, на мій досвід, якщо вхідні значення негативні, вони повертають помилкові значення. Я поділюсь тут ще одним простим підходом, оскільки ми знаємо, що потужність двох чисел має лише один набір бітів, тому просто ми будемо рахувати кількість встановлених бітів, це займе час O (log N).

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

Перевірте цю статтю, щоб порахувати ні. заданих бітів

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

Ця програма в Java повертає "true", якщо число є потужністю 2, і повертає "false", якщо це не сила 2

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