Calculateur de factorisation en nombres premiers
Décompose un entier en puissances de nombres premiers : 360 s'écrit 2³ × 3² × 5, chaque premier à côté de son exposant. Vous voyez aussi le nombre de premiers distincts, le total et si le nombre est lui-même premier. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Entier positif à factoriser
- 360
- Oméga
- 3
- Grand omega
- 6
Tout entier supérieur à un se factorise de manière unique en nombres premiers élevés à des puissances — le théorème fondamental de l'arithmétique. Ce calculateur de factorisation en nombres premiers prend un entier positif, le décompose en ces puissances premières avec un algorithme BigInt déterministe, et renvoie chaque base avec son exposant afin que vous puissiez auditer des exemples de classe de taille RSA, vérifier des devoirs, ou injecter des facteurs structurés dans un autre pipeline sans boucles de division d'essai écrites à la main.
Ce que renvoie réellement la factorisation en nombres premiers
La factorisation en nombres premiers réécrit un entier n comme un produit de nombres premiers élevés à des exposants positifs, par exemple 360 = 2³ × 3² × 5. L'unicité à l'ordre près est garantie par le théorème fondamental de l'arithmétique, si bien que deux factorisations correctes du même n s'accordent toujours une fois les nombres premiers triés.
Ce calculateur ne s'arrête pas à une liste plate de facteurs premiers avec multiplicité ; il les regroupe en puissances premières et indique chaque base avec son exposant, ce qui est la forme dont les formules de théorie des nombres, les fonctions radicales, et les calculs d'indicatrice d'Euler ont généralement besoin.
Comment appeler le calculateur et lire le résultat
Soumettez un seul champ n — un entier JavaScript sûr ou une simple chaîne décimale sans virgules, espaces, ou notation scientifique. En interne, le moteur promeut n en BigInt, retire les facteurs de deux et de trois, puis parcourt une roue de diviseurs candidats 6k±1 jusqu'à la racine carrée de ce qui reste. Lorsque la boucle se termine, tout reste supérieur à un est lui-même un nombre premier et est ajouté comme puissance première finale.
Le tableau factors est ordonné par base ascendante, les exposants sont des entiers ordinaires, et les bases sont des chaînes décimales afin que les appelants puissent faire l'aller-retour avec de très grands nombres premiers sans perte de précision. Restez dans la limite publiée de chiffres ; au-delà de cette limite, la requête échoue rapidement plutôt que de consommer du CPU sur une recherche par division d'essai intraitable.
Cas d’usage
Vérification de devoirs et de concours
Vérifiez les solutions d'élèves ou de concours en comparant les puissances premières renvoyées aux factorisations calculées à la main, pour les composés comme pour les nombres premiers.
Questions fréquentes
Le calculateur de factorisation en nombres premiers est-il gratuit ?
L'outil du navigateur s'exécute gratuitement sur votre appareil.
Pourquoi n doit-il être au moins 2 ?
La factorisation en nombres premiers est définie pour les entiers supérieurs à 1.
Puis-je factoriser des nombres plus grands que la plage d'entiers sûrs de JavaScript ?
Oui. Passez n comme une chaîne décimale ; le moteur utilise BigInt jusqu'à la limite de chiffres publiée afin que les grands exemples de classe restent exacts.
Combien de facteurs premiers a 360 ?
Il a 3 premiers distincts, 2, 3 et 5, et 6 facteurs premiers au total en comptant les répétitions, car 2 apparaît trois fois et 3 deux fois. Les deux comptes accompagnent le résultat.
Comment savoir si mon nombre est premier ?
Le résultat l'indique directement. Un nombre premier n'a qu'une entrée, le nombre lui-même avec l'exposant 1, et il est signalé comme premier ; tout autre nombre montre au moins deux facteurs premiers.
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/prime-factorization \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":"360"}'const res = await fetch("https://api.kit.forhosting.com/numth/prime-factorization", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": "360"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/prime-factorization",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": "360"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/prime-factorization", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":"360"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":"360"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/prime-factorization", 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": "360"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.prime_factorization",
"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 | 18 |
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
Les résultats restent exacts en tant que chaînes décimales, jamais arrondis en virgule flottante, et le chemin gratuit du navigateur correspond à l'API octet par octet.
Ce que renvoie réellement la factorisation en nombres premiers
La réponse porte aussi omega (le compte de bases premières distinctes) et big_omega (le nombre total de facteurs premiers en comptant la multiplicité), plus un indicateur is_prime qui est true exactement lorsque n lui-même est premier. Les grandes valeurs voyagent sous forme de chaînes décimales afin que rien ne soit arrondi par la virgule flottante IEEE, et le même contrat s'exécute gratuitement dans le navigateur et via le chemin de l'API payante à $0.002 par requête réussie.
Comment appeler le calculateur et lire le résultat
Les valeurs doivent être des entiers d'au moins 2 ; un, zéro, les nombres négatifs, et les fractions sont rejetés avec invalid_input et ne sont jamais facturés. Les noms de champs alias number et value sont acceptés par commodité.
Où les puissances premières structurées sont utiles
Injectez les facteurs structurés dans des vérifications d'indicatrice d'Euler, de radical, ou d'abondance ; vérifiez qu'un module de défi est un produit des nombres premiers que vous attendez ; ou documentez la signature première des tailles de table de hachage et des graines aléatoires. Comme l'algorithme est pur et déterministe — pas d'appels réseau, pas d'aléatoire, pas de dépendance à l'horloge murale — la même entrée produit toujours le même JSON, ce qui rend les exemples de référence stables et l'outil gratuit du navigateur identique bit à bit à l'API. La validation échouée ne consomme jamais de solde ; seules les factorisations réussies facturent le $0.002 publié. Utilisez l'outil du navigateur pour l'exploration interactive et l'API lorsqu'un backend, un notebook, ou un travail par lots doit factoriser de nombreux entiers sous un seul solde KIT prépayé sans abonnement.
Cas d'intégration
Démonstrations de classe de cryptographie
Factorisez de petits produits de style RSA et montrez les bases plus les exposants comme un JSON structuré au lieu d'une seule chaîne opaque.
Utilitaires de théorie des nombres pour pipelines
Émettez omega, big_omega, et les puissances premières pour des calculs d'indicatrice, de radical, ou d'abondance dans des pipelines mathématiques automatisés.
Questions techniques
Comment factoriser un entier en nombres premiers avec cette API ?
Envoyez un objet POST avec le champ n réglé sur un entier ≥ 2 (ou une chaîne décimale). La réponse liste factors comme des paires { base, exponent } plus omega, big_omega, et is_prime.
Le résultat est-il déterministe entre le navigateur et l'API ?
Oui. La même routine pure de division d'essai alimente les deux chemins, si bien que des entrées identiques produisent un JSON identique sans réseau ni aléatoire impliqués.