Grand illustrette illustrée Traopidence Marco Da Marco Trapp Da Marco Da Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco Marco

Vous pouvez rechercher (1 … 100)! Sur WolframAlpha pour pré-calculer la séquence factorielle.

Marco illustréeTappdMMM citjoyea DawoTdMM citea aleeaeaeaeaeaeaeaeaeaeaeaeaeaeaea dela lleg

1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000, 355687428096000, 6402373705728000, 121645100408832000, 2432902008176640000, 51090942171709440000, 1124000727777607680000, 25852016738884976640000, 620448401733239439360000, 15511210043330985984000000, 403291461126605635584000000, 10888869450418352160768000000, 304888344611713860501504000000, 8841761993739701954543616000000, 265252859812191058636308480000000, 8222838654177922817725562880000000, 263130836933693530167218012160000000, 8683317618811886495518194401280000000, 295232799039604140847618609643520000000, 10333147966386144929666651337523200000000, 371993326789901217467999448150835200000000, 13763753091226345046315979581580902400000000, 523022617466601111760007224100074291200000000, 20397882081197443358640281739902897356800000000, 815915283247897734345611269596115894272000000000, 33452526613163807108170062053440751665152000000000, 1405006117752879898543142606244511569936384000000000, 60415263063373835637355132068513997507264512000000000, 2658271574788448768043625811014615890319638528000000000, 119622220865480194561963161495657715064383733760000000000, 5502622159812088949850305428800254892961651752960000000000, 258623241511168180642964355153611979969197632389120000000000, 12413915592536072670862289047373375038521486354677760000000000, 608281864034267560872252163321295376887552831379210240000000000, 30414093201713378043612608166064768844377641568960512000000000000, 1551118753287382280224243016469303211063259720016986112000000000000, 80658175170943878571660636856403766975289505440883277824000000000000, 4274883284060025564298013753389399649690343788366813724672000000000000, 230843697339241380472092742683027581083278564571807941132288000000000000, 12696403353658275925965100847566516959580321051449436762275840000000000000, 710998587804863451854045647463724949736497978881168458687447040000000000000, 40526919504877216755680601905432322134980384796226602145184481280000000000000, 2350561331282878571829474910515074683828862318181142924420699914240000000000000, 138683118545689835737939019720389406345902876772687432540821294940160000000000000, 8320987112741390144276341183223364380754172606361245952449277696409600000000000000, 507580213877224798800856812176625227226004528988036003099405939480985600000000000000, 31469973260387937525653122354950764088012280797258232192163168247821107200000000000000, 1982608315404440064116146708361898137544773690227268628106279599612729753600000000000000, 126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000, 8247650592082470666723170306785496252186258551345437492922123134388955774976000000000000000, 544344939077443064003729240247842752644293064388798874532860126869671081148416000000000000000, 36471110918188685288249859096605464427167635314049524593701628500267962436943872000000000000000, 2480035542436830599600990418569171581047399201355367672371710738018221445712183296000000000000000, 171122452428141311372468338881272839092270544893520369393648040923257279754140647424000000000000000, 11978571669969891796072783721689098736458938142546425857555362864628009582789845319680000000000000000, 850478588567862317521167644239926010288584608120796235886430763388588680378079017697280000000000000000, 61234458376886086861524070385274672740778091784697328983823014963978384987221689274204160000000000000000, 4470115461512684340891257138125051110076800700282905015819080092370422104067183317016903680000000000000000, 330788544151938641225953028221253782145683251820934971170611926835411235700971565459250872320000000000000000, 24809140811395398091946477116594033660926243886570122837795894512655842677572867409443815424000000000000000000, 1885494701666050254987932260861146558230394535379329335672487982961844043495537923117729972224000000000000000000, 145183092028285869634070784086308284983740379224208358846781574688061991349156420080065207861248000000000000000000, 11324281178206297831457521158732046228731749579488251990048962825668835325234200766245086213177344000000000000000000, 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000, 71569457046263802294811533723186532165584657342365752577109445058227039255480148842668944867280814080000000000000000000, 5797126020747367985879734231578109105412357244731625958745865049716390179693892056256184534249745940480000000000000000000, 475364333701284174842138206989404946643813294067993328617160934076743994734899148613007131808479167119360000000000000000000, 39455239697206586511897471180120610571436503407643446275224357528369751562996629334879591940103770870906880000000000000000000, 3314240134565353266999387579130131288000666286242049487118846032383059131291716864129885722968716753156177920000000000000000000, 281710411438055027694947944226061159480056634330574206405101912752560026159795933451040286452340924018275123200000000000000000000, 24227095383672732381765523203441259715284870552429381750838764496720162249742450276789464634901319465571660595200000000000000000000, 2107757298379527717213600518699389595229783738061356212322972511214654115727593174080683423236414793504734471782400000000000000000000, 185482642257398439114796845645546284380220968949399346684421580986889562184028199319100141244804501828416633516851200000000000000000000, 16507955160908461081216919262453619309839666236496541854913520707833171034378509739399912570787600662729080382999756800000000000000000000, 1485715964481761497309522733620825737885569961284688766942216863704985393094065876545992131370884059645617234469978112000000000000000000000, 135200152767840296255166568759495142147586866476906677791741734597153670771559994765685283954750449427751168336768008192000000000000000000000, 12438414054641307255475324325873553077577991715875414356840239582938137710983519518443046123837041347353107486982656753664000000000000000000000, 1156772507081641574759205162306240436214753229576413535186142281213246807121467315215203289516844845303838996289387078090752000000000000000000000, 108736615665674308027365285256786601004186803580182872307497374434045199869417927630229109214583415458560865651202385340530688000000000000000000000, 10329978488239059262599702099394727095397746340117372869212250571234293987594703124871765375385424468563282236864226607350415360000000000000000000000, 991677934870949689209571401541893801158183648651267795444376054838492222809091499987689476037000748982075094738965754305639874560000000000000000000000, 96192759682482119853328425949563698712343813919172976158104477319333745612481875498805879175589072651261284189679678167647067832320000000000000000000000, 9426890448883247745626185743057242473809693764078951663494238777294707070023223798882976159207729119823605850588608460429412647567360000000000000000000000, 933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000, 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 

Si vous souhaitez toujours calculer les valeurs vous-même, vous pouvez utiliser la mémoisation :

 var f = []; function factorial (n) { if (n == 0 || n == 1) return 1; if (f[n] > 0) return f[n]; return f[n] = factorial(n-1) * n; } ​ 

Modifier: 21.08.2014

Solution 2

Je pensais qu'il serait utile d'ajouter un exemple pratique de la fonction factorielle itérative paresseuse qui utilise de gros nombres pour obtenir un résultat exact avec la mémoire et le cache en comparaison

 var f = [new BigNumber("1"), new BigNumber("1")]; var i = 2; function factorial(n) { if (typeof f[n] != 'undefined') return f[n]; var result = f[i-1]; for (; i <= n; i++) f[i] = result = result.multiply(i.toString()); return result; } var cache = 100; //due to memoization following line will cache first 100 elements factorial(cache); 

Je suppose que vous utiliserez une sorte de fermeture pour limiter la visibilité des noms de variables.

Ref : BigNumber Sandbox : JsFiddle

Vous devriez utiliser une boucle.

Voici deux versions comparées en calculant le factoriel de 100 pour 10 000 fois.

Récursif

 function rFact(num) { if (num === 0) { return 1; } else { return num * rFact( num - 1 ); } } 

Itératif

 function sFact(num) { var rval=1; for (var i = 2; i <= num; i++) rval = rval * i; return rval; } 

Live at: http://jsfiddle.net/xMpTv/

Mes résultats montrent:
– Recursive ~ 150 millisecondes
– Iterative ~ 5 millisecondes ..

Je pense toujours que la réponse de Margus est la meilleure. Toutefois, si vous souhaitez calculer les factoriels des nombres dans la plage de 0 à 1 (c.-à-d. La fonction gamma), vous ne pouvez pas utiliser cette approche car la table de recherche devra contenir des valeurs infinies.

Cependant, vous pouvez approximer les valeurs des factorielles, et c'est assez rapide, plus rapide que l'appel récursif ou le boucler au moins (en particulier lorsque les valeurs commencent à grossir).

Une méthode de bonne approximation est celle de Lanczos

Voici une implémentation en JavaScript (portée par un calculateur que j'ai écrit il y a quelques mois):

 function factorial(op) { // Lanczos Approximation of the Gamma Function // As described in Numerical Recipes in C (2nd ed. Cambridge University Press, 1992) var z = op + 1; var p = [1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 1.208650973866179E-3, -5.395239384953E-6]; var d1 = Math.sqrt(2 * Math.PI) / z; var d2 = p[0]; for (var i = 1; i <= 6; ++i) d2 += p[i] / (z + i); var d3 = Math.pow((z + 5.5), (z + 0.5)); var d4 = Math.exp(-(z + 5.5)); d = d1 * d2 * d3 * d4; return d; } 

Vous pouvez maintenant faire des choses intéressantes comme factorial(0.41) , etc. Cependant, la précision pourrait être un peu désactivée, après tout, c'est une approximation du résultat.

La table de recherche est la façon évidente d'aller, si vous travaillez avec des nombres naturels. Pour calculer tout facteur factoriel en temps réel, vous pouvez l'accélérer avec un cache, en sauvegardant les chiffres que vous avez déjà calculés. Quelque chose comme:

 factorial = (function() { var cache = {}, fn = function(n) { if (n === 0) { return 1; } else if (cache[n]) { return cache[n]; } return cache[n] = n * fn(n -1); }; return fn; })(); 

Vous pouvez précalculer certaines valeurs afin de l'accélérer encore plus.

Fonction récursive courte et facile (vous pourriez le faire avec une boucle, aussi, mais je ne pense pas que cela ferait une différence dans les performances):

 function factorial (n){ if (n==0 || n==1){ return 1; } return factorial(n-1)*n; } 

Pour un très grand nombre de n, vous pouvez utiliser l' approximation des remparts – mais cela ne vous donnera qu'une valeur approximative.

EDIT: un commentaire sur la raison pour laquelle je vais avoir un downvote pour cela aurait été agréable …

EDIT2: ce serait l'expérience en utilisant une boucle (ce serait le meilleur choix):

 function factorial (n){ j = 1; for(i=1;i<=n;i++){ j = j*i; } return j; } 

Je pense que la meilleure solution serait d'utiliser les valeurs mises en cache, comme l'a mentionné Margus et d'utiliser l' approximation de soulèvement pour des valeurs plus grandes (supposé que vous devez être vraiment rapide et ne doit pas être exact sur de si gros nombres).

Voici ma solution:

 function fac(n){ return(n<2)?1:fac(n-1)*n; } 

C'est le moyen le plus simple (moins de caractères / lignes) que j'ai trouvé, seulement une fonction avec une seule ligne de code.

Modifier:
Si vous voulez vraiment enregistrer des caractères, vous pouvez utiliser une fonction flèche (21 octets) :

 f=n=>(n<2)?1:f(n-1)*n 

Voici, le memoizer, qui prend toute fonction d'argument unique et le mémoise. Il s'avère être légèrement plus rapide que la solution @ xPheRe, y compris la limite de la taille du cache et la vérification associée, car j'utilise des courts-circuits et ainsi de suite.

 function memoize(func, max) { max = max || 5000; return (function() { var cache = {}; var remaining = max; function fn(n) { return (cache[n] || (remaining-- >0 ? (cache[n]=func(n)) : func(n))); } return fn; }()); } function fact(n) { return n<2 ? 1: n*fact(n-1); } // construct memoized version var memfact = memoize(fact,170); // xPheRe's solution var factorial = (function() { var cache = {}, fn = function(n) { if (n === 0) { return 1; } else if (cache[n]) { return cache[n]; } return cache[n] = n * fn(n -1); }; return fn; }()); 

Approximativement 25 fois plus rapide sur ma machine en Chrome que la version récursive, et 10% plus rapide que celle de xPheRe's.

Je suis tombé sur cette publication. Inspiré par toutes les contributions, j'ai proposé ma propre version, qui a deux fonctionnalités dont je n'ai pas déjà été discuté: 1) Un contrôle pour s'assurer que l'argument est un entier non négatif 2) Faire sortir une unité du cache et La fonction pour en faire un code de code autonome. Pour le plaisir, j'ai essayé de le rendre aussi compact que possible. Certains peuvent trouver cela élégant, d'autres peuvent penser que cela est terriblement obscur. Quoi qu'il en soit, voici:

 var fact; (fact = function(n){ if ((n = parseInt(n)) < 0 || isNaN(n)) throw "Must be non-negative number"; var cache = fact.cache, i = cache.length - 1; while (i < n) cache.push(cache[i++] * i); return cache[n]; }).cache = [1]; 

Vous pouvez soit pré-remplir le cache, soit permettre de le remplir pendant que les appels passent. Mais l'élément initial (pour le fait (0) doit être présent ou il se brise.

Prendre plaisir 🙂

Le code de calcul factoriel dépend de vos besoins.

1. Êtes-vous préoccupé par le débordement?
2. Quelle gamme d'intrants avez-vous?
3. Est-il plus important pour vous de minimiser la taille ou l'heure?
4. Que vas-tu faire avec le factoriel?

En ce qui concerne les points 1 et 4, il est souvent plus utile d'avoir une fonction pour évaluer le log du facteur directement plutôt que d'avoir une fonction pour évaluer le facteur factoriel lui-même.

Voici une publication sur le blog qui traite de ces problèmes. Voici un code C # pour calculer la logarithme logarithmique qui serait trivial au port en JavaScript. Mais ce n'est peut-être pas le meilleur pour vos besoins en fonction de vos réponses aux questions ci-dessus.

C'est très simple en utilisant ES6

const factorial = n => n ? (n * factorial(n-1)) : 1;

Voir un exemple ici

Juste pour l'exhaustivité, voici une version récursive qui permettrait l'optimisation des appels de queue. Je ne sais pas si les optimisations d'appel de queue sont effectuées en JavaScript.

 function rFact(n, acc) { if (n == 0 || n == 1) return acc; else return rFact(n-1, acc*n); } 

Pour l'appeler:

 rFact(x, 1); 

Il s'agit d'une solution itérative qui utilise moins d'espace de pile et enregistre les valeurs précédemment calculées de manière autonome:

 Math.factorial = function(n){ if(this.factorials[n]){ // memoized return this.factorials[n]; } var total=1; for(var i=n; i>0; i--){ total*=i; } this.factorials[n] = total; // save return total; }; Math.factorials={}; // store 

Notez également que j'ajoute ceci à l'objet Math qui est un objet littéraire, donc il n'y a pas de prototype. Plutôt que de les relier à la fonction directement.

Je crois que le texte suivant est le morceau de code le plus durable et le plus efficace à partir des commentaires ci-dessus. Vous pouvez l'utiliser dans votre architecture js de l'application mondiale … et ne vous inquiétez pas de l'écrire dans plusieurs espaces de noms (puisqu'il s'agit d'une tâche qui n'a probablement pas besoin d'augmenter). J'ai inclus 2 noms de méthode (selon la préférence), mais les deux peuvent être utilisés car ils sont juste des références.

 Math.factorial = Math.fact = function(n) { if (isNaN(n)||n<0) return undefined; var f = 1; while (n > 1) { f *= n--; } return f; }; 

 // if you don't want to update the Math object, use `var factorial = ...` Math.factorial = (function() { var f = function(n) { if (n < 1) {return 1;} // no real error checking, could add type-check return (f[n] > 0) ? f[n] : f[n] = n * f(n -1); } for (i = 0; i < 101; i++) {f(i);} // precalculate some values return f; }()); factorial(6); // 720, initially cached factorial[6]; // 720, same thing, slightly faster access, // but fails above current cache limit of 100 factorial(100); // 9.33262154439441e+157, called, but pulled from cache factorial(142); // 2.6953641378881614e+245, called factorial[141]; // 1.89814375907617e+243, now cached 

Cela fait la mise en cache des 100 premières valeurs à la volée et n'introduit pas une variable externe dans la portée du cache, stockant les valeurs en tant que propriétés de l'objet de fonction lui-même, ce qui signifie que si vous connaissez le factorial(n) Calculé, vous pouvez simplement vous référer à cela comme factorial[n] , ce qui est légèrement plus efficace. L'exécution de ces 100 premières valeurs prendra un temps de sous-millisecondes dans les navigateurs modernes.

Voici une implémentation qui calcule à la fois des facteurs factoriels positifs et négatifs. C'est rapide et simple.

 var factorial = function(n) { return n > 1 ? n * factorial(n - 1) : n < 0 ? n * factorial(n + 1) : 1; } 

Voici mon code

 function factorial(num){ var result = num; for(i=num;i>=2;i--){ result = result * (i-1); } return result; } 

 function isNumeric(n) { return !isNaN(parseFloat(n)) && isFinite(n) } 

Fourni par http://javascript.info/tutorial/number-math comme un moyen simple d'évaluer si un objet est un nombre entier approprié pour le calcul.

 var factorials=[[1,2,6],3]; 

Un ensemble simple de facteurs factoriels mémoisés nécessitant des calculs redondants peut être traité avec "multiplier par 1", ou un chiffre qui est une équation simple ne vaut pas le traitement en direct.

 var factorial = (function(memo,n) { this.memomize = (function(n) { var ni=n-1; if(factorials[1]<n) { factorials[0][ni]=0; for(var factorial_index=factorials[1]-1;factorials[1]<n;factorial_index++) { factorials[0][factorials[1]]=factorials[0][factorial_index]*(factorials[1]+1); factorials[1]++; } } }); this.factorialize = (function(n) { return (n<3)?n:(factorialize(n-1)*n); }); if(isNumeric(n)) { if(memo===true) { this.memomize(n); return factorials[0][n-1]; } return this.factorialize(n); } return factorials; }); 

Après avoir passé en revue les commentaires des autres membres (à l'exception des conseils de Log, bien que je puisse l'implémenter plus tard), je suis allé de l'avant et je liaisons un script assez simple. J'ai commencé par un simple exemple d'OOP JavaScript instruit et j'ai construit une petite classe pour gérer les facteurs factoriels. J'ai ensuite mis en œuvre ma version du Memoization qui a été suggéré ci-dessus. J'ai également implémenté la sténographie, mais j'ai fait un petit ajustement d'erreur; J'ai changé le "n <2" à "n <3". "N <2" continuerait à traiter n = 2 qui serait un gaspillage, car vous répéteriez un 2 * 1 = 2; C'est un gaspillage à mon avis. Je l'ai changé en "n <3"; Parce que si n est 1 ou 2, il retournera simplement n, s'il est 3 ou plus, il évaluera normalement. Bien sûr, comme les règles s'appliquent, j'ai mis mes fonctions dans un ordre décroissant d'exécution supposée. J'ai ajouté dans l'option bool (true | false) pour permettre une modification rapide entre l'exécution memo'ed et normal (Vous ne savez jamais quand vous souhaitez échanger sur votre page sans avoir à changer le "style") Comme je l'ai déjà dit avant le La variable factorielle mémoisée est définie avec les 3 positions de départ, prenant 4 caractères et minimisant les calculs inutiles. Tout au long de la troisième itération, vous gérez les mathématiques à deux chiffres plus. Je pense que si vous vous trouviez suffisamment sur ce sujet, vous exécuteriez sur une table factorielle (telle que mise en œuvre).

Qu'est-ce que j'ai prévu après cela? Local et | stockage de session pour permettre un cache cas par cas d'itérations nécessaires, traitant essentiellement le problème "table" mentionné ci-dessus. Cela permettrait également de sauvegarder massivement la base de données et l'espace côté serveur. Cependant, si vous allez avec localStorage, vous serez essentiellement en train d'aspirer de l'espace sur votre ordinateur d'ordinateur simplement pour stocker une liste de nombres et rendre leur écran plus rapide, mais pendant une longue période de temps avec un besoin immense, cela serait lent. Je pense que sessionStorage (clearing after Tab files) serait une route beaucoup mieux. Peut-être combiner cela avec un serveur d'équilibrage automatique / cache dépendant local? L'utilisateur A a besoin d'itérations X. L'utilisateur B a besoin d'itérations. X + Y / 2 = Quantité nécessaire localement mise en cache. Ensuite, il suffit de détecter les délais de chargement et de temps d'exécution en direct pour chaque utilisateur jusqu'à ce qu'il s'ajuste à l'optimisation du site lui-même. Merci!

Modifier 3:

 var f=[1,2,6]; var fc=3; var factorial = (function(memo) { this.memomize = (function(n) { var ni=n-1; if(fc<n) { for(var fi=fc-1;fc<n;fi++) { f[fc]=f[fi]*(fc+1); fc++; } } return f[ni]; }); this.factorialize = (function(n) { return (n<3)?n:(factorialize(n-1)*n); }); this.fractal = (function (functio) { return function(n) { if(isNumeric(n)) { return functio(n); } return NaN; } }); if(memo===true) { return this.fractal(memomize); } return this.fractal(factorialize); }); 

Cette édition implémente une autre suggestion Stack et me permet d'appeler la fonction comme factoriel (vrai) (5), ce qui a été l'un de mes objectifs. : 3 J'ai également supprimé une affectation inutile et j'ai raccourci certains noms de variables non publiques.

Il s'agit d'une version compacte basée sur une boucle

 function factorial( _n ) { var _p = 1 ; while( _n > 0 ) { _p *= _n-- ; } return _p ; } 

Ou vous pouvez remplacer l'objet Math (version récursive):

 Math.factorial = function( _x ) { return _x <= 1 ? 1 : _x * Math.factorial( --_x ) ; } 

Ou rejoignez les deux approches …

Voici ce que j'ai fait moi-même, n'utilisez pas de nombres supérieurs à 170 ou moins de 2 ans.

 function factorial(x){ if((!(isNaN(Number(x)))) && (Number(x)<=170) && (Number(x)>=2)){ x=Number(x);for(i=x-(1);i>=1;--i){ x*=i; } }return x; } 

La boucle mise en cache devrait être la plus rapide (au moins lorsque appelée plusieurs fois)

 var factorial = (function() { var x =[]; return function (num) { if (x[num] >0) return x[num]; var rval=1; for (var i = 2; i <= num; i++) { rval = rval * i; x[i] = rval; } return rval; } })(); 

Ce serait probablement très simple d'abord et peut-être à partir de ce code court que vous le définiriez mieux dépend de vos besoins:

 <body> <button onclick="fact()">Open the Prompt</button> <h2 id="output"></h2> <script> function fact(){ var enter=prompt("Enter You Factorial Number Bellow :",""); var Num_enter=Number(enter); for (var i=1,FactNumber=1;i<=Num_enter;i++){ FactNumber=FactNumber*i; } if(Num_enter){ document.getElementById("output").textContent="the factorial of "+ Num_enter + " is: "+Num_enter+"!= "+ FactNumber; } } </script> </body> 

  function factorial(num){ var num=Number(num); if (num < 0){ return "this is not a positive number"; } else{ for (i=2 , f=1 ; i<=num;i++){ f=f*i; } return f; } } // the function assumes that a number < 0 is null and factorial of any word is considerate as factorial of 0 // console.log("-5! ="+factorial(-1)); console.log("something ="+factorial("something")); console.log("15! ="+factorial(15)); console.log("20! ="+factorial(20)); 

Cela renverra le factoriel de n

 function f(n) { var e = n; if (e == 1 | e == 0) return 1; while (n--) { if (n < 1) break; e *= n; } return e } 

En utilisant les fonctions ES6, vous pouvez écrire un code sur ONE line et sans récursion :

 var factorial=(n)=>Array.from({length:n},(v,k)=>k+1).reduce((a,b)=>a*b,1) 

C'est la façon la plus simple dont je sais de faire une fonction factorielle

 function factorial(num) { var result = 1; for(var i = 2; i<= num; i++) { result *= i; } return result; } 

Voici une utilisant les nouvelles fonctionnalités javascript remplissant , carte , réduction et constructeur (et la syntaxe de la flèche en graisse):

 Math.factorial = n => n === 0 ? 1 : Array(n).fill(null).map((e,i)=>i+1).reduce((p,c)=>p*c) 

Modifier: mis à jour pour gérer n === 0

Étant donné qu'un factoriel est simplement une multiplication dégénérative du nombre donné à 1, il serait plus simple de passer à travers la multiplication:

 Math.factorial = function(n) { if (n === 0||n === 1) { return 1; } else { for(var i = n; i > 0; --i) { //always make sure to decrement the value BEFORE it's tacked onto the original as a product n *= i; } return n; } } 

 var factorial = (function() { var cache = [1]; return function(value) { for (var index = cache.length; index <= value; index++) { cache[index] = index * cache[index - 1] } return cache[value]; } })(); 

Je trouve cela utile dans les mêmes cas:

 function factorialDivision(n, d) { var value = 1; for (d++ < n) { value *= d; } return value; } 

  used closure for this with the helper (getFact) , I think this approach is neat hope this helps factorial of n : using closures*/ function getFact(num) { if (num > 1) return num * getFact(num - 1); else return 1; } function makeFact(fn) { return function(num) { return fn(num); } } makeFact(getFact)(5) //120 

 function findFact() { result = 1; //Variable declared earlier operation = " ! "; //Variable declared earlier for(var i = 0;i<x;i++) { //Variable declared earlier (x is user input) result*=(xi); } write(x.toString() + operation + " = " + result.toString()); //Function I made myself result = 0; } 

Je trouve ce code assez simple à comprendre; Il exécute une boucle for, en multipliant "résultat" par x (le nombre), puis x-1, puis x-2, et ainsi de suite. De même, vous pouvez utiliser 1x2x3x4...xn plutôt que nxn-1x...x2x1 avec

 function findFact() { result = 1;//Variable declared earlier operation = " ! ";//Variable declared earlier for(var i = 1;i<=x;i++) {//Variable declared earlier (x is user input) result*=(xi); } write(x.toString() + operation + " = " + result.toString());//Function I made myself result = 0; }