Calcul
MathCalculatrice de factorielle
Calculatrice de factorielle gratuite pour n! jusqu'à 170. Pas à pas, BigInt, approximation de Stirling, permutations et combinaisons.
Vous avez des commentaires ? Signalez des bugs, suggérez des fonctionnalités ou partagez vos idées — nous lisons toutUne calculatrice de factorielle calcule n! — le produit de tous les entiers positifs de 1 à n. La fonction apparaît partout en combinatoire, en probabilités, en calcul différentiel (séries de Taylor) et en statistiques, et croît plus vite que n'importe quel polynôme ou exponentielle simple. Cette calculatrice accepte les entiers de 0 à 170 en précision standard ; au-delà de n = 170 le résultat dépasse le domaine IEEE-754 (~1,8 × 10³⁰⁸), donc les entrées plus grandes utilisent l'arithmétique BigInt pour préserver chaque chiffre. Chaque calcul produit la valeur finale et le déroulé pas à pas pour vérifier la multiplication à la main, utile pour relire un devoir, monter un problème de combinatoire ou résoudre des probabilités.
Qu'est-ce qu'une factorielle ?
Une factorielle est le produit de tous les entiers positifs de 1 jusqu'à un entier non négatif n. Elle s'écrit n! et se lit « n factorielle » — la notation au point d'exclamation a été introduite par le mathématicien français Christian Kramp en 1808 et s'est imposée car elle est concise et sans ambiguïté. Par convention 0! = 1 ; c'est le produit vide, l'analogue multiplicatif de la somme vide qui vaut 0, indispensable pour que des formules combinatoires comme C(n,0) = 1 et la série de Taylor de e^x se comportent correctement en n = 0.
Comment la calculer ?
Méthode manuelle :
- Choisissez l'entier non négatif n dont vous voulez la factorielle.
- Listez les entiers de 1 à n.
- Multipliez-les successivement : 1 × 2 × 3 × ... × n. La multiplication itérative de gauche à droite est la plus simple et évite une pile de récursion profonde.
- Le produit obtenu est n!.
- Pour vérification, cette calculatrice affiche aussi le déroulé complet afin de contrôler chaque étape.
Formule :
n! = n × (n-1) × (n-2) × ... × 2 × 1, avec le cas de base 0! = 1.
Exemple
Pour 5! :
5! = 5 × 4 × 3 × 2 × 1 = 120
Donc 5! = 120.
Modifiez n dans le champ de saisie pour calculer n'importe quelle autre factorielle ; le déroulé sous le résultat s'adapte automatiquement.
Cas particuliers :
- 0! = 1 (par convention, le produit vide)
- 1! = 1
- Croissance très rapide : 10! = 3 628 800 ; 20! ≈ 2,43 × 10¹⁸ ; 70! ≈ 1,2 × 10¹⁰⁰
Applications :
- Permutations : n! arrangements de n objets distincts
- Combinaisons : C(n,k) = n! / (k! × (n−k)!)
- Probabilités et statistiques (coefficients multinomiaux, espérances)
- Développements en série de Taylor : e^x = Σ xⁿ / n!
- Approximation de Stirling pour les grandes valeurs : n! ≈ √(2πn) × (n/e)ⁿ
Questions fréquentes
Trois arguments indépendants pointent tous vers 0! = 1, ce qui explique que les mathématiciens aient fixé cette convention plutôt que de laisser 0! indéfini. (1) Produit vide : en algèbre, multiplier zéro nombres donne l'élément neutre de la multiplication, soit 1 — la même logique fait que x⁰ = 1 pour tout x non nul. (2) Argument combinatoire : C(n,0) compte le nombre de façons de ne rien choisir parmi n éléments, soit exactement 1 (la sélection vide). La formule C(n,0) = n! / (0! × n!) ne vaut 1 que si 0! = 1. (3) Cohérence récursive : la règle n! = n × (n−1)! doit tenir en n = 1, donnant 1! = 1 × 0!, donc 0! doit valoir 1 pour que 1! = 1. La même logique s'étend à la fonction gamma Γ(n+1) = n!, où Γ(1) = 1 par intégration directe. Ainsi 0! = 1 n'est pas arbitraire — c'est la seule valeur qui maintient tout l'édifice cohérent.
Parce que 170! ≈ 7,257 × 10³⁰⁶ est la plus grande factorielle qui tient dans un nombre flottant double précision IEEE-754 standard, dont le maximum est d'environ 1,798 × 10³⁰⁸. 171! ≈ 1,241 × 10³⁰⁹ déborde en Infinity dans JavaScript, Excel et la plupart des calculatrices. Pour traiter des n plus grands, le calcul passe à BigInt — un type entier à précision arbitraire intégré au JavaScript moderne — qui calcule n'importe quelle factorielle, limité seulement par la mémoire et le temps. 1000! a 2568 chiffres et prend une fraction de seconde ; 100000! a 456 574 chiffres et prend quelques secondes. Pour des factorielles très grandes, on n'a en général pas besoin de la valeur exacte — on veut l'approximation de Stirling log(n!) ≈ n log n − n + 0,5 log(2πn), précise à une fraction de pour cent même pour des n modérés.
L'approximation de Stirling dit que n! ≈ √(2πn) × (n/e)ⁿ pour n grand. L'erreur reste sous 1% dès n ≥ 10 et sous 0,1% dès n ≥ 100, donc essentiellement exacte pour toute application où chaque chiffre n'importe pas. La version logarithmique, log(n!) ≈ n log n − n + 0,5 log(2πn), est celle qu'on utilise vraiment en pratique car l'exponentielle brute déborde aussi vite que n! lui-même — pas le logarithme. Mécanique statistique, théorie de l'information et méthode du col en analyse complexe s'appuient toutes sur la forme logarithmique pour estimer l'entropie d'un système, le comportement asymptotique des coefficients binomiaux ou le théorème central limite. James Stirling l'a publiée dans son Methodus Differentialis de 1730 ; une version plus précise avait été trouvée auparavant par de Moivre. La raffiner donne la série de Stirling, une expansion asymptotique utile en analyse numérique.
Les trois comptent des arrangements, mais diffèrent dans ce qu'ils considèrent distinct. La factorielle n! compte le nombre d'ordres de n objets distincts — ABCDE a 5! = 120 ordres. La permutation P(n,k) = n! / (n−k)! compte les arrangements ordonnés de k objets choisis parmi n — P(5,2) = 5!/3! = 20 paires ordonnées, AB et BA comptés séparément. La combinaison C(n,k) = n! / (k! × (n−k)!) compte les sélections non ordonnées de k objets parmi n — C(5,2) = 10 car AB et BA sont désormais identiques. Règle pratique : si l'ordre compte, utilisez la permutation ; sinon, la combinaison. La factorielle est le cas particulier k = n. Les trois se réduisent à des expressions soignées avec des factorielles, ce qui fait de la calculatrice de factorielle la base de toute la combinatoire.
Oui — elles sont définies par la fonction gamma Γ, qui étend la factorielle à presque tous les réels et complexes. La relation exacte est n! = Γ(n+1), donc Γ(1) = 0! = 1, Γ(2) = 1! = 1, Γ(3) = 2! = 2, etc. Pour des arguments non entiers, on obtient des valeurs utiles comme Γ(0,5) = √π, équivalent à (−0,5)! = √π ≈ 1,7725. Les valeurs demi-entières apparaissent partout en physique — volume d'une sphère à n dimensions, distribution du khi-deux, normalisation de la vitesse de Maxwell-Boltzmann. Les entiers négatifs, eux, restent indéfinis : Γ a des pôles en 0, −1, −2, ..., donc (−1)!, (−2)! etc. sont infinis. Cette calculatrice renvoie une erreur pour une entrée entière négative au lieu de produire une valeur trompeuse. Pour des valeurs de Γ, un outil dédié à la fonction gamma ou un langage avec une routine tgamma est le bon choix.
Les zéros terminaux de n! proviennent des facteurs 10 du produit, et chaque 10 demande un 2 et un 5. La quantité de 2 dans n! dépasse toujours celle de 5, donc le nombre de zéros terminaux égale le total de facteurs 5 dans la factorisation de n!. La formule de Legendre le donne exactement : Z(n) = ⌊n/5⌋ + ⌊n/25⌋ + ⌊n/125⌋ + ⌊n/625⌋ + ... jusqu'à ce que les termes s'annulent. Exemple : 100! a ⌊100/5⌋ + ⌊100/25⌋ = 20 + 4 = 24 zéros terminaux ; 1000! en a 200 + 40 + 8 + 1 = 249. C'est un problème classique des mathématiques de concours, et l'identité de Legendre donne la réponse en O(log n) — bien plus vite que calculer la factorielle elle-même. La même technique fonctionne dans n'importe quelle base : pour la base b, comptez la multiplicité de chaque facteur premier de b dans n! et prenez le minimum après normalisation.
L'itératif est presque toujours meilleur pour n!. La définition récursive n! = n × (n−1)! se lit naturellement et c'est l'exemple manuel pour enseigner la récursion, mais en pratique elle alloue une trame de pile par entier jusqu'au cas de base. Les moteurs JavaScript limitent typiquement la pile à 10 000 à 100 000 trames avant de lever RangeError: Maximum call stack size exceeded, et Python à 1 000 par défaut. Une boucle itérative — for (let i = 2, r = 1n; i <= n; i++) r *= BigInt(i) — utilise une pile constante et tourne plus vite, sans surcoût d'appel par pas. Certains langages (Scheme, Scala dans des cas particuliers) optimisent l'appel terminal et peuvent compiler une factorielle récursive bien écrite en boucle, mais JavaScript et Python non. Pour apprendre, écrivez la version récursive une fois pour sentir la structure ; pour du code de production ou du calcul côté navigateur comme cette calculatrice, utilisez la boucle.
Plus souvent qu'on ne le pense. (1) Probabilités : paradoxe des anniversaires, dénombrement des mains de poker, probabilités de loterie — tout repose sur des combinaisons, qui sont des rapports de factorielles. (2) Statistiques : lois binomiale et multinomiale, khi-deux et gamma, approximations normales fondées sur Stirling pour des lois discrètes. (3) Analyse : toute série de Taylor — sin, cos, e^x, log(1+x) — a n! au dénominateur. C'est ce n! qui fait converger la série plus vite que ne croît le polynôme au numérateur. (4) Physique : fonctions de partition en mécanique statistique, comptage de chemins en mécanique quantique, sections efficaces de diffusion. (5) Informatique : algorithmes de dénombrement, analyse en moyenne du tri (n! permutations sur n éléments), dérivations de la FFT. (6) Vie quotidienne : compte des anagrammes (« combien d'arrangements des lettres de MISSISSIPPI ? » utilise 11! divisé par les factorielles des lettres répétées), plans de table, estimations de robustesse de mots de passe.
CALCULATRICES MATHéMATIQUES32
WUTOOLS