Підрахуйте число 1 в двійковому поданні

Ефективний спосіб підрахувати кількість 1s у двійковому поданні числа в O (1), якщо у вас є достатньо пам’яті для гри. Це запитання для інтерв’ю, яке я знайшов на форумі в Інтернеті, але на нього не було відповіді. Хтось може щось підказати, я не можу придумати, як це зробити за час O (1)?

Це проблема ваги Хеммінга , вона ж кількість населення. Посилання згадує про ефективні реалізації. Цитування:

Маючи необмежену пам’ять, ми могли просто створити велику таблицю пошуку ваги Хеммінга кожного 64-бітного цілого числа

У мене є рішення, яке підраховує біти в O(Number of 1's)часі:

bitcount(n):
    count = 0
    while n > 0:
        count = count + 1
        n = n & (n-1)
    return count

У гіршому випадку (коли число 2 ^ n - 1, усі одиниці в двійковому вигляді) він буде перевіряти кожен біт.

Редагувати: Щойно знайшов дуже приємний алгоритм постійної пам’яті, постійної пам’яті для кількості бітів. Ось воно, написане на C:

int BitCount(unsigned int u)
{
     unsigned int uCount;

     uCount = u - ((u >> 1) & 033333333333) - ((u >> 2) & 011111111111);
     return ((uCount + (uCount >> 3)) & 030707070707) % 63;
}

Доказ його правильності ви можете знайти тут .

Зверніть увагу на той факт, що: n & (n-1) завжди виключає найменш значущу 1.

Звідси ми можемо написати код для обчислення числа 1 наступним чином:

count=0;
while(n!=0){
  n = n&(n-1);
  count++;
}
cout<<"Number of 1's in n is: "<<count;

Складність програми буде такою: число одиниць в n (що постійно <32).

Я побачив таке рішення з іншого веб-сайту:

int count_one(int x){
    x = (x & (0x55555555)) + ((x >> 1) & (0x55555555));
    x = (x & (0x33333333)) + ((x >> 2) & (0x33333333));
    x = (x & (0x0f0f0f0f)) + ((x >> 4) & (0x0f0f0f0f));
    x = (x & (0x00ff00ff)) + ((x >> 8) & (0x00ff00ff));
    x = (x & (0x0000ffff)) + ((x >> 16) & (0x0000ffff));
    return x;
}

public static void main(String[] args) {

    int a = 3;
    int orig = a;
    int count = 0;
    while(a>0)
    {
        a = a >> 1 << 1;
        if(orig-a==1)
            count++;
        orig = a >> 1;
        a = orig;
    }

    System.out.println("Number of 1s are: "+count);
}

   countBits(x){
     y=0;
     while(x){   
       y += x &  1 ;
       x  = x >> 1 ;
     }
   }

Це воно?

Це буде найкоротша відповідь у моєму житті SO: таблиця пошуку.

Очевидно, мені потрібно трохи пояснити: "якщо у вас достатньо пам'яті, з якою можна пограти", означає, що у нас є вся потрібна пам'ять (не зважаючи на технічну можливість). Тепер вам не потрібно зберігати таблицю пошуку більше, ніж байт або два. Хоча технічно це буде Ω (log (n)), а не O (1), просто зчитування потрібного вам числа є Ω (log (n)), тож якщо це проблема, то відповідь неможлива - що ще коротше.

Якої з двох відповідей вони чекають від вас на співбесіді, ніхто не знає.

Існує ще одна хитрість: в той час як інженери можуть взяти число і поговорити про Ω (log (n)), де n - це число, вчені-комп’ютерники скажуть, що насправді ми повинні вимірювати час роботи як функцію довжини введення , отже, те, що інженери називають Ω (log (n)), насправді є Ω (k), де k - кількість байтів. І все-таки, як я вже говорив раніше, просто читання числа дорівнює Ω (k), тож ми не можемо зробити краще цього.

Нижче також буде працювати.

nofone(int x) {
  a=0;
  while(x!=0) {
    x>>=1;
    if(x & 1)
      a++;
  }
  return a;
} 

Нижче наведено рішення C із використанням бітових операторів:

int numberOfOneBitsInInteger(int input) {
  int numOneBits = 0;

  int currNum = input;
  while (currNum != 0) {
    if ((currNum & 1) == 1) {
      numOneBits++;
    }
    currNum = currNum >> 1;
  }
  return numOneBits;
}

Далі подано рішення Java, що використовує повноваження 2:

public static int numOnesInBinary(int n) {

  if (n < 0) return -1;

  int j = 0;
  while ( n > Math.pow(2, j)) j++;

  int result = 0;
  for (int i=j; i >=0; i--){
    if (n >= Math.pow(2, i)) {
        n = (int) (n - Math.pow(2,i));
        result++;    
    }
  }

  return result;
}

Нижче наведено два простих приклади (на C ++), серед яких ви можете це зробити.

1. Ми можемо просто порахувати встановлені біти (1) за допомогою __builtin_popcount ().

   int numOfOnes(int x) { return __builtin_popcount(x); }

2. Прокрутіть усі біти у цілому числі, перевірте, чи встановлений біт, і якщо він потім, збільште змінну count.

   int hammingDistance(int x) { int count = 0 for(int i = 0; i < 32; i++) if(x & (1 << i)) count++; return count; }

Сподіваюся, це допомагає!

Функція приймає intі повертає кількість Онів у двійковому поданні

public static int findOnes(int number)
{

   if(number < 2)
    {
        if(number == 1)
        {
            count ++;
        }
        else
        {
            return 0;
        }
    }

    value = number % 2;

    if(number != 1 && value == 1)
        count ++;

    number /= 2;

    findOnes(number);

    return count;
}

Найкращий спосіб у javascript це зробити

function getBinaryValue(num){
 return num.toString(2);
}

function checkOnces(binaryValue){
    return binaryValue.toString().replace(/0/g, "").length;
}

де binaryValue - це двійковий рядок, наприклад: 1100

Існує лише один спосіб, яким я можу придумати виконати це завдання в O (1) ... це "обдурити" і використовувати фізичний пристрій (при лінійному або навіть паралельному програмуванні, на мою думку, обмеження - O (log (k)) де k являє собою кількість байтів числа).

Однак ви могли б дуже легко уявити фізичний пристрій, який з'єднує кожен біт і вихідну лінію напругою 0/1. Тоді ви могли просто прочитати в електронній мережі загальну напругу на лінії 'підсумовування' в O (1). Було б досить легко зробити цю базову ідею більш елегантною за допомогою деяких основних елементів схеми, щоб отримати вихід у будь-якій формі, яку ви хочете (наприклад, двійково закодований вихід), але основна ідея та сама, і електронна схема дасть правильний результат стан у встановлений час.

Я гадаю, є також можливі квантові обчислення, але якщо нам це дозволено, я думаю, простіші електронні схеми є простішим рішенням.

Я насправді зробив це, використовуючи трохи спритності: достатньо однієї таблиці пошуку з 16 записами, і все, що вам потрібно зробити, це розбити двійковий реп на ключки (4-бітні кортежі). Складність насправді O (1), і я написав шаблон C ++, який спеціалізувався на розмірі цілого числа, яке ви хотіли (у # ​​бітах) ... робить його постійним виразом, а не невизначеним.

fwiw ви можете використовувати той факт, що (i & -i) поверне вам LS однобітний і просто цикл, щоразу знімаючи lsbit, доки ціле число не буде нульовим - але це стара хитрість паритету.

Я прийшов сюди, переконавшись, що знаю прекрасне рішення цієї проблеми. Код на C:

    short numberOfOnes(unsigned int d) {
        short count = 0;

        for (; (d != 0); d &= (d - 1))
            ++count;

        return count;
    }

Але після невеликого дослідження на цю тему (прочитайте інші відповіді :)) я знайшов 5 більш ефективних алгоритмів. Любіть ТАК!

Існує навіть інструкція CPU розроблений спеціально для вирішення цього завдання: popcnt. (згадане у цій відповіді )

Опис та порівняльний аналіз багатьох алгоритмів ви можете знайти тут .

Наведений нижче метод також може підрахувати кількість одиниць у від’ємних числах.

private static int countBits(int number)    {
    int result = 0;
    while(number != 0)  {
        result += number & 1;
        number = number >>> 1;
    }
    return result;
}

Однак число, подібне до -1, представлене у двійковому вигляді як 1111111111111111111111111111111111, і тому буде потрібно багато змін. Якщо ви не хочете робити стільки змін для малих від’ємних чисел, іншим способом може бути такий:

private static int countBits(int number)    {
    boolean negFlag = false;
    if(number < 0)  { 
        negFlag = true;
        number = ~number;
    }

    int result = 0;
    while(number != 0)  {
        result += number & 1;
        number = number >> 1;
    }
    return negFlag? (32-result): result;
}

У python або будь-якому іншому перетворенні в рядок bin, потім розділіть його на "0", щоб позбутися нулів, потім об'єднайте і отримайте довжину.

len(''.join(str(bin(122011)).split('0')))-1

Використовуючи рядкові операції JS, можна зробити наступне;

0b1111011.toString(2).split(/0|(?=.)/).length // returns 6

або

0b1111011.toString(2).replace("0","").length  // returns 6

Мені довелося гольфувати це в рубіні, і в підсумку

l=->x{x.to_s(2).count ?1}

Використання:

l[2**32-1] # returns 32

Очевидно, неефективний, але робить фокус :)

Впровадження Ruby

def find_consecutive_1(n)
  num = n.to_s(2)
  arr = num.split("")
  counter = 0
  max = 0
  arr.each do |x|
      if x.to_i==1
          counter +=1
      else
          max = counter if counter > max
          counter = 0 
      end
      max = counter if counter > max  
  end
  max
end

puts find_consecutive_1(439)

Два шляхи ::

/* Method-1 */
int count1s(long num)
{
    int tempCount = 0;

    while(num)
    {
        tempCount += (num & 1); //inc, based on right most bit checked
        num = num >> 1;         //right shift bit by 1
    }

    return tempCount;
}

/* Method-2 */
int count1s_(int num)
{
    int tempCount = 0;

    std::string strNum = std::bitset< 16 >( num ).to_string(); // string conversion
    cout << "strNum=" << strNum << endl;
    for(int i=0; i<strNum.size(); i++)
    {
        if('1' == strNum[i])
        {
            tempCount++;
        }
    }

    return tempCount;
}

/* Method-3 (algorithmically - boost string split could be used) */
1) split the binary string over '1'.
2) count = vector (containing splits) size - 1

Використання ::

    int count = 0;

    count = count1s(0b00110011);
    cout << "count(0b00110011) = " << count << endl; //4

    count = count1s(0b01110110);
    cout << "count(0b01110110) = " << count << endl;  //5

    count = count1s(0b00000000);
    cout << "count(0b00000000) = " << count << endl;  //0

    count = count1s(0b11111111);
    cout << "count(0b11111111) = " << count << endl;  //8

    count = count1s_(0b1100);
    cout << "count(0b1100) = " << count << endl;  //2

    count = count1s_(0b11111111);
    cout << "count(0b11111111) = " << count << endl;  //8

    count = count1s_(0b0);
    cout << "count(0b0) = " << count << endl;  //0

    count = count1s_(0b1);
    cout << "count(0b1) = " << count << endl;  //1