Cách nhanh chóng để đếm các bit khác không trong số nguyên dương

Tôi cần một cách nhanh chóng để đếm số bit trong một số nguyên trong python. Giải pháp hiện tại của tôi là

bin(n).count("1")

nhưng tôi đang tự hỏi nếu có cách nào nhanh hơn để làm điều này?

Tái bút: (Tôi đang đại diện cho một mảng nhị phân 2D lớn dưới dạng một danh sách các số duy nhất và thực hiện các phép toán bit, và điều đó làm giảm thời gian từ hàng giờ xuống còn phút. Và bây giờ tôi muốn loại bỏ những phút thừa đó.

Chỉnh sửa: 1. nó phải ở trong python 2.7 hoặc 2.6

và tối ưu hóa cho các số nhỏ không quan trọng lắm vì đó sẽ không phải là một nút cổ chai rõ ràng, nhưng tôi có những con số với 10 000 + bit ở một số nơi

ví dụ đây là trường hợp 2000 bit:

12448057941136394342297748548545082997815840357634948550739612798732309975923280685245876950055614362283769710705811182976142803324242407017104841062064840113262840137625582646683068904149296501029754654149991842951570880471230098259905004533869130509989042199261339990315125973721454059973605358766253998615919997174542922163484086066438120268185904663422979603026066685824578356173882166747093246377302371176167843247359636030248569148734824287739046916641832890744168385253915508446422276378715722482359321205673933317512861336054835392844676749610712462818600179225635467147870208L

Đối với các số nguyên có độ dài tùy ý, bin(n).count("1")là tốc độ nhanh nhất mà tôi có thể tìm thấy trong Python thuần túy.

Tôi đã thử điều chỉnh các giải pháp của Óscar và Adam để xử lý số nguyên tương ứng ở các khối 64 bit và 32 bit. Cả hai đều chậm hơn ít nhất mười lần bin(n).count("1")(phiên bản 32-bit mất khoảng một nửa thời gian).

Mặt khác, gmpy popcount() chiếm khoảng 1/5 thời gian bin(n).count("1"). Vì vậy, nếu bạn có thể cài đặt gmpy, hãy sử dụng nó.

Để trả lời một câu hỏi trong nhận xét, đối với byte, tôi sẽ sử dụng một bảng tra cứu. Bạn có thể tạo nó trong thời gian chạy:

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

Hoặc chỉ định nghĩa nó theo nghĩa đen:

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

Sau đó, nó counts[x]lấy số bit 1 trong xđó 0 ≤ x ≤ 255.

Bạn có thể điều chỉnh thuật toán sau:

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

Điều này hoạt động đối với các số dương 64 bit, nhưng nó có thể dễ dàng mở rộng và số lượng phép toán tăng lên theo lôgarit của đối số (tức là tuyến tính với kích thước bit của đối số).

Để hiểu cách hoạt động của điều này, hãy tưởng tượng rằng bạn chia toàn bộ chuỗi 64 bit thành 64 nhóm 1 bit. Giá trị của mỗi nhóm bằng số bit được đặt trong nhóm (0 nếu không có bit nào được đặt và 1 nếu một bit được đặt). Lần chuyển đổi đầu tiên dẫn đến một trạng thái tương tự, nhưng với 32 nhóm, mỗi nhóm dài 2 bit. Điều này đạt được bằng cách dịch chuyển các nhóm một cách thích hợp và thêm các giá trị của chúng (một phép bổ sung sẽ quan tâm đến tất cả các nhóm vì không thể thực hiện được trên các nhóm - số n-bit luôn đủ dài để mã hóa số n). Các phép biến đổi tiếp theo dẫn đến các trạng thái có số lượng nhóm giảm dần theo cấp số nhân có kích thước đang phát triển theo cấp số nhân cho đến khi chúng ta đi đến một nhóm dài 64 bit. Điều này cho biết số bit được đặt trong đối số ban đầu.

Đây là một triển khai Python của thuật toán đếm dân số, như được giải thích trong bài đăng này :

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

Nó sẽ hoạt động cho 0 <= i < 0x100000000.

Theo bài đăng này , đây có vẻ là một trong những cách thực hiện trọng lượng Hamming nhanh nhất (nếu bạn không ngại sử dụng khoảng 64KB bộ nhớ).

#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])

Trên Python 2.x, bạn nên thay thế rangebằng xrange.

Biên tập

Nếu bạn cần hiệu suất tốt hơn (và số của bạn là số nguyên lớn), hãy xem GMPthư viện. Nó chứa các triển khai lắp ráp viết tay cho nhiều kiến ​​trúc khác nhau.

gmpy là một mô-đun mở rộng Python được mã hóa C bao bọc thư viện GMP.

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

Tôi thực sự thích phương pháp này. Nó đơn giản và khá nhanh nhưng cũng không bị giới hạn về độ dài bit vì python có vô hạn số nguyên.

Nó thực sự tinh ranh hơn vẻ ngoài của nó, vì nó tránh lãng phí thời gian quét các số không. Ví dụ, sẽ mất cùng thời gian để đếm các bit đã đặt trong 1000000000000000000000010100000001 như trong 1111.

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

Bạn có thể sử dụng thuật toán để lấy chuỗi nhị phân [1] của một số nguyên nhưng thay vì nối chuỗi, hãy đếm số đơn vị:

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

Bạn nói Numpy quá chậm. Bạn có sử dụng nó để lưu trữ các bit riêng lẻ không? Tại sao không mở rộng ý tưởng sử dụng int làm mảng bit mà lại sử dụng Numpy để lưu trữ chúng?

Lưu trữ n bit dưới dạng một mảng các ceil(n/32.)int 32 bit. Sau đó, bạn có thể làm việc với mảng numpy giống như cách bạn sử dụng int, bao gồm cả việc sử dụng chúng để lập chỉ mục một mảng khác.

Thuật toán về cơ bản là tính toán song song số lượng bit được đặt trong mỗi ô và chúng tổng hợp số bit của mỗi ô.

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

Mặc dù tôi rất ngạc nhiên là không ai đề nghị bạn viết mô-đun 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)

Hóa ra biểu diễn bắt đầu của bạn là một danh sách danh sách các số nguyên là 1 hoặc 0. Chỉ cần đếm chúng trong biểu diễn đó.

Số bit trong một số nguyên là không đổi trong python.

Tuy nhiên, nếu bạn muốn đếm số bit đã đặt, cách nhanh nhất là tạo một danh sách tuân theo mã giả sau: [numberofsetbits(n) for n in range(MAXINT)]

Điều này sẽ cung cấp cho bạn một thời gian tra cứu liên tục sau khi bạn đã tạo danh sách. Xem câu trả lời của @ PaoloMoretti để biết cách triển khai tốt điều này. Tất nhiên, bạn không cần phải lưu tất cả những thứ này trong bộ nhớ - bạn có thể sử dụng một số loại lưu trữ khóa-giá trị liên tục, hoặc thậm chí MySql. (Một tùy chọn khác sẽ là triển khai bộ lưu trữ dựa trên đĩa đơn giản của riêng bạn).