Führende Nullbits zählen
Zählen Sie die Nullbits oberhalb des höchsten Einsbits in einem Wort fester Breite: 16 in 8 Bit ist 00010000, das Ergebnis ist also 3. Sie sehen außerdem die Bitlänge und das vollständige Binärmuster. Kostenlos in Ihrem Browser.
- Kostenlos
- Läuft in Ihrem Browser
- Ohne Anmeldung
- Ihre Daten bleiben auf Ihrem Gerät
Im Browser ausführen – kostenlos
Rechenbeispiel
- Wert
- 16
- Breite
- 8
- Führende Nullen
- 3
- Bitlänge
- 5
- Binär
- 00010000
- Höchstwertiges Bit
- 4
Führende Nullen zählen — CLZ, LZCNT oder ein von BSR abgeleiteter Scan — ist die Anzahl der Nullbits, die oberhalb des höchstwertigen Eins-Bits einer vorzeichenlosen Ganzzahl in einem wortfesten Register sitzen. Compiler erzeugen diesen Zähler für ganzzahliges log2, zum Normalisieren einer Signifikande vor einer Verschiebung und zum Finden des ersten gesetzten Flags in einem Statusregister. Dieser Rechner für führende Nullbits nimmt eine nichtnegative Ganzzahl als Dezimalziffern, Hexadezimal mit Präfix 0x, Binär mit 0b oder Oktal mit 0o entgegen, plus eine Wortbreite von acht, sechzehn, zweiunddreißig oder vierundsechzig Bit. Er liefert den CLZ-Zähler, die Bitlänge der Magnitude, eine auf die Breite aufgefüllte Binärzeichenkette, damit Sie die führenden Nullen sehen, und den nullbasierten Index des höchstwertigen Eins-Bits, wenn der Wert nicht null ist. Null ist ein erstklassiger Fall: jedes Bit ist eine führende Null, der Zähler gleicht also der gewählten Breite.
Führende Nullen hängen von der Wortbreite ab
Die Zählung führender Nullen, auch CLZ oder LZCNT genannt, gibt an, wie viele Nullbits über dem höchsten gesetzten Bit einer vorzeichenlosen Zahl stehen. Hardwarebefehle betrachten dabei immer ein Register bekannter Breite, nicht eine abstrakte Zahl. In einem 8-Bit-Wort ist 16 das Muster 00010000: Über der höchsten Eins stehen drei Nullen, das Ergebnis ist 3. In einem 32-Bit-Wort wird daraus siebenundzwanzig, weil beim Verbreitern des Registers 24 zusätzliche Nullen oben hinzukommen. Rechnerisch ist die Bitlänge einer positiven Zahl der abgerundete Zweierlogarithmus plus eins, und die führenden Nullen sind die Wortbreite minus diese Bitlänge.
Null, Eingabeformen und typische Einsätze
Bei null gibt es kein gesetztes Bit, also ist jede Stelle eine führende Null und das Ergebnis entspricht der Breite. So halten es LZCNT, CLZ und clz, während ältere BSR-Varianten das Ergebnis teils offenließen. Sie können die Zahl dezimal, hexadezimal, binär oder oktal eingeben; sie muss in die gewählte Breite passen. Das Binärmuster hat genau so viele Stellen wie die Breite, damit Sie die Nullen ohne zweite Umrechnung sehen. Gebraucht wird das für den ganzzahligen Logarithmus, zum Normalisieren vor einer Verschiebung, um das erste gesetzte Flag in einem Statusregister zu finden, und im Unterricht zur Bitlänge.
Was das Zählen führender Nullen in einem wortfesten Register bedeutet
Hardware-Befehle zum Zählen führender Nullen betrachten ein Register bekannter Breite, nicht eine abstrakte mathematische Ganzzahl. In einem Acht-Bit-Wort ist der Wert sechzehn das Muster 00010000: drei Nullen sitzen oberhalb der höchsten Eins, also ist CLZ drei. In einem Zweiunddreißig-Bit-Wort ist dieselbe Magnitude 00000000000000000000000000010000 und CLZ wird siebenundzwanzig, weil beim Verbreitern des Registers vierundzwanzig zusätzliche hohe Nullen erscheinen.
Algebraisch ist die Bitlänge einer positiven Ganzzahl der Abrundungswert des Zweierlogarithmus des Werts plus eins, und der Zähler führender Nullen ist die Wortbreite minus dieser Länge. Ist der Wert null, gibt es kein höchstwertiges Eins-Bit; jede Position ist eine führende Null, der Zähler gleicht also der Breite. Das ist die Konvention von LZCNT auf x86, CLZ auf ARM, clz auf RISC-V sowie der Compiler-Builtins __builtin_clz und leadingZeroBitCount: sie melden die volle Wortgröße für einen Nulloperanden, statt das Ergebnis unbestimmt zu lassen, wie es ältere BSR-Kodierungen manchmal taten.
Diese Fähigkeit kodiert genau diese Identität.
Anwendungsfälle
CLZ-Orakel für Compiler und virtuelle Maschinen
Prüfen Sie ganzzahliges log2, die Absenkung auf LZCNT und das Nulloperanden-Verhalten gegen 8/16/32/64-Bit-Hardwarekonventionen in Regressions-Suiten von Compilern und Interpretern.
Normalisierung von Registern und Flags
Ermitteln Sie, wie viele hohe Nullen oberhalb des höchsten Eins-Bits eines Status- oder Freigabeworts sitzen, bevor Sie ein Feld in eine kanonische Lage verschieben.
Lehre von Bitlänge und log2
Lassen Sie Studierende handgeschriebenes, aufgefülltes Binär und CLZ-Zähler für eine gewählte Wortgröße vergleichen, ohne einen CPU-Simulator zu starten.
Häufige Fragen
Warum muss ich 8, 16, 32 oder 64 Bit wählen?
CLZ ist auf einem Register fester Breite definiert. Dieselbe Magnitude hat in einem 8-Bit-Byte einen anderen Zähler als in einem 32-Bit-Wort; das geschlossene Enum entspricht gängigen CPU- und Sprachbreiten.
Was liefert die Zählung führender Nullen für die Zahl null?
Die volle gewählte Breite: 8 bei einem 8-Bit-Wort, 64 bei einem 64-Bit-Wort. Alle Bits der Null sind führende Nullen, genau wie bei LZCNT auf x86, CLZ auf ARM und clz auf RISC-V.
Kann ich die Zahl hexadezimal oder binär eingeben?
Ja. Geben Sie Dezimalziffern ein, hexadezimal mit 0x, binär mit 0b oder oktal mit 0o. Die Zahl wird vorzeichenlos gelesen und muss in die gewählte Breite passen, deshalb wird eine Zahl, die ein neuntes Bit bräuchte, bei 8 Bit abgelehnt.
Wie hängen führende Nullen mit dem Zweierlogarithmus zusammen?
Die Bitlänge einer positiven Zahl ist der abgerundete Zweierlogarithmus plus eins, und die Zahl der führenden Nullen ist die Wortbreite minus diese Bitlänge. Für 16 in 8 Bit ist die Bitlänge 5, das Ergebnis also 3.
An welcher Position steht das höchstwertige Bit?
Die Positionen werden ab null gezählt, beginnend beim niedrigstwertigen Bit, wie es beim Programmieren üblich ist. Deshalb meldet 16 das höchstwertige Bit an Position 4; beim Wert null gibt es keines.
Verwandte Tools
Für Entwickler — API-Zugang
Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.
Endpunkt
Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.
Aufruf aus Ihrem Stack
curl -X POST https://api.kit.forhosting.com/dev/count-leading-zeros \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":"16","width":8}'const res = await fetch("https://api.kit.forhosting.com/dev/count-leading-zeros", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": "16",
"width": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/count-leading-zeros",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": "16",
"width": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/count-leading-zeros", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":"16","width":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":"16","width":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/count-leading-zeros", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Beispiel-Anfrage
{
"value": "16",
"width": 8
}Beispiel-Antwort
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.count_leading_zeros",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.
Preis
Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.
Fehler
| HTTP | Code | Bedeutung |
|---|---|---|
401 | unauthorized | Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer). |
402 | insufficient_balance | Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht. |
404 | unknown_type | Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog. |
429 | rate_limited | Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt. |
Technische Hinweise
Was das Zählen führender Nullen in einem wortfesten Register bedeutet
Die Bitnummerierung des optionalen Feldes most_significant_bit folgt der üblichen Programmierkonvention, dass Bit null das niedrigstwertige Bit ist, daher meldet sechzehn most_significant_bit vier. Das aufgefüllte Binärfeld hat genau width Zeichen aus Null und Eins ohne Präfix 0b, wodurch die führenden Nullen ohne einen zweiten Umwandlungsschritt sichtbar werden. Das Feld formula stellt die Logarithmus-Identität neu dar, damit erzeugte Dokumentation und Testkommentare denselben Satz zitieren können, den der Rechner verwendet hat.
Eingabevertrag, Breiten und Fehlerverhalten
Der Wert wird vorzeichenlos gelesen und muss in so viele Bits passen: sechzehn ist bei acht Bit zulässig, zweihundertsechsundfünfzig nicht, weil ein neuntes Bit nötig wäre. Senden Sie per POST einen JSON-Body mit zwei Pflichtfeldern. value ist eine nichtnegative Ganzzahl als Dezimalziffernkette, hexadezimales Literal 0x, binäres Literal 0b oder oktales Literal 0o; eine JSON-Zahl, die eine sichere nichtnegative Ganzzahl ist, wird ebenfalls akzeptiert, und die Aliasse n, integer und x zeigen auf dasselbe Feld. width ist die vorzeichenlose Wortgröße und muss zur geschlossenen Menge acht, sechzehn, zweiunddreißig oder vierundsechzig gehören — die Breiten der gängigen CLZ-Befehle — und wird auch als bits oder bit_width akzeptiert. Fehlende Felder, leere Zeichenketten, Booleans, Vorzeichen, Bruchzahlen, unbekannte Präfixe und ein width außerhalb des Enums scheitern mit invalid_input unter Nennung der Regel; diese Fehler werden nicht berechnet. Bei Erfolg spiegelt der Body value als kanonische Dezimalzeichenkette ohne führende Nullen (außer der Zahl null selbst) und width als Zahl, dann liefert er leading_zeros als Hauptzähler, bit_length als Breite der Magnitude (null, wenn der Wert null ist) und binary als die auf die Breite aufgefüllte Bitkette. most_significant_bit ist nur vorhanden, wenn der Wert nicht null ist; es wird weggelassen statt auf null gesetzt, damit optionale Ausgabe ehrlich bleibt. Beispiel: value sechzehn und width acht ergeben leading_zeros drei, bit_length fünf, binary 00010000 und most_significant_bit vier. Beispiel: value null und width zweiunddreißig ergeben leading_zeros zweiunddreißig, bit_length null und eine Kette aus zweiunddreißig Nullzeichen, ohne most_significant_bit.
Wo ein Rechner für führende Nullbits seinen Nutzen zeigt
Compiler- und VM-Autoren erzeugen CLZ oder einen Software-Fallback für ganzzahliges log2, zum Finden des höchsten gesetzten Flags und zum Normalisieren einer Mantisse vor einer Verschiebung im Gleitkomma-Stil; sie brauchen ein Orakel, das auf Null und auf jeder unterstützten Breite mit der Hardware übereinstimmt, damit Regressionssuites nicht stillschweigend einen Off-by-one in der Logarithmus-Identität akzeptieren. Firmware- und Treiberautoren lesen Status- und Freigaberegister und wollen den Index des höchsten anstehenden Bits, ohne in jeder Sprache, die sie anfassen, einen portablen clz-Helfer zu schreiben. Kryptografie- und Großinteger-Bibliotheken normalisieren ein Limb vor einer Linksverschiebung oder vor dem Zählen signifikanter Bits eines Nonce, und ein Rechner fester Breite ist der schlankste Weg, diese Helfer gegen Acht- bis Vierundsechzig-Bit-Fälle einschließlich des All-Null-Limbs zu prüfen. Lehrende bitweiser Operatoren und der Normalisierung im IEEE-Stil können Studierenden einen Wert und eine Breite geben und handgeschriebenes, aufgefülltes Binär plus den CLZ-Zähler mit einem deterministischen Dienst statt eines vollen ISA-Simulators vergleichen. Weil dies Parse-Stufe A ist, kostet jeder erfolgreiche Aufruf den veröffentlichten Basispreis $0.002 ohne Modell-Tokens und ohne ausgehendes Netz; ungültige Eingabe wird nicht berechnet. Halten Sie Anfragen klein, pinnen Sie leading_zeros und die aufgefüllte Binärkette in Tests und erhalten Sie reproduzierbare CLZ-Ergebnisse für SDKs, CMS-Schnipsel und Edge-Worker, ohne eine eigene lokale Bit-Scan-Bibliothek aufzubauen.
Technische Fragen
Wie zähle ich die führenden Nullbits einer Ganzzahl?
Senden Sie value (nichtnegativ dezimal, 0x, 0b oder 0o) und width (8, 16, 32 oder 64). Die API liefert leading_zeros = width, wenn value 0 ist, sonst width − floor(log2(value)) − 1.
Was liefert das Zählen führender Nullen für die Null?
leading_zeros gleicht der gewählten Breite und bit_length ist 0. most_significant_bit entfällt, weil kein Bit gesetzt ist. Das entspricht LZCNT, ARM-CLZ und Compiler-Builtins.
Kann ich Hexadezimal oder eine JSON-Zahl senden?
Ja. value akzeptiert Dezimalziffern, Hex 0x, Binär 0b, Oktal 0o oder eine sichere nichtnegative JSON-Ganzzahl. Der Wert muss trotzdem in die gewählte vorzeichenlose Breite passen.
Was kostet der Rechner für führende Nullbits?
Das Browser-Werkzeug ist kostenlos. API-Anfragen nutzen vorausbezahltes KIT-Guthaben zu $0.002 je erfolgreichem Aufruf; ungültige Eingabe wird nicht berechnet.