Швидкий спосіб підрахунку ненульових бітів у натуральному цілому

Мені потрібен швидкий спосіб підрахунку кількості бітів у цілому цілому в python. Моє поточне рішення

bin(n).count("1")

але мені цікаво, чи існує якийсь швидший спосіб зробити це?

PS: (Я представляю великий двовимірний двійковий масив у вигляді єдиного списку чисел і роблю побітові операції, і це зводить час з годин на хвилини. Тепер я хотів би позбутися цих додаткових хвилин.

Редагувати: 1. він повинен бути в python 2.7 або 2.6

і оптимізація для невеликих чисел не має великого значення, оскільки це не було б чітким вузьким місцем, але у мене є цифри з 10 000 + бітами в деяких місцях

наприклад, це 2000-бітний випадок:

12448057941136394342297748548545082997815840357634948550739612798732309975923280685245876950055614362283769710705811182976142803324242407017104841062064840113262840137625582646683068904149296501029754654149991842951570880471230098259905004533869130509989042199261339990315125973721454059973605358766253998615919997174542922163484086066438120268185904663422979603026066685824578356173882166747093246377302371176167843247359636030248569148734824287739046916641832890744168385253915508446422276378715722482359321205673933317512861336054835392844676749610712462818600179225635467147870208L

Для цілих цілей довільної довжини bin(n).count("1")- це найшвидший, який я міг знайти в чистому Python.

Я спробував адаптувати рішення Оскара та Адама для обробки цілого числа в 64-бітних та 32-бітових фрагментах відповідно. Обидва були принаймні в десять разів повільнішими bin(n).count("1")(32-бітна версія забирала приблизно вдвічі більше часу).

З іншого боку, gmpy popcount() зайняла близько 1/20-го часу bin(n).count("1"). Тож якщо ви можете встановити gmpy, використовуйте це.

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

counts = bytes(bin(x).count("1") for x in range(256))  # py2: use bytearray

Або просто визначте це буквально:

counts = (b'\x00\x01\x01\x02\x01\x02\x02\x03\x01\x02\x02\x03\x02\x03\x03\x04'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x01\x02\x02\x03\x02\x03\x03\x04\x02\x03\x03\x04\x03\x04\x04\x05'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x03\x04\x04\x05\x04\x05\x05\x06\x04\x05\x05\x06\x05\x06\x06\x07'
          b'\x04\x05\x05\x06\x05\x06\x06\x07\x05\x06\x06\x07\x06\x07\x07\x08')

Тоді counts[x]потрібно отримати кількість 1 біт, xде 0 ≤ x ≤ 255.

Можна адаптувати наступний алгоритм:

def CountBits(n):
  n = (n & 0x5555555555555555) + ((n & 0xAAAAAAAAAAAAAAAA) >> 1)
  n = (n & 0x3333333333333333) + ((n & 0xCCCCCCCCCCCCCCCC) >> 2)
  n = (n & 0x0F0F0F0F0F0F0F0F) + ((n & 0xF0F0F0F0F0F0F0F0) >> 4)
  n = (n & 0x00FF00FF00FF00FF) + ((n & 0xFF00FF00FF00FF00) >> 8)
  n = (n & 0x0000FFFF0000FFFF) + ((n & 0xFFFF0000FFFF0000) >> 16)
  n = (n & 0x00000000FFFFFFFF) + ((n & 0xFFFFFFFF00000000) >> 32) # This last & isn't strictly necessary.
  return n

Це працює для 64-бітних позитивних чисел, але їх легко розширити, а кількість операцій зростає логарифмом аргументу (тобто лінійно з розміром біта аргументу).

Для того, щоб зрозуміти, як це працює, уявіть, що ви розділите всю 64-бітну рядок на 64 1-бітні відра. Значення кожного відра дорівнює кількості бітів, встановлених у відрі (0, якщо бітів не встановлено, і 1, якщо встановлено один біт). Перша трансформація призводить до аналогічного стану, але з 32 відрами довжиною в 2 біти. Це досягається відповідним зміщенням відра та додаванням їх значень (одне доповнення піклується про всі відра, оскільки жодне перенесення не може відбуватися через відра - n-бітове число завжди досить довге, щоб кодувати число n). Подальші перетворення призводять до станів із експоненціально зменшенням кількості відер експоненціально зростаючого розміру, поки ми не отримаємо одне 64-бітове довге відро. Це дає кількість бітів, встановлених у вихідному аргументі.

Ось реалізація алгоритмом підрахунку кількості населення Python, як це пояснено у цій публікації :

def numberOfSetBits(i):
    i = i - ((i >> 1) & 0x55555555)
    i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
    return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24

Це буде працювати 0 <= i < 0x100000000.

Згідно з цим повідомленням , здається, це одна з найшвидших реалізацій ваги Хеммінга (якщо ви не заперечуєте, використовуючи близько 64 КБ пам'яті).

#http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable
POPCOUNT_TABLE16 = [0] * 2**16
for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

На Python 2.x ви повинні замінити rangeз xrange.

Редагувати

Якщо вам потрібна краща продуктивність (а ваші числа великі цілі числа), погляньте на GMPбібліотеку. Він містить власноруч написані варіанти складання для багатьох різних архітектур.

gmpy являє собою модуль розширення Python, кодований С, який охоплює бібліотеку GMP.

>>> import gmpy
>>> gmpy.popcount(2**1024-1)
1024

Мені дуже подобається цей метод. Його простий і досить швидкий, але також не обмежений у довжині біт, оскільки python має нескінченні цілі числа.

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

def get_bit_count(value):
   n = 0
   while value:
      n += 1
      value &= value-1
   return n

Ви можете використовувати алгоритм, щоб отримати двійковий рядок [1] ​​цілого числа, але замість об'єднання рядка, підраховуючи кількість одиниць:

def count_ones(a):
    s = 0
    t = {'0':0, '1':1, '2':1, '3':2, '4':1, '5':2, '6':2, '7':3}
    for c in oct(a)[1:]:
        s += t[c]
    return s

[1] https://wiki.python.org/moin/BitManipulation

Ви сказали, що Numpy був надто повільним. Ви використовували його для зберігання окремих біт? Чому б не розширити ідею використання ints як бітових масивів, а використовувати Numpy для їх зберігання?

Збережіть n біт як масив ceil(n/32.)32-бітових ints. Потім ви можете працювати з numpy масивом тим же (ну, досить схожим), як ви використовуєте ints, включаючи їх використання для індексації іншого масиву.

В основному алгоритм обчислює паралельно кількість бітів, встановлених у кожній комірці, і їх підсумовують бітові рахунки кожної комірки.

setup = """
import numpy as np
#Using Paolo Moretti's answer http://stackoverflow.com/a/9829855/2963903
POPCOUNT_TABLE16 = np.zeros(2**16, dtype=int) #has to be an array

for index in range(len(POPCOUNT_TABLE16)):
    POPCOUNT_TABLE16[index] = (index & 1) + POPCOUNT_TABLE16[index >> 1]

def popcount32_table16(v):
    return (POPCOUNT_TABLE16[ v        & 0xffff] +
            POPCOUNT_TABLE16[(v >> 16) & 0xffff])

def count1s(v):
    return popcount32_table16(v).sum()

v1 = np.arange(1000)*1234567                       #numpy array
v2 = sum(int(x)<<(32*i) for i, x in enumerate(v1)) #single int
"""
from timeit import timeit

timeit("count1s(v1)", setup=setup)        #49.55184188873349
timeit("bin(v2).count('1')", setup=setup) #225.1857464598633

Хоча я здивований, ніхто не запропонував вам написати модуль С.

#Python prg to count set bits
#Function to count set bits
def bin(n):
    count=0
    while(n>=1):
        if(n%2==0):
            n=n//2
        else:
            count+=1
            n=n//2
    print("Count of set bits:",count)
#Fetch the input from user
num=int(input("Enter number: "))
#Output
bin(num)

Виявляється, ваше стартове представлення - це список списків входів, який дорівнює 1 або 0. Просто порахуйте їх у цьому поданні.

Кількість бітів у цілому чисті постійне в пітоні.

Однак, якщо ви хочете порахувати кількість встановлених бітів, найшвидший спосіб - створити список, відповідний наступному псевдокоду: [numberofsetbits(n) for n in range(MAXINT)]

Це забезпечить вам постійний пошук часу після створення списку. Дивіться відповідь @ PaoloMoretti для гарного втілення цього. Звичайно, вам не доведеться зберігати все це в пам'яті - ви можете використовувати якийсь стійкий сховище ключа-значення або навіть MySql. (Іншим варіантом буде реалізація власного простого дискового накопичувача).