ForHosting KIT · Mathématiques

Calculateur de nombre premier maison par factorisation

12 se factorise en 2 × 2 × 3 ; en accolant ces chiffres on obtient 223, qui est premier : le premier maison de 12 est donc 223. Saisissez une valeur de départ entre 2 et mille milliards pour voir toute la chaîne. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

N: 12

Vous obtenez

Nombre premier maison: 223
Itérations: 1
Séquence: 12, 223

Un nombre premier maison s’obtient en factorisant un entier composé, en écrivant ses facteurs premiers par ordre croissant sans séparateur, puis en répétant l’opération jusqu’à atteindre un nombre premier. Ce calculateur exécute exactement cette suite, affiche tous les entiers intermédiaires et indique le nombre de transformations. Des limites explicites d’itération et d’arithmétique garantissent aussi qu’une suite difficile ou excessivement longue produit une erreur claire au lieu de mobiliser des ressources sans borne.

Création de la suite par concaténation des facteurs

Commencez par un entier supérieur à un. S’il est déjà premier, il constitue son propre nombre premier maison et le calcul se termine après zéro itération. Sinon, décomposez-le entièrement en facteurs premiers, conservez les répétitions et classez les facteurs du plus petit au plus grand.

Supprimez les signes de multiplication et les espaces, puis lisez les chiffres décimaux accolés comme l’entier suivant. Par exemple, douze se factorise en deux fois deux fois trois : la valeur suivante est donc 223. Comme 223 est premier, cette suite s’achève après une transformation.

L’ordre est essentiel : la procédure standard emploie des facteurs non décroissants, ce qui rend le résultat reproductible. La réponse comprend le nombre premier final sous forme de chaîne décimale, le nombre de transformations et la suite complète depuis la valeur fournie. Les chaînes préservent les entiers exacts lorsqu’une valeur intermédiaire dépasse la plage numérique sûre du navigateur.

Le résultat ne dépend d’aucun hasard, service externe ou tableau enregistré.

Comprendre les limites et les erreurs

Les trajectoires peuvent croître rapidement, et certaines valeurs initiales produisent des nombres composés bien plus difficiles à factoriser que l’entrée. L’exécution bornée fait donc partie du contrat mathématique du calculateur. L’entier initial doit se situer entre deux et mille milliards, tandis que chaque valeur générée doit rester dans la plage non signée de 64 bits prise en charge.

Vous pouvez choisir une limite comprise entre une et vingt itérations ; la valeur par défaut est vingt. Si la suite n’atteint pas de nombre premier dans ce délai, la requête renvoie une erreur d’entrée non valide précisant que la limite sûre est dépassée. Une autre erreur claire signale que la factorisation ou une valeur intermédiaire excède sa protection.

Ces erreurs ne prouvent pas l’inexistence d’un nombre premier maison : elles indiquent uniquement que la trajectoire n’a pas abouti dans le périmètre informatique publié. Relever une limite réduite peut aider, sans contourner les protections arithmétiques.

Lire et vérifier le résultat

Considérez la suite comme une piste d’audit, et non le nombre final comme une réponse inexpliquée. Chaque paire d’éléments voisins représente une opération complète : factoriser le composé précédent, trier ses facteurs premiers, concaténer leurs écritures décimales et obtenir la valeur suivante. Le champ des itérations égale le nombre de transitions ; il vaut donc toujours une unité de moins que la longueur de la suite.

Le dernier élément est identique au nombre premier maison et a réussi un test déterministe de primalité adapté au domaine de 64 bits. Pour comparer un autre programme, vérifiez qu’il conserve les multiplicités, effectue un tri numérique et concatène sans séparateur.

Cas d’usage

Explorer les mathématiques récréatives

Suivez l’évolution d’un nombre composé par concaténations successives jusqu’à son nombre premier terminal.

Créer des exemples pédagogiques vérifiables

Exploitez la suite complète pour illustrer factorisation, multiplicité, tri, concaténation et primalité.

Tester une autre implémentation

Comparez chaque chaîne intermédiaire et le nombre d’itérations à une référence déterministe.

Questions fréquentes

Un nombre premier peut-il servir d’entrée ?

Oui. Il est renvoyé comme son propre nombre premier maison, avec zéro itération et une suite à un élément.

Une erreur de limite signifie-t-elle qu’il n’existe aucune solution ?

Non. Elle indique seulement que la suite n’a pas abouti dans la limite choisie ou la plage de calcul prise en charge.

Comment les facteurs répétés sont-ils traités ?

Chaque occurrence est conservée. Ainsi, douze emploie les facteurs 2, 2 et 3 pour produire 223.

Quel est le nombre premier maison de 12 ?

C’est 223. 12 se décompose en 2, 2 et 3 ; écrits côte à côte par ordre croissant, ils forment 223, déjà premier, donc la chaîne s’arrête après une seule étape.

Pourquoi l’ordre des facteurs compte-t-il ?

Parce qu’accoler les mêmes facteurs dans un autre ordre donne un autre nombre. La méthode standard écrit toujours les premiers du plus petit au plus grand, si bien que tout le monde obtient la même chaîne.

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

POSThttps://api.kit.forhosting.com/numth/home-prime

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/home-prime \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"n":12}'

const res = await fetch("https://api.kit.forhosting.com/numth/home-prime", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "n": 12
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/numth/home-prime",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "n": 12
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/home-prime", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"n":12}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"n":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/home-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

{
  "n": 12
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "numth.home_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

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

`max_iterations`	20
`max_n`	1000000000000

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

Lire et vérifier le résultat

En automatisation API, gardez les résultats sous forme de chaînes afin d’éviter une perte de précision. Une réussite atteste l’achèvement dans les limites ; une erreur typée signale proprement une restriction de ressources.

Questions techniques

Quel est le prix du calculateur ?

Chaque requête API coûte $0.002 ; la version navigateur exécute localement la même logique déterministe.

Pourquoi les valeurs sont-elles des chaînes ?

Les entiers intermédiaires peuvent dépasser la précision exacte de JavaScript ; les chaînes décimales conservent tous les chiffres dans JSON.

Consulter la documentation complète du KIT →

Lancer gratuitement

Exemple résolu

Création de la suite par concaténation des facteurs

Comprendre les limites et les erreurs

Lire et vérifier le résultat

Cas d’usage

Explorer les mathématiques récréatives

Créer des exemples pédagogiques vérifiables

Tester une autre implémentation

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Limites

Erreurs

Notes techniques

Lire et vérifier le résultat

Questions techniques

merci