Formule de Legendre : exposant d’un nombre premier dans n!
Le premier 5 apparaît 24 fois dans la factorielle de 100 : 100 divisé par 5 donne 20, 20 divisé par 5 donne 4, et 20 plus 4 font 24. Saisissez n et un premier p pour obtenir cet exposant en quelques divisions. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- N
- 100
- Puissance (W)
- 5
- Exposant
- 24
Ce calculateur applique la formule de Legendre pour fournir l’exposant exact d’un nombre premier p choisi dans la factorielle de n. Au lieu de construire l’immense entier n!, il divise plusieurs fois n par p et additionne les quotients entiers. Vous pouvez l’utiliser pour la divisibilité, les zéros terminaux, les coefficients binomiaux, l’enseignement de la théorie des nombres et les concours de programmation. Chaque entrée est contrôlée comme un entier borné, puis la primalité de p est vérifiée séparément afin qu’une base composée produise une erreur explicite plutôt qu’un résultat trompeur.
Ce que mesure la formule de Legendre
La formule compte les occurrences du nombre premier p dans 1 × 2 × 3 × … × n. Chaque multiple de p apporte un facteur, chaque multiple de p² en apporte un autre, puis les multiples de p³ en ajoutent encore un. L’exposant vaut donc floor(n/p) + floor(n/p²) + floor(n/p³) + les termes suivants, jusqu’au quotient nul.
Le calculateur ne développe jamais la factorielle. La réponse rappelle n et p pour rester sans ambiguïté.
Validation et calcul des entrées
Envoyez n, entier positif ou nul, et p, entier premier au moins égal à 2. Les chaînes composées uniquement de chiffres décimaux sont admises, tandis que fractions, valeurs négatives, chaînes vides, infinis et dépassements de limite sont refusés. Après validation, quotient = n devient successivement floor(quotient/p), et chaque valeur est ajoutée à l’exposant jusqu’à zéro.
Cette forme évite le débordement lié aux puissances.
Réutiliser l’exposant dans d’autres problèmes
Pour obtenir l’exposant de p dans C(n, k), calculez celui de n!, puis soustrayez ceux de k! et (n-k)!. Pour savoir si p^a divise n!, vérifiez que a ne dépasse pas le résultat. En base dix, les zéros terminaux proviennent des paires de 2 et 5 ; comme les facteurs 2 sont plus nombreux, l’exposant de 5 donne leur nombre.
Cette capacité répond volontairement pour un seul nombre premier au lieu de renvoyer toute la factorisation. Elle convient aux cours, correcteurs automatiques, concours et validations serveur. Pour plusieurs nombres premiers, effectuez une requête par valeur.
Cas d’usage
Vérifier la plus grande puissance première d’une factorielle
Trouvez le plus grand exposant a tel que p^a divise n! sans calculer la factorielle.
Évaluer des valuations binomiales
Combinez trois exposants factoriels pour obtenir exactement celui de p dans un coefficient binomial.
Questions fréquentes
Que représente l’exposant ?
C’est le plus grand entier a tel que p^a divise n! sans reste.
Pourquoi p doit-il être premier ?
Cette forme de la formule calcule la valuation d’un seul nombre premier ; les valeurs composées sont refusées pour éviter une qualification erronée.
Le calculateur construit-il la factorielle de n ?
Non. Il additionne des quotients entiers successifs et évite l’immense valeur de la factorielle.
Que se passe-t-il si p est supérieur à n ?
Le résultat est nul, car aucun facteur de 1 à n n’est divisible par p.
Combien de zéros finaux compte la factorielle de 100 ?
Elle en compte 24. Chaque zéro final demande un 2 et un 5, et une factorielle contient plus de facteurs 2 que de facteurs 5 : le compte égale donc l’exposant de 5, soit 24 pour 100.
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/legendre-formula \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":100,"p":5}'const res = await fetch("https://api.kit.forhosting.com/numth/legendre-formula", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 100,
"p": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/legendre-formula",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 100,
"p": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/legendre-formula", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":100,"p":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":100,"p":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/legendre-formula", 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": 100,
"p": 5
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.legendre_formula",
"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_n | 1000000000 |
max_p | 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
Le résultat est la valuation p-adique de n!, souvent notée v_p(n!).
Ce que mesure la formule de Legendre
Pour n = 100 et p = 5, les termes 20, 4 et 0 donnent 24 : 5²⁴ divise 100!, contrairement à 5²⁵. Il inclut n = 0 et n = 1, dont les factorielles valent 1 et donnent un exposant nul.
Validation et calcul des entrées
Le service vérifie aussi la primalité : p = 7 réussit, mais p = 9 renvoie invalid_input. Le calcul est déterministe, sans réseau ni hasard, et identique dans le navigateur et l’API. Une requête API réussie coûte $0.002.
Cas d'intégration
Calculer les zéros terminaux d’une factorielle
Utilisez p = 5 pour les zéros décimaux de n!, ou adaptez le résultat à une base de puissance première.
Questions techniques
Combien coûte un calcul par API ?
Chaque requête API réussie coûte $0.002. Le calculateur du navigateur utilise le même noyau déterministe.