Schnelle Methode zum Zählen von Nicht-Null-Bits in positiven Ganzzahlen

Ich brauche einen schnellen Weg, um die Anzahl der Bits in einer Ganzzahl in Python zu zählen. Meine aktuelle Lösung ist

bin(n).count("1")

aber ich frage mich, ob es einen schnelleren Weg gibt, dies zu tun?

PS: (Ich stelle ein großes 2D-Binärarray als einzelne Liste von Zahlen dar und führe bitweise Operationen durch. Dadurch wird die Zeit von Stunden auf Minuten verkürzt. Jetzt möchte ich diese zusätzlichen Minuten loswerden.

Bearbeiten: 1. Es muss in Python 2.7 oder 2.6 sein

und die Optimierung für kleine Zahlen spielt keine große Rolle, da dies kein klarer Engpass wäre, aber ich habe an einigen Stellen Zahlen mit mehr als 10 000 Bits

Dies ist beispielsweise ein 2000-Bit-Fall:

12448057941136394342297748548545082997815840357634948550739612798732309975923280685245876950055614362283769710705811182976142803324242407017104841062064840113262840137625582646683068904149296501029754654149991842951570880471230098259905004533869130509989042199261339990315125973721454059973605358766253998615919997174542922163484086066438120268185904663422979603026066685824578356173882166747093246377302371176167843247359636030248569148734824287739046916641832890744168385253915508446422276378715722482359321205673933317512861336054835392844676749610712462818600179225635467147870208L

Für Ganzzahlen beliebiger Länge bin(n).count("1")ist dies die schnellste, die ich in reinem Python finden konnte.

Ich habe versucht, die Lösungen von Óscar und Adam so anzupassen, dass die Ganzzahl in 64-Bit- bzw. 32-Bit-Blöcken verarbeitet wird. Beide waren mindestens zehnmal langsamer als bin(n).count("1")(die 32-Bit-Version brauchte wieder etwa halb so viel Zeit).

Auf der anderen Seite dauerte gmpy popcount() ungefähr 1/20 der Zeit von bin(n).count("1"). Wenn Sie also gmpy installieren können, verwenden Sie das.

Um eine Frage in den Kommentaren zu beantworten, würde ich für Bytes eine Nachschlagetabelle verwenden. Sie können es zur Laufzeit generieren:

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

Oder definieren Sie es einfach wörtlich:

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

Dann ist es counts[x], die Anzahl von 1 Bits zu erhalten, xwobei 0 ≤ x ≤ 255 ist.

Sie können den folgenden Algorithmus anpassen:

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

Dies funktioniert für positive 64-Bit-Zahlen, ist jedoch leicht erweiterbar und die Anzahl der Operationen wächst mit dem Logarithmus des Arguments (dh linear mit der Bitgröße des Arguments).

Um zu verstehen, wie dies funktioniert, stellen Sie sich vor, Sie teilen die gesamte 64-Bit-Zeichenfolge in 64 1-Bit-Buckets. Der Wert jedes Buckets entspricht der Anzahl der im Bucket gesetzten Bits (0, wenn keine Bits gesetzt sind, und 1, wenn ein Bit gesetzt ist). Die erste Transformation führt zu einem analogen Zustand, jedoch mit 32 Buckets von jeweils 2 Bit Länge. Dies wird erreicht, indem die Buckets entsprechend verschoben und ihre Werte addiert werden (eine Addition kümmert sich um alle Buckets, da kein Übertrag zwischen Buckets auftreten kann - die n-Bit-Nummer ist immer lang genug, um die Nummer n zu codieren). Weitere Transformationen führen zu Zuständen mit exponentiell abnehmender Anzahl von Buckets exponentiell wachsender Größe, bis wir zu einem 64 Bit langen Bucket gelangen. Dies gibt die Anzahl der im ursprünglichen Argument gesetzten Bits an.

Hier ist eine Python-Implementierung des Populationszählalgorithmus, wie in diesem Beitrag erläutert :

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

Es wird funktionieren für 0 <= i < 0x100000000.

Laut diesem Beitrag scheint dies eine der schnellsten Implementierungen des Hamming-Gewichts zu sein (wenn es Ihnen nichts ausmacht, etwa 64 KB Speicher zu verwenden).

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

Auf Python 2.x Sie ersetzen sollten rangemit xrange.

Bearbeiten

Wenn Sie eine bessere Leistung benötigen (und Ihre Zahlen große Zahlen sind), schauen Sie sich die GMPBibliothek an. Es enthält handgeschriebene Assembly-Implementierungen für viele verschiedene Architekturen.

gmpy ist ein C-codiertes Python-Erweiterungsmodul, das die GMP-Bibliothek umschließt.

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

Ich mag diese Methode wirklich. Es ist einfach und ziemlich schnell, aber auch nicht in der Bitlänge begrenzt, da Python unendlich viele ganze Zahlen hat.

Es ist tatsächlich schlauer als es aussieht, weil es keine Zeit damit verschwendet, die Nullen zu scannen. Beispielsweise dauert das Zählen der gesetzten Bits in 1000000000000000000000010100000001 genauso lange wie in 1111.

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

Sie können den Algorithmus verwenden, um die Binärzeichenfolge [1] einer Ganzzahl abzurufen, aber anstatt die Zeichenfolge zu verketten, zählen Sie die Anzahl der Einsen:

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

Sie sagten, Numpy sei zu langsam. Haben Sie es verwendet, um einzelne Bits zu speichern? Warum nicht die Idee erweitern, Ints als Bit-Arrays zu verwenden, sondern diese mit Numpy speichern?

Speichern Sie n Bits als Array von ceil(n/32.)32-Bit-Ints. Sie können dann mit dem numpy-Array auf die gleiche (gut genug ähnliche) Weise arbeiten, wie Sie Ints verwenden, einschließlich der Verwendung, um ein anderes Array zu indizieren.

Der Algorithmus besteht im Wesentlichen darin, parallel die Anzahl der in jeder Zelle gesetzten Bits zu berechnen und die Bitanzahl jeder Zelle zusammenzufassen.

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

Obwohl ich überrascht bin, hat niemand vorgeschlagen, ein C-Modul zu schreiben.

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

Es stellt sich heraus, dass Ihre Startdarstellung eine Liste von Ints-Listen ist, die entweder 1 oder 0 sind. Zählen Sie sie einfach in dieser Darstellung.

Die Anzahl der Bits in einer Ganzzahl ist in Python konstant.

Wenn Sie jedoch die Anzahl der gesetzten Bits zählen möchten, erstellen Sie am schnellsten eine Liste, die dem folgenden Pseudocode entspricht: [numberofsetbits(n) for n in range(MAXINT)]

Dadurch erhalten Sie eine konstante Zeitsuche, nachdem Sie die Liste erstellt haben. Eine gute Implementierung finden Sie in der Antwort von @ PaoloMoretti. Natürlich müssen Sie dies nicht alles im Speicher behalten - Sie könnten einen dauerhaften Schlüsselwertspeicher oder sogar MySQL verwenden. (Eine andere Möglichkeit wäre, einen eigenen einfachen festplattenbasierten Speicher zu implementieren.)