Vérificateur de nombre vampire
Un nombre vampire est un entier composé dont les chiffres peuvent être réorganisés en deux facteurs de même longueur, appelés crocs.
Lancer gratuitement
Ce vérificateur applique la définition complète au lieu de chercher seulement une factorisation commode. Saisissez un entier positif comportant un nombre pair de chiffres : vous saurez s’il est vampire et obtiendrez toutes ses paires de crocs valides. Une entrée de longueur impaire produit une erreur, puisque la définition impose deux crocs de même longueur.
Ce que démontre le test d’un nombre vampire
Un résultat positif établit bien davantage qu’une factorisation ordinaire. Pour un entier de 2k chiffres, chaque croc doit compter exactement k chiffres, les deux crocs doivent donner l’entier initial lorsqu’ils sont multipliés, et leurs chiffres décimaux réunis doivent correspondre aux chiffres d’origine avec les mêmes répétitions. Deux zéros dans le nombre exigent donc deux zéros parmi les crocs, tandis qu’un chiffre absent ne peut apparaître dans aucun facteur. La règle classique des zéros finaux s’applique également : une paire est refusée si les deux crocs se terminent par zéro. Le vérificateur examine toutes ces conditions simultanément et renvoie chaque paire distincte dans l’ordre croissant. Ainsi, 1260 convient, car 21 multiplié par 60 donne 1260 et les chiffres rassemblés de 21 et 60 sont exactement 1, 2, 6 et 0. Un résultat négatif signifie qu’aucune paire de la longueur requise ne respecte toute la règle des chiffres ; il ne signifie pas que le nombre est premier ou dépourvu de facteurs.
Comment saisir le nombre et lire la réponse
Fournissez n sous forme de chaîne représentant un entier décimal non signé. Ce choix conserve les chiffres et permet de les compter exactement, sans notation scientifique ni arrondi numérique silencieux. N’ajoutez ni espace, ni virgule, ni point décimal, ni signe plus, ni zéro initial. L’entrée doit comporter un nombre pair de chiffres, avec une limite de douze, afin que la recherche exacte reste bornée dans le navigateur comme via l’API. La réponse répète n, indique digit_count, attribue true ou false à is_vampire et fournit fangs sous forme de tableau de paires numériques. Un tableau fangs vide constitue une réponse négative complète selon la définition annoncée. S’il existe plusieurs décompositions valides, chacune apparaît une seule fois, avec le plus petit croc en premier. Une longueur impaire provoque une erreur de saisie plutôt que false : ces nombres sont hors du domaine prévu, car leurs chiffres ne peuvent pas être répartis entre deux crocs décimaux de même longueur. Une intégration peut ainsi distinguer une question incorrecte d’un résultat négatif valide.
Pourquoi il faut examiner tous les facteurs
Les énigmes de nombres vampires sont faciles à vérifier incorrectement à la main. Trouver des facteurs dont les chiffres semblent proches ne suffit pas, et essayer une seule paire connue peut masquer une autre décomposition valable. Cette implémentation parcourt les premiers crocs possibles depuis le plus petit entier autorisé de k chiffres jusqu’à la racine carrée de n. Elle ne retient un candidat que s’il divise n exactement, puis vérifie que le facteur complémentaire possède lui aussi k chiffres. Enfin, elle compare les signatures de chiffres triées et applique l’exclusion des deux zéros finaux. Borner le premier croc à la racine carrée évite les doublons inversés sans modifier la réponse. Le procédé est déterministe : une même entrée produit toujours les mêmes paires dans le même ordre, sans réseau, valeur aléatoire, horloge ni état conservé. Il convient donc aux loisirs mathématiques, à l’enseignement, à la correction d’exercices de programmation et aux traitements reproductibles. L’exécution dans le navigateur est gratuite, tandis qu’une requête API automatisée coûte $0.002. Le même code pur dessert les deux voies et garantit des règles identiques.
Cas d’usage
Vérifier une énigme de théorie des nombres
Contrôlez un nombre vampire proposé et affichez les paires exactes de crocs qui satisfont toute la définition.
Valider des suites générées
Testez des entiers candidats dans un script et distinguez les non-vampires valides des entrées hors du domaine pair.
Enseigner facteurs et multiensembles
Montrez comment multiplication, longueur des facteurs, chiffres répétés et règle des zéros finaux interagissent.
Questions fréquentes
Qu’est-ce qu’un nombre vampire ?
C’est un entier comportant un nombre pair de chiffres, factorisable en deux crocs de même longueur dont les chiffres réunis reproduisent exactement ceux de l’entier, sans que les deux finissent par zéro.
Pourquoi une longueur impaire provoque-t-elle une erreur ?
La définition exige deux crocs de même longueur. Un nombre impair de chiffres ne peut pas être partagé également entre eux ; cette entrée est donc hors du domaine.
Un nombre peut-il avoir plusieurs paires de crocs ?
Oui. Le vérificateur parcourt tout l’intervalle autorisé et renvoie chaque paire valide une fois, classée par le plus petit croc.
Les zéros initiaux sont-ils autorisés dans le nombre ou les crocs ?
Non. L’entrée doit employer sa représentation décimale habituelle, et les bornes numériques de longueur empêchent les crocs précédés d’un zéro.
Combien coûte une vérification par API ?
Chaque requête API coûte $0.002. Vous pouvez aussi exécuter gratuitement le même vérificateur déterministe dans votre navigateur.
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/vampire-number \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":"1260"}'const res = await fetch("https://api.kit.forhosting.com/numth/vampire-number", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": "1260"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/vampire-number",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": "1260"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/vampire-number", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":"1260"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":"1260"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/vampire-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": "1260"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.vampire_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.
Limites
max_digits | 12 |
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. |