What is the fastest factorial function in JavaScript?

Question

Looking for a really fast implementation of factorial functions in JavaScript. Do you have some ideas?

Answer 1

You can search (1 ... 100)! on WolframAlpha to pre-calculate the factorial sequence.

The first 100 numbers:

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 

If you still want to calculate the values ​​yourself, you can use memoization :

 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; } ​ 

Edit: 08/21/2014

Decision 2

I thought it would be useful to add a working example of a lazy iterative factorial function that uses large numbers to get an accurate result with a record and cache as a comparison

 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); 

I assume that you are using some kind of closure to limit the visibility of the variable name.

Link : BigNumber Sandbox : JsFiddle

Answer 2

You must use a loop.

Here are two versions that are estimated by calculating the factorial 100 10,000 times.

Recursive

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

Iterative

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

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

My results show:
- Recursive ~ 150 milliseconds

- Iterative ~ 5 milliseconds ..

Answer 3

I still think Margus's answer is the best. However, if you want to calculate factorials of numbers in the range from 0 to 1 (i.e., the Gamma function), then you cannot use this approach, because the search table must contain infinite values.

However, you can approximate the values ​​of factorials, and this is pretty fast, faster than recursively invoking yourself or at least looping (especially when the values ​​start to increase).

A good approximation method is Lanczos one

Here is the implementation in JavaScript (ported from a calculator that I wrote a few months ago):

 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; } 

Now you can do cool things, such as factorial(0.41) , etc., however, the accuracy may be a little low, in the end, this is an approximation of the result.

Answer 4

A lookup table is the obvious way if you are working with natural numbers. To calculate any factorial in real time, you can speed it up using the cache, saving the numbers you calculated earlier. Something like:

 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; })(); 

You can pre-calculate some values ​​to speed it even further.

Answer 5

Here is my solution:

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

This is the easiest way (fewer characters / lines) that I found, only a function with one line of code.

---

Edit:
If you really want to save several characters, you can use the Arrow function (21 bytes):

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

Answer 6

short and simple recursive function (you can do this with a loop too, but I don't think that would affect performance):

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

for very large n, you can use the applique of curls - but this will give you an approximate value.

EDIT: A comment about why I get downvote for this would be nice ...

EDIT2: this will be using the soul using a loop (which would be a better choice):

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

I think the best solution would be to use cached values, as Margus mentioned, and use curl applique for large values ​​(it is assumed that you have to be very fast and not necessarily be so accurate on such large numbers).

Answer 7

Here is a memoizer that takes any function with one argument and remembers it. It turns out that it will be a little faster than the @xPheRe solution , including a cache size limit and related verification, because I use shortcircuiting, etc.

 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 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; }()); 

About 25 times faster on my machine in Chrome than in the recursive version, and 10% faster than xPheRe.

Answer 8

Only one line with ES6

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

 const factorial =(n) =>!(n > 1) ? 1 : factorial(n - 1) * n; function print(value) { document.querySelector('.result').innerHTML = value; } 

 .result { margin-left: 10px; } 

 <input onkeyup="print(factorial(this.value))" type="number"/> <span class="result">......</span> 

Hide result

Answer 9

I came across this post. Inspired by all the contributions here, I came up with my own version, which has two functions that I have not seen before: 1) Checking that the argument is a non-negative integer 2) Extracting the block from the cache and a function to make it one stand-alone bit of code. For pleasure, I tried to make it as compact as possible. Some may find it elegant; others may think it is terribly obscure. Anyway, here it is:

 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]; 

You can either pre-populate the cache or allow it to populate when making calls. But the original element (for fact (0) must be present or it will break.

Enjoy :)

Answer 10

It is very simple using ES6.

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

See an example here.

Answer 11

Here is one solution:

 function factorial(number) { total = 1 while (number > 0) { total *= number number = number - 1 } return total } 

Answer 12

Using ES6, you can achieve this both quickly and in a short time:

 const factorial = n => [...Array(n + 1).keys()].slice(1).reduce((acc, cur) => acc * cur, 1) 

Answer 13

Fastest factorial function

I think this loop-based version might be the fastest factorial function.

 function factorial(n, r = 1) { while (n > 0) r *= n--; return r; } // Default parameters 'r = 1', // was introduced in ES6 

And here are my reasoning:

• Recursive functions, even with memorization, have an overhead when calling a function (mainly transferring functions to the stack), which is less efficient than using a loop
• Although the for and while loops have the same performance, the for loop without an initialization expression and end expression looks strange; it's probably best to write for(; n > 0;) as while(n > 0)
• Only two parameters n and r , therefore theoretically fewer parameters mean less time spent on memory allocation
• Uses a reduced loop that checks if n zero - I have heard theories that computers check binary numbers (0 and 1) better than they check other integers

Answer 14

The code for calculating factorial depends on your requirements.

• Are you concerned about overflow?
• What input range will you have?
• What is more important for you to minimize the size or time?
• What are you going to do with factorial?

As for points 1 and 4, it is often more useful to have a function to evaluate the logarithm of the factorial directly, rather than to have a function to evaluate the factorial itself.

Here 's a blog post discussing these issues. Here is some C # code to compute the log factorial , which would be trivial to port to JavaScript. But this may not be the best for your needs, depending on your answers to the questions above.

Answer 15

This is a compact version based on a loop.

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

Or you can override the Math object (recursive version):

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

Or combine both approaches ...

Answer 16

Using the fact that Number.MAX_VALUE < 171! , we can simply use the complete search table , consisting of only 171 compact array elements, occupying less than 1.4 kilobytes of memory.

A quick search function with O (1) execution complexity and minimal access to resources will look like this:

 // Lookup table for n! for 0 <= n <= 170: const factorials = [1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800,87178291200,1307674368e3,20922789888e3,355687428096e3,6402373705728e3,121645100408832e3,243290200817664e4,5109094217170944e4,1.1240007277776077e21,2.585201673888498e22,6.204484017332394e23,1.5511210043330986e25,4.0329146112660565e26,1.0888869450418352e28,3.0488834461171387e29,8.841761993739702e30,2.6525285981219107e32,8.222838654177922e33,2.631308369336935e35,8.683317618811886e36,2.9523279903960416e38,1.0333147966386145e40,3.7199332678990125e41,1.3763753091226346e43,5.230226174666011e44,2.0397882081197444e46,8.159152832478977e47,3.345252661316381e49,1.40500611775288e51,6.041526306337383e52,2.658271574788449e54,1.1962222086548019e56,5.502622159812089e57,2.5862324151116818e59,1.2413915592536073e61,6.082818640342675e62,3.0414093201713376e64,1.5511187532873822e66,8.065817517094388e67,4.2748832840600255e69,2.308436973392414e71,1.2696403353658276e73,7.109985878048635e74,4.0526919504877214e76,2.3505613312828785e78,1.3868311854568984e80,8.32098711274139e81,5.075802138772248e83,3.146997326038794e85,1.98260831540444e87,1.2688693218588417e89,8.247650592082472e90,5.443449390774431e92,3.647111091818868e94,2.4800355424368305e96,1.711224524281413e98,1.1978571669969892e100,8.504785885678623e101,6.1234458376886085e103,4.4701154615126844e105,3.307885441519386e107,2.48091408113954e109,1.8854947016660504e111,1.4518309202828587e113,1.1324281178206297e115,8.946182130782976e116,7.156945704626381e118,5.797126020747368e120,4.753643337012842e122,3.945523969720659e124,3.314240134565353e126,2.81710411438055e128,2.4227095383672734e130,2.107757298379528e132,1.8548264225739844e134,1.650795516090846e136,1.4857159644817615e138,1.352001527678403e140,1.2438414054641308e142,1.1567725070816416e144,1.087366156656743e146,1.032997848823906e148,9.916779348709496e149,9.619275968248212e151,9.426890448883248e153,9.332621544394415e155,9.332621544394415e157,9.42594775983836e159,9.614466715035127e161,9.90290071648618e163,1.0299016745145628e166,1.081396758240291e168,1.1462805637347084e170,1.226520203196138e172,1.324641819451829e174,1.4438595832024937e176,1.588245541522743e178,1.7629525510902446e180,1.974506857221074e182,2.2311927486598138e184,2.5435597334721877e186,2.925093693493016e188,3.393108684451898e190,3.969937160808721e192,4.684525849754291e194,5.574585761207606e196,6.689502913449127e198,8.094298525273444e200,9.875044200833601e202,1.214630436702533e205,1.506141741511141e207,1.882677176888926e209,2.372173242880047e211,3.0126600184576594e213,3.856204823625804e215,4.974504222477287e217,6.466855489220474e219,8.47158069087882e221,1.1182486511960043e224,1.4872707060906857e226,1.9929427461615188e228,2.6904727073180504e230,3.659042881952549e232,5.012888748274992e234,6.917786472619489e236,9.615723196941089e238,1.3462012475717526e241,1.898143759076171e243,2.695364137888163e245,3.854370717180073e247,5.5502938327393044e249,8.047926057471992e251,1.1749972043909107e254,1.727245890454639e256,2.5563239178728654e258,3.80892263763057e260,5.713383956445855e262,8.62720977423324e264,1.3113358856834524e267,2.0063439050956823e269,3.0897696138473508e271,4.789142901463394e273,7.471062926282894e275,1.1729568794264145e278,1.853271869493735e280,2.9467022724950384e282,4.7147236359920616e284,7.590705053947219e286,1.2296942187394494e289,2.0044015765453026e291,3.287218585534296e293,5.423910666131589e295,9.003691705778438e297,1.503616514864999e300,2.5260757449731984e302,4.269068009004705e304,7.257415615307999e306]; // Lookup function: function factorial(n) { return factorials[n] || (n > 170 ? Infinity : NaN); } // Test cases: console.log(factorial(NaN)); // NaN console.log(factorial(-Infinity)); // NaN console.log(factorial(-1)); // NaN console.log(factorial(0)); // 1 console.log(factorial(170)); // 7.257415615307999e+306 < Number.MAX_VALUE console.log(factorial(171)); // Infinity > Number.MAX_VALUE console.log(factorial(Infinity)); // Infinity 

Hide result

This is as accurate and fast as using the Number data type. Computing a lookup table in Javascript - as some other recommendations suggest - will decrease accuracy if n! > Number.MAX_SAFE_INTEGER n! > Number.MAX_SAFE_INTEGER .

Compressing the runtime table through gzip reduces the size of the disk from 3.6 to 1.8 kilobytes.

Answer 17

One answer:

 const factorial = (num, accumulator) => num <= 1 ? accumulator || 1 : factorial(--num, num * (accumulator || num + 1)); factorial(5); // 120 factorial(10); // 3628800 factorial(3); // 6 factorial(7); // 5040 // et cetera 

Hide result

Answer 18

Iterative BigInt with BigInt for Security

The solution uses BigInt , ES 2018 + / 2019.

This working example uses BigInt because many of the answers here are completely BigInt from the secure Number (MDN) border almost immediately. This is not the fastest, but simplest and, therefore, clearer to adapt other optimizations (for example, the cache of the first 100 numbers).

 function factorial(nat) { let p = BigInt(1) let i = BigInt(nat) while (1 < i--) p *= i return p } 

---

Usage example

 // 9.332621544394415e+157 Number(factorial(100)) // "933262154439441526816992388562667004907159682643816214685929638952175999 // 932299156089414639761565182862536979208272237582511852109168640000000000 // 00000000000000" String(factorial(100)) // 9332621544394415268169923885626670049071596826438162146859296389521759999 // 3229915608941463976156518286253697920827223758251185210916864000000000000 // 000000000000n factorial(100) 

• n at the end of a numeric literal such as 1303n indicates the type of BigInt .
• Remember that you should not mix BigInt with Number unless you explicitly force them, and this can lead to a loss of precision.

Answer 19

Just for completeness, here is a recursive version that would allow tail call optimization. I'm not sure that tail call optimization is done in JavaScript, though ...

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

To call it:

 rFact(x, 1); 

Answer 20

This is an iterative solution that uses less stack space and saves previously calculated self-help values:

 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 

Also note that I am adding this to the Math object, which is the object literal, so there is no prototype. Rather, simply binding them to a function directly.

Answer 21

I believe the next most stable and efficient piece of code from the comments above. You can use this in your global js application architecture ... and not worry about writing it in multiple namespaces (since this is a task that probably doesn't need a lot of enlargement). I have included 2 method names (based on preferences), but both of them can be used as they are just references.

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

Answer 22

 // 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 

This does the caching of the first 100 values ​​"on the fly" and does not introduce an external variable into the cache area, storing the values ​​as properties of the function object itself, which means that if you know that factorial(n) has already been calculated, you can simply refer on it like factorial[n] , which is a bit more efficient. Running these first 100 values ​​in modern browsers will take a sub-millisecond time.

Answer 23

Here is an implementation that calculates both positive and negative factorials. It is quick and easy.

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

Answer 24

Here I did it myself, I do not use numbers more than 170 or less than 2.

 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; } 

Answer 25

Here is my code

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

Answer 26

The cached loop should be the fastest (at least when called multiple times)

 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; } })(); 

Answer 27

Here is one of them that uses the newer javascript fill , map , reduce functions and the constructor (and the thick arrow syntax):

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

Edit: updated to handle n === 0

Answer 28

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

Provided by http://javascript.info/tutorial/number-math as an easy way to evaluate if an object is the correct integer to calculate.

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

A simple set of noticed factorials that require redundant calculations can be processed with "multiplication by 1" or a single digit, which is a simple equation that should not be processed in real time.

 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; }); 

After watching input from other participants (with the exception of Log recommendations, although I can implement this later), I went ahead and threw the script together, which is pretty simple. I started with a simple uneducated JavaScript OOP example and built a small class for processing factorials. Then I implemented my version of Memoization, which was proposed above. I also implemented abbreviated factorization, however I made a small error correction; I changed "n <2" to "n <3". "n <2" will still handle n = 2, which will be waste, because you will iterate over 2 * 1 = 2; in my opinion, this is a waste. I changed it to "n <3"; because if n is 1 or 2, it will just return n, if it is 3 or more, it will be evaluated normally. Of course, as the rules apply, I put my functions in descending order of the intended execution. I added the bool parameter (true | false) to allow a quick change between recording and normal execution (you just don’t know when you want to exchange on your page without changing the "style") As I said, the memoized factorials variable is set to 3 starting positions, taking 4 characters and minimizing wasteful calculations. Everything that has passed after the third iteration, you use to calculate two-digit math plus. I suppose if you, where intently enough, tell about it on the factorial table (as implemented).

What did I plan after that? local & | session storage, in order to provide the cache of the necessary iterations in each case, mainly handling the "table" problem mentioned above. This will also significantly save database and server space. However, if you go with localStorage, you will essentially be sucking up space on your user's computer, just to save the list of numbers and make their screen faster, however, for a long period of time with great demand, this would be slow. I think sessionStorage (cleaning up after Tab tabs) would be a much better route. , / ? A X. B . X + Y/2 = . , . Thank!

Edit 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); }); 

Stack factorial (true) (5), .: 3 .

Answer 29

Using ES6 functions, you can write code on ONE line and without recursion :

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

Answer 30

 function computeFactorialOfN(n) { var output=1; for(i=1; i<=n; i++){ output*=i; } return output; } computeFactorialOfN(5);