Vérificateur de nombre pernicieux par bits à un
Comptez les uns d'un nombre en binaire et voyez si ce total est premier : 13 s'écrit 1101 en binaire, avec 3 uns, il est donc pernicieux. Les puissances de deux n'ont qu'un seul un et ne le sont jamais. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- N
- 13
- Binaire
- 1101
- Nombre de uns
- 3
Un nombre pernicieux est un entier positif dont l’écriture binaire contient un nombre premier de bits à un. Ce vérificateur convertit exactement votre saisie décimale en base deux, compte les uns, teste la primalité de ce petit total et renvoie chaque valeur intermédiaire avec une conclusion explicite. Il convient aux exercices de théorie des nombres, à l’étude des suites, aux tests de programmation et à la validation de données. Les valeurs inférieures à un sont refusées afin d’éviter toute classification ambiguë.
Définition d’un nombre pernicieux
La définition suit deux étapes précises. Écrivez d’abord l’entier positif n en base deux, sans zéro initial. Comptez ensuite les chiffres égaux à un dans cette écriture, quantité également appelée poids de Hamming.
Le nombre n est pernicieux si et seulement si ce compte est premier. Par exemple, treize s’écrit 1101 : il contient trois uns et trois est premier, donc treize est pernicieux. Quinze s’écrit 1111 et contient quatre uns ; quatre étant composé, quinze n’est pas pernicieux.
Les puissances de deux, telles que huit, ne possèdent qu’un seul bit à un. Or un n’est pas premier, elles ne sont donc pas pernicieuses. Les deux booléens concordent volontairement : le premier nomme le test mathématique, tandis que le second donne directement la classification.
Seuls les entiers positifs appartiennent au domaine ; zéro et les négatifs déclenchent une erreur de validation.
Usages pratiques du vérificateur
Les nombres pernicieux relient simplement arithmétique entière, représentation binaire, combinatoire et primalité. En classe, cet outil confirme une conversion manuelle tout en montrant assez d’étapes pour repérer une erreur. Les amateurs et chercheurs peuvent filtrer des listes avant d’étudier écarts, résidus ou intersections avec d’autres suites.
Une équipe de données peut aussi comparer l’écriture binaire et le compte issus d’un autre système à ce résultat déterministe. Il ne prétend pas non plus que n est lui-même premier : un composé peut être pernicieux si son compte de uns est premier, tandis qu’un nombre premier peut échouer. Séparer ces questions évite une confusion fréquente.
Cas d’usage
Corriger un exercice de théorie des nombres
Confirmez la conversion binaire, le compte de uns et la classification dans une seule réponse.
Tester une fonction de population de bits
Employez des sorties déterministes comme jeux d’essai pour un compteur de bits ou un générateur de suite.
Filtrer un ensemble d’entiers
Classez des entiers positifs avant d’analyser motifs, écarts ou intersections avec d’autres suites.
Questions fréquentes
Qu’est-ce qu’un nombre pernicieux ?
C’est un entier positif dont la représentation binaire contient un nombre premier de bits égaux à un.
Le nombre un est-il pernicieux ?
Non. Un s’écrit 1 en binaire, possède un seul bit à un, et un n’est pas premier.
Un nombre pernicieux est-il forcément premier ?
Non. La primalité concerne le compte des bits à un, pas n lui-même ; un composé peut être pernicieux.
Quelles saisies sont refusées ?
Les valeurs absentes ou inférieures à un, fractions, notations scientifiques, chaînes non décimales et entiers non sûrs.
13 est-il un nombre pernicieux ?
Oui. En binaire, 13 s'écrit 1101, qui contient trois uns. Trois est premier, donc 13 est pernicieux. Le résultat affiche l'écriture binaire et le décompte pour que vous puissiez vérifier à la main.
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/numth/pernicious-number \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":13}'const res = await fetch("https://api.kit.forhosting.com/numth/pernicious-number", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 13
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/pernicious-number",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 13
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/pernicious-number", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":13}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":13}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/pernicious-number", 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
{
"n": 13
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.pernicious_number",
"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
Définition d’un nombre pernicieux
La réponse expose binary, one_count, one_count_is_prime et pernicious afin que vous puissiez contrôler la conversion et chaque étape plutôt que de recevoir seulement un booléen.
Envoyer une valeur et comprendre la réponse
Une chaîne peut commencer par un signe plus ; les décimales, la notation exponentielle, les préfixes hexadécimaux, les virgules et les espaces internes sont refusés. Après validation, l’algorithme convertit la valeur en BigInt et produit son écriture en base deux, conservant ainsi chaque bit près de la limite. Il parcourt ensuite cette chaîne une fois et incrémente le compte pour chaque un. Un entier sûr ayant au plus 53 chiffres binaires significatifs, le test de primalité reste minuscule : il écarte les comptes inférieurs à deux, traite deux, élimine les pairs et essaie les diviseurs impairs jusqu’à la racine carrée. Transmettez n sous forme d’entier JSON exact ou de chaîne décimale simple. Le champ conseillé est n, mais number et value sont acceptés comme alias pour les formulaires et jeux de données existants. La plage s’arrête au plus grand entier sûr de JavaScript, ce qui permet de renvoyer la saisie comme nombre JSON sans arrondi. Consultez binary pour la conversion, one_count pour le total et pernicious pour la conclusion. Sans réseau, hasard, horloge ni état mutable, une même entrée rend toujours le même JSON.
Usages pratiques du vérificateur
Dans un exercice de programmation, son JSON stable sert d’oracle pour tester une fonction de population de bits, un analyseur d’entiers ou un générateur de suite. Chaque requête API réussie coûte $0.002 ; l’utilisation interactive dans le navigateur est gratuite. L’outil classe un entier par requête et ne génère ni plage ni suite illimitée, ce qui rend durée et facturation prévisibles.
Questions techniques
Quel est le prix de l’API ?
Chaque requête API réussie coûte $0.002. La version interactive du navigateur est gratuite.