Calculateur de zéros de tête
Comptez les bits à zéro situés au-dessus du bit à un le plus haut, dans un mot de largeur fixe : 16 sur 8 bits s'écrit 00010000, le résultat est donc 3. Vous voyez aussi la longueur en bits et le binaire complet. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Valeur
- 16
- Largeur
- 8
- Zéros en tête
- 3
- Longueur en bits
- 5
- Binaire
- 00010000
- Bit de poids fort
- 4
Compter les zéros de tête — CLZ, LZCNT ou un balayage dérivé de BSR — est le nombre de bits nuls qui se trouvent au-dessus du bit à un le plus significatif d’un entier non signé dans un mot de largeur fixe. Les compilateurs émettent ce décompte pour le log2 entier, pour normaliser une significande avant un décalage et pour trouver le premier drapeau positionné dans un registre d’état. Ce calculateur de zéros de tête accepte un entier non négatif en chiffres décimaux, en hexadécimal préfixé 0x, en binaire 0b ou en octal 0o, plus une taille de mot de huit, seize, trente-deux ou soixante-quatre bits. Il renvoie le décompte CLZ, la longueur en bits de la magnitude, une chaîne binaire complétée à la largeur pour que vous voyiez les zéros de tête, et l’indice base zéro du bit à un le plus significatif lorsque la valeur n’est pas nulle. Zéro est un cas de premier rang : chaque bit est un zéro de tête, donc le décompte égale la largeur choisie.
Ce que compter les zéros de tête signifie sur un mot de largeur fixe
Les instructions matérielles de comptage des zéros de tête regardent un registre de largeur connue, non un entier mathématique abstrait. Dans un mot de huit bits, la valeur seize est le motif 00010000 : trois zéros se trouvent au-dessus du un le plus haut, donc CLZ vaut trois. Dans un mot de trente-deux bits, la même magnitude est 00000000000000000000000000010000 et CLZ devient vingt-sept, car vingt-quatre zéros de poids fort supplémentaires apparaissent lorsque vous élargissez le registre.
Algébriquement, la longueur en bits d’un entier positif est le plancher du logarithme en base deux de la valeur plus un, et le décompte des zéros de tête est la largeur du mot moins cette longueur. Lorsque la valeur est zéro, il n’existe aucun bit à un le plus significatif ; chaque position est un zéro de tête, donc le décompte égale la largeur.
C’est la convention de LZCNT sur x86, de CLZ sur ARM, de clz sur RISC-V et des builtins de compilateur __builtin_clz et leadingZeroBitCount : ils rapportent la taille complète du mot pour un opérande nul au lieu de laisser le résultat indéfini, comme le faisaient parfois les anciens encodages BSR. Cette capacité encode exactement cette identité. Le champ binaire complété comporte exactement width caractères de zéro et de un sans préfixe 0b, ce qui rend les zéros de tête visibles sans une seconde conversion.
Le champ formula reformule l’identité logarithmique afin que la documentation générée et les commentaires de test citent la même phrase que le calculateur.
Cas d’usage
Oracles CLZ pour compilateur et machine virtuelle
Vérifiez le log2 entier, l’abaissement LZCNT et le comportement de l’opérande nul face aux conventions matérielles 8/16/32/64 bits dans les suites de régression de compilateurs et d’interpréteurs.
Normalisation de registres et de drapeaux
Déterminez combien de zéros de poids fort se trouvent au-dessus du bit à un le plus haut d’un mot d’état ou d’activation avant de décaler un champ vers une position canonique.
Enseignement de la longueur en bits et du log2
Laissez les étudiants comparer le binaire complété à la main et les décomptes CLZ pour une taille de mot choisie, sans lancer un simulateur de processeur.
Questions fréquentes
Pourquoi dois-je choisir 8, 16, 32 ou 64 bits ?
CLZ est défini sur un registre de largeur fixe. La même magnitude a un décompte différent dans un octet de 8 bits et dans un mot de 32 ; l’enum fermé concorde avec les largeurs courantes de processeur et de langages.
Que renvoie le comptage des zéros de tête pour zéro ?
La largeur complète choisie : 8 pour un mot de 8 bits, 64 pour un mot de 64. Tous les bits de zéro sont des zéros de tête, comme avec LZCNT sur x86, CLZ sur ARM et clz sur RISC-V.
Puis-je saisir le nombre en hexadécimal ou en binaire ?
Oui. Écrivez-le en décimal, en hexadécimal avec 0x, en binaire avec 0b ou en octal avec 0o. Il est lu comme non signé et doit tenir dans la largeur choisie : un nombre qui demanderait un neuvième bit est donc refusé sur 8 bits.
Quel lien entre les zéros de tête et le logarithme en base deux ?
La longueur en bits d'un nombre positif est la partie entière de son logarithme en base deux plus un, et les zéros de tête valent la largeur du mot moins cette longueur. Pour 16 sur 8 bits, la longueur est 5 et le résultat 3.
À quelle position se trouve le bit de poids fort ?
Les positions sont numérotées à partir de zéro en partant du bit de poids faible, selon l'usage en programmation. C'est pourquoi 16 indique son bit de poids fort en position 4 ; pour la valeur zéro, il n'y en a aucun.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre 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)Exemple de requête
{
"value": "16",
"width": 8
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.count_leading_zeros",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Ce que compter les zéros de tête signifie sur un mot de largeur fixe
La numérotation des bits du champ optionnel most_significant_bit suit la convention habituelle selon laquelle le bit zéro est le moins significatif, donc seize rapporte most_significant_bit quatre.
Contrat d’entrée, largeurs et comportement d’erreur
Envoyez par POST un corps JSON avec deux champs obligatoires. value est un entier non négatif écrit comme chaîne de chiffres décimaux, littéral hexadécimal 0x, littéral binaire 0b ou littéral octal 0o ; un nombre JSON qui est un entier non négatif sûr est aussi accepté, et les alias n, integer et x pointent vers le même champ. width est la taille du mot non signé et doit appartenir à l’ensemble fermé huit, seize, trente-deux ou soixante-quatre — les largeurs des instructions CLZ courantes — également accepté comme bits ou bit_width. La valeur est interprétée non signée et doit tenir dans ce nombre de bits : seize est licite sur huit bits, deux cent cinquante-six ne l’est pas, car il faudrait un neuvième bit. Champs manquants, chaînes vides, booléens, signes, nombres fractionnaires, préfixes inconnus et un width hors enum échouent avec invalid_input qui nomme la règle, et ces échecs ne sont pas facturés. En cas de succès, le corps renvoie value comme chaîne décimale canonique sans zéros de tête (sauf le nombre zéro lui-même) et width comme nombre, puis expose leading_zeros comme décompte principal, bit_length comme largeur de la magnitude (zéro lorsque la valeur est nulle) et binary comme la chaîne de bits complétée à la largeur. most_significant_bit n’est présent que lorsque la valeur n’est pas nulle ; il est omis plutôt que mis à null pour que la sortie optionnelle reste honnête. Exemple : value seize et width huit donnent leading_zeros trois, bit_length cinq, binary 00010000 et most_significant_bit quatre. Exemple : value zéro et width trente-deux donnent leading_zeros trente-deux, bit_length zéro et une chaîne de trente-deux caractères zéro, sans most_significant_bit.
Où un calculateur de zéros de tête prouve son utilité
Les auteurs de compilateurs et de machines virtuelles émettent CLZ ou un repli logiciel pour le log2 entier, pour trouver le drapeau le plus haut et pour normaliser une mantisse avant un décalage de style virgule flottante ; ils ont besoin d’un oracle qui concorde avec le matériel sur zéro et sur chaque largeur prise en charge afin que les suites de régression n’acceptent pas en silence une erreur d’un cran dans l’identité logarithmique. Les auteurs de micrologiciel et de pilotes lisent des registres d’état et d’activation et veulent l’indice du bit en attente le plus haut sans écrire un auxiliaire clz portable dans chaque langage qu’ils touchent. Les bibliothèques de cryptographie et de grands entiers normalisent un limb avant un décalage à gauche ou avant de compter les bits significatifs d’un nonce, et un calculateur à largeur fixe est le moyen le plus mince de vérifier ces auxiliaires sur des cas de huit à soixante-quatre bits, y compris le limb tout à zéro. Les enseignants des opérateurs bit à bit et de la normalisation de style IEEE peuvent donner aux étudiants une valeur et une largeur et comparer le binaire complété à la main plus le décompte CLZ à un service déterministe plutôt qu’à un simulateur ISA complet. Comme il s’agit de parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant, et une entrée invalide ne consomme pas le solde. Gardez les requêtes petites, épinglez leading_zeros et la chaîne binaire complétée dans les tests, et vous obtenez des résultats CLZ reproductibles pour SDK, extraits CMS et workers en bordure sans dresser votre propre bibliothèque locale de balayage de bits.
Questions techniques
Comment compter les bits nuls de tête d’un entier ?
Envoyez value (décimal non négatif, 0x, 0b ou 0o) et width (8, 16, 32 ou 64). L’API renvoie leading_zeros = width lorsque value vaut 0, sinon width − floor(log2(value)) − 1.
Que renvoie le décompte des zéros de tête pour zéro ?
leading_zeros égale la largeur choisie et bit_length vaut 0. most_significant_bit est omis car aucun bit n’est positionné. Cela concorde avec LZCNT, CLZ ARM et les builtins de compilateur.
Puis-je envoyer de l’hexadécimal ou un nombre JSON ?
Oui. value accepte des chiffres décimaux, de l’hex 0x, du binaire 0b, de l’octal 0o ou un entier JSON non négatif sûr. La valeur doit encore tenir dans la largeur non signée choisie.
Combien coûte le calculateur de zéros de tête ?
L’outil du navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n’est pas facturée.