Vérifier un nombre premier équilibré avec ses voisins
53 est un premier équilibré : ses premiers les plus proches sont 47 en dessous et 59 au-dessus, à 6 d'écart chacun, et leur moyenne vaut 53. Saisissez un nombre premier de 2 à un milliard pour voir ses voisins, leur moyenne et le verdict. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Nombre
- 53
- Nombre premier précédent
- 47
- Nombre premier suivant
- 59
- Moyenne des voisins
- 53
Un nombre premier équilibré se situe exactement à mi-chemin entre le nombre premier qui le précède immédiatement et celui qui le suit immédiatement. Cet outil confirme que l’entier fourni est bien premier, trouve ses deux voisins premiers, calcule leur moyenne arithmétique et compare cette moyenne à la valeur initiale. Le résultat expose les éléments qui justifient la décision, plutôt qu’une simple réponse positive ou négative. Les nombres composés sont rejetés afin de respecter la définition mathématique et de rendre les erreurs de saisie visibles dans les traitements automatisés.
Ce qui caractérise un nombre premier équilibré
Un nombre premier est équilibré lorsque sa distance au nombre premier précédent est égale à sa distance au nombre premier suivant. Cette condition revient à dire que le nombre central est la moyenne arithmétique de ces deux voisins. Ainsi, 53 est immédiatement précédé par 47 et suivi par 59.
Les deux écarts valent six, tandis que la moyenne de 47 et 59 vaut 53 : le test est donc concluant. Le caractère immédiat des voisins est essentiel, car sélectionner deux nombres premiers inférieurs et supérieurs quelconques ne correspondrait pas à la définition admise. L’outil recherche donc dans les deux directions jusqu’aux nombres premiers les plus proches, affiche ces valeurs, calcule leur moyenne puis la compare au nombre soumis.
Les champs renvoyés permettent de contrôler ou de réutiliser facilement la conclusion. Un résultat faux ne signifie pas que le nombre est composé : il reste premier, mais n’est pas centré entre ses voisins. Une entrée composée déclenche une erreur distincte afin de ne jamais confondre ces deux propriétés mathématiques.
Saisir une valeur et comprendre le résultat
Saisissez un seul entier dans le champ prévu. Les fractions, les chaînes numériques, les entiers non sûrs, les valeurs hors plage et les nombres composés sont rejetés au lieu d’être arrondis ou convertis silencieusement. Dans le cas contraire, les voisins restent exacts, mais leur milieu diffère du nombre soumis.
Le nombre 2 est bien premier, mais il ne possède aucun nombre premier précédent et ne peut donc pas satisfaire une définition fondée sur deux voisins. Dans ce cas particulier, le résultat est faux, le nombre premier suivant est indiqué et les champs relatifs au voisin précédent et à la moyenne inexistants sont omis.
Un contrôle déterministe pour l’étude et l’automatisation
L’outil repose sur une arithmétique entière exacte et des tests de primalité déterministes, sans témoins aléatoires, base de données externe ni requête réseau. Il valide d’abord la valeur fournie, puis examine les candidats voisins jusqu’à trouver le nombre premier le plus proche de chaque côté. Il suffit de tester la divisibilité jusqu’à la racine carrée de chaque candidat, et les candidats pairs sont ignorés après le traitement de 2.
Cet outil convient aux cours sur les écarts entre nombres premiers, aux expériences sur les suites, à la validation d’énigmes et aux chaînes de données où une réponse explicable importe davantage qu’une simple catégorie. La borne supérieure limite le pire volume de calcul tout en couvrant les exemples courants. Pour de très grands entiers ou des méthodes probabilistes, privilégiez un logiciel spécialisé en théorie des nombres et en précision arbitraire.
Cas d’usage
Contrôler un exercice de théorie des nombres
Validez un nombre premier supposé équilibré et consultez les voisins exacts qui justifient la réponse.
Valider la saisie d’une énigme
Rejetez les valeurs composées et distinguez les nombres premiers valides non équilibrés des nombres équilibrés.
Constituer un jeu de suites premières
Classez chaque nombre premier avec ses voisins et son milieu explicites en vue d’une analyse ultérieure.
Questions fréquentes
Qu’est-ce qu’un nombre premier équilibré ?
C’est un nombre premier égal à la moyenne arithmétique des nombres premiers qui le précèdent et le suivent immédiatement.
Pourquoi 2 n’est-il pas équilibré ?
Deux n’a aucun nombre premier précédent et ne peut donc pas être le milieu de deux voisins premiers.
L’outil consulte-t-il une base de nombres premiers ?
Non. Il teste de manière déterministe la valeur et ses candidats voisins avec une arithmétique entière locale.
Que se passe-t-il si je saisis un nombre composé ?
Il est refusé avec un message clair au lieu d'un résultat négatif. La réponse négative est réservée aux nombres premiers qui ne sont pas centrés entre leurs voisins : les deux situations ne se confondent jamais.
Pourquoi les voisins doivent-ils être les premiers les plus proches ?
La définition utilise le premier immédiatement inférieur et le premier immédiatement supérieur. Choisir d'autres premiers ne testerait rien, c'est pourquoi l'outil cherche de chaque côté jusqu'au plus proche.
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/balanced-prime \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"number":53}'const res = await fetch("https://api.kit.forhosting.com/numth/balanced-prime", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"number": 53
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/balanced-prime",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"number": 53
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/balanced-prime", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"number":53}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"number":53}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/balanced-prime", 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
{
"number": 53
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.balanced_prime",
"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_value | 1000000000 |
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
Saisir une valeur et comprendre le résultat
La plage acceptée va de 2 à 1,000,000,000, ce qui donne à l’algorithme déterministe une limite de fonctionnement claire dans le navigateur comme avec l’API. Pour un nombre premier supérieur à 2, la réponse fournit previous_prime, next_prime, neighbor_average et is_balanced avec la valeur d’origine. Si is_balanced est vrai, les deux écarts entre nombres premiers sont identiques.
Un contrôle déterministe pour l’étude et l’automatisation
Ces choix garantissent un résultat reproductible entre le module du navigateur et le gestionnaire de l’API. Chaque requête évalue un élément et l’utilisation de l’API coûte $0.002 ; le même calcul peut s’exécuter localement dans la page pour des contrôles interactifs.
Questions techniques
Que se passe-t-il si je saisis un nombre composé ?
La requête renvoie une erreur invalid_input, car l’équilibre n’est défini ici que pour une entrée première.
Combien coûte l’utilisation de l’API ?
Chaque requête coûte $0.002. Une exécution interactive dans le navigateur est également proposée sans calcul réseau.