Быстрый способ подсчета ненулевых бит в положительном целом числе

Мне нужен быстрый способ подсчета количества бит в целом числе в Python. Мое текущее решение

bin(n).count("1")

но мне интересно, есть ли более быстрый способ сделать это?

PS: (я представляю большой двумерный двоичный массив как единый список чисел и выполняю побитовые операции, и это сокращает время с часов до минут. И теперь я хотел бы избавиться от этих лишних минут.

Изменить: 1. он должен быть в Python 2.7 или 2.6

и оптимизация для небольших чисел не имеет большого значения, поскольку это не будет явным узким местом, но у меня есть числа с более чем 10000 битами в некоторых местах

например, это 2000-битный случай:

12448057941136394342297748548545082997815840357634948550739612798732309975923280685245876950055614362283769710705811182976142803324242407017104841062064840113262840137625582646683068904149296501029754654149991842951570880471230098259905004533869130509989042199261339990315125973721454059973605358766253998615919997174542922163484086066438120268185904663422979603026066685824578356173882166747093246377302371176167843247359636030248569148734824287739046916641832890744168385253915508446422276378715722482359321205673933317512861336054835392844676749610712462818600179225635467147870208L

Для целых чисел произвольной длины bin(n).count("1")это самое быстрое, что я мог найти в чистом Python.

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

С другой стороны, gmpy popcount() занял около 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 с кодом C, который является оболочкой для библиотеки 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 для их хранения?

Храните n битов как массив ceil(n/32.)32-битных целых чисел. Затем вы можете работать с массивом numpy таким же (ну, достаточно похожим) способом, которым вы используете int, в том числе используя их для индексации другого массива.

Алгоритм заключается в параллельном вычислении количества битов, установленных в каждой ячейке, и их суммировании количества битов каждой ячейки.

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

Хотя я удивлен, что никто не предложил вам написать модуль C.

#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. Просто посчитайте их в этом представлении.

Количество бит в целом числе в Python постоянно.

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

Это обеспечит вам постоянный поиск по времени после создания списка. См. Ответ @ PaoloMoretti для хорошей реализации этого. Конечно, вам не обязательно хранить все это в памяти - вы можете использовать какое-то постоянное хранилище значений ключей или даже MySql. (Другой вариант - реализовать собственное простое дисковое хранилище).