জাভাস্ক্রিপ্টের দ্রুততম ফ্যাক্টরিয়াল ফাংশনটি কী? [বন্ধ]

Question 1

বন্ধ । এই প্রশ্নটি আরও ফোকাস করা প্রয়োজন । এটি বর্তমানে উত্তর গ্রহণ করছে না।

এই প্রশ্নটি উন্নত করতে চান? প্রশ্নটি আপডেট করুন যাতে এটি কেবলমাত্র এই পোস্টটি সম্পাদনা করে একটি সমস্যায় ফোকাস করে ।

গত বছর বন্ধ ছিল ।

এই প্রশ্নটি উন্নত করুন

জাভাস্ক্রিপ্টে ফ্যাক্টরিয়াল ফাংশনের সত্যিকারের দ্রুত বাস্তবায়নের সন্ধান করছেন । কোন পরামর্শ?

Question 2

আপনি অনুসন্ধান করতে পারেন (1 ... 100)! ওল্ফ্রামে | আলফা আলকোণাগুলি ক্রমটি প্রাক-গণনা করতে।

প্রথম 100 নম্বরগুলি হ'ল:

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

আপনি যদি এখনও মানগুলি নিজেই গণনা করতে চান তবে আপনি স্মৃতিচারণ ব্যবহার করতে পারেন :

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

সম্পাদনা করুন: 21.08.2014

সমাধান 2

আমি ভেবেছিলাম যে অলস পুনরাবৃত্তিযুক্ত ফাংশনাল ফাংশনের একটি কার্যকারী উদাহরণ যুক্ত করা দরকারী যা তুলনা হিসাবে স্মৃতিচারণ এবং ক্যাশে সঠিক ফলাফল পেতে বড় সংখ্যা ব্যবহার করে

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

আমি ধরে নিয়েছি আপনি পরিবর্তনশীল নামের দৃশ্যমানতা সীমাবদ্ধ করতে কোনও ধরণের ক্লোজার ব্যবহার করবেন ।

সূত্র : BigNumber স্যান্ডবক্স : JsFiddle

Question 3

আপনার একটি লুপ ব্যবহার করা উচিত।

10.000 বারের জন্য 100 এর ফ্যাক্টরিয়াল গণনা করে এখানে দুটি সংস্করণ বেঞ্চমার্কযুক্ত।

পুনরাবৃত্তি

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

লাইভ এ: http://jsfiddle.net/xMpTv/

আমার ফলাফলগুলি দেখায়:
- পুনরাবৃত্ত ~ 150 মিলিসেকেন্ড
- আইট্রেটিভ ~ 5 মিলিসেকেন্ড ..

Question 4

আমি এখনও মনে করি মার্গাসের উত্তরটি সবচেয়ে ভাল। তবে আপনি যদি 0 থেকে 1 (যেমন গামা ফাংশন) এর মধ্যে সংখ্যার ফ্যাক্টরিয়ালগুলি গণনা করতে চান তবে আপনি সেই পদ্ধতির ব্যবহার করতে পারবেন না কারণ অনুসন্ধান সারণিতে অসীম মান থাকতে হবে।

তবে, আপনি পারেন ফ্যাক্টরিয়ালগুলির মানগুলি আনুমানিকভাবে নির্ধারণ , এবং এটি পুনরুক্তার সাথে নিজেকে কল করা বা কমপক্ষে লুপ করা (বিশেষত যখন মানগুলি বড় হতে শুরু করে) এর চেয়ে দ্রুততর faster

একটি ভাল আনুমানিক পদ্ধতিটি ল্যাঙ্কজোসের একটি one

জাভাস্ক্রিপ্টে এখানে একটি বাস্তবায়ন রয়েছে (আমি কয়েক মাস আগে লিখেছি এমন ক্যালকুলেটর থেকে পোর্ট করা):

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

আপনি এখন শীতল স্টাফ factorial(0.41)ইত্যাদি করতে পারেন তবে যথার্থতা কিছুটা দূরে থাকতে পারে, সর্বোপরি, এটি ফলাফলের একটি আনুমানিক x

Question 5

আপনি যদি প্রাকৃতিক সংখ্যা নিয়ে কাজ করে থাকেন তবে সন্ধানের টেবিলটি হ'ল স্পষ্ট উপায়। রিয়েল-টাইমে কোনও ফ্যাক্টরিয়াল গণনা করতে, আপনি আগে গণনা করেছেন এমন নম্বরগুলি সংরক্ষণ করে, আপনি এটি ক্যাশে দিয়ে গতি করতে পারেন। কিছুটা এইরকম:

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

আরও গতি বাড়ানোর জন্য আপনি কয়েকটি মানকে প্রাক্কলিত করতে পারেন।

Question 6

এখানে আমার সমাধান:

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

এটি সবচেয়ে সহজ উপায় (কম অক্ষর / লাইন) আমি খুঁজে পেয়েছি, কেবল একটি কোড লাইনের সাথে একটি ফাংশন।

সম্পাদনা করুন:
আপনি যদি কিছু অক্ষর সংরক্ষণ করতে চান তবে আপনি একটি তীর ফাংশন (21 বাইট) নিয়ে যেতে পারেন :

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

Question 7

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>

স্নিপেট প্রসারিত করুন

Question 8

সংক্ষিপ্ত এবং সহজ পুনরাবৃত্তি ফাংশন (আপনি এটি একটি লুপ দিয়েও করতে পারেন, তবে আমি মনে করি না যে এটি পারফরম্যান্সে কোনও পার্থক্য আনবে):

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

খুব বড় এন এর জন্য আপনি আলোড়নগুলি সান্নিধ্য ব্যবহার করতে পারেন - তবে এটি আপনাকে কেবল একটি আনুমানিক মান দেবে।

সম্পাদনা করুন: আমি কেন এই জন্য একটি ডাউনটোট পাচ্ছি তার একটি মন্তব্য চমৎকার হত ...

সম্পাদনা 2: এটি একটি লুপ ব্যবহার করে আধ্যাত্মিক হবে (যা আরও ভাল পছন্দ হবে):

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

আমি মনে করি, ক্যাশেড মানগুলি ব্যবহার করার সর্বোত্তম সমাধান হ'ল মার্গাস যেমন উল্লেখ করেছেন এবং বৃহত্তর মানগুলির জন্য আলোড়নগুলি সান্নিধ্য হিসাবে ব্যবহার করেছেন (ধরে নেওয়া হয়েছে যে আপনাকে সত্যিকারের দ্রুত হতে হবে এবং এত বড় সংখ্যার সাথে সঠিক হওয়া উচিত নয় )।

Question 9

দেখুন, মেমোভাইজারটি, যা কোনও একক-তর্কের কাজ করে এবং এটি মেমোমাইজ করে। @ XPheRe এর সমাধানের তুলনায় সামান্য দ্রুত গতিতে পরিণত হয়েছে, ক্যাশে এবং সম্পর্কিত পরীক্ষার আকারের সীমা সহ, কারণ আমি শর্টকিউটিং এবং আরও কিছু ব্যবহার করি।

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

পুনরাবৃত্ত সংস্করণের তুলনায় ক্রোমে আমার মেশিনে প্রায় 25x দ্রুত এবং এক্সফির থেকে 10% দ্রুত%

Question 10

দ্রুততম ফ্যাক্টরিয়াল ফাংশন

আমি মনে করি যে এই লুপ-ভিত্তিক সংস্করণটি দ্রুততম ফ্যাক্টরিয়াল ফাংশন হতে পারে।

function factorial(n, r = 1) {
  while (n > 0) r *= n--;
  return r;
}

// Default parameters `r = 1`,
//   was introduced in ES6

এবং এখানে আমার যুক্তি:

স্মৃতিচারণের সাথেও পুনরাবৃত্ত ফাংশনগুলির একটি ফাংশন কলের ওভারহেড থাকে (মূলত স্ট্যাকের উপর ফাংশনগুলি পুশ করে) যা লুপ ব্যবহারের চেয়ে কম পারফরম্যান্ট
যদিও forloops এবং whileloops, অনুরূপ কর্মক্ষমতা থাকবে, যার ফলে forএকটি আরম্ভের প্রকাশ এবং চূড়ান্ত প্রকাশ ছাড়া লুপ বিজোড় হচ্ছে, for(; n > 0;)হিসাবে লিখতে সম্ভবত ভালwhile(n > 0)
মাত্র দুটি প্যারামিটার nএবং rব্যবহার করা হয়, সুতরাং তাত্ত্বিকভাবে কম পরামিতি মানে মেমরি বরাদ্দে কম সময় ব্যয় করা
একটি হ্রাসযুক্ত লুপ ব্যবহার করে যা nশূন্য কিনা তা পরীক্ষা করে - আমি তত্ত্বগুলি শুনেছি যে কম্পিউটারগুলি বাইনারি সংখ্যা (0 এবং 1) যাচাই করার ক্ষেত্রে অন্যান্য পূর্ণসংখ্যার চেয়ে আরও ভাল

Question 11

আমি এই পোস্ট জুড়ে এসেছি। এখানে সমস্ত অবদানের দ্বারা অনুপ্রাণিত হয়ে আমি আমার নিজস্ব সংস্করণ নিয়ে এসেছি, যার দুটি বৈশিষ্ট্য রয়েছে যা আমি আগে আলোচনা করে দেখিনি: 1) যুক্তিটি নিশ্চিত করার জন্য একটি চেক একটি অ-নেতিবাচক পূর্ণসংখ্যা 2) ক্যাশে থেকে একটি ইউনিট তৈরি করা এবং এটিকে একটি স্ব কোডযুক্ত বিট করার ফাংশন। মজা করার জন্য, আমি এটি যথাসম্ভব কমপ্যাক্ট করার চেষ্টা করেছি। কেউ কেউ দেখতে পারেন যে মার্জিত, অন্যরা এটি ভয়াবহভাবে অস্পষ্ট মনে করতে পারেন। যাইহোক, এটি এখানে:

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

আপনি হয় ক্যাশে পূর্বে পূরণ করতে পারেন, বা কলগুলি এগিয়ে যাওয়ার সাথে সাথে এটি পূরণ করার অনুমতি দিতে পারেন। তবে প্রাথমিক উপাদানটি (আসলে (0) অবশ্যই উপস্থিত থাকতে হবে বা এটি ভেঙে যাবে।

উপভোগ করুন :)

Question 12

এটি ES6 ব্যবহার করে খুব সহজ

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

এখানে একটি উদাহরণ দেখুন

Question 13

এখানে একটি সমাধান দেওয়া হল:

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

Question 14

ES6 ব্যবহার করে আপনি এটিকে দ্রুত এবং সংক্ষিপ্ত উভয় ক্ষেত্রেই অর্জন করতে পারেন:

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

Question 15

ফ্যাকটোরিয়াল গণনা করার কোডটি আপনার প্রয়োজনীয়তার উপর নির্ভর করে।

আপনি কি ওভারফ্লো সম্পর্কে উদ্বিগ্ন?
আপনার ইনপুটগুলির কতগুলি পরিসীমা থাকবে?
আপনার পক্ষে আকার বা সময়কে ন্যূনতম করা কি আরও গুরুত্বপূর্ণ?
আপনি ফ্যাক্টরিয়াল সাথে কি করতে যাচ্ছেন?

1 এবং 4 পয়েন্ট সম্পর্কে, প্রায়শই ফ্যাক্টরিয়ালটি নিজেই মূল্যায়নের জন্য কোনও ফাংশন না করে সরাসরি ফ্যাক্টরিয়ালটির লগ মূল্যায়নের জন্য একটি ফাংশন থাকা অনেক বেশি কার্যকর ।

এই সমস্যাগুলি নিয়ে আলোচনা করে একটি ব্লগ পোস্ট এখানে । লগ ফ্যাক্টরিয়াল কম্পিউটিংয়ের জন্য এখানে কিছু সি # কোড রয়েছে যা জাভাস্ক্রিপ্টে পোর্ট করার ক্ষেত্রে তুচ্ছ। তবে উপরের প্রশ্নের উত্তরগুলির উপর নির্ভর করে আপনার প্রয়োজনগুলির পক্ষে এটি সর্বোত্তম হতে পারে না।

Question 16

এটি একটি কমপ্যাক্ট লুপ-ভিত্তিক সংস্করণ

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

অথবা আপনি ম্যাথ অবজেক্ট (পুনরাবৃত্ত সংস্করণ) ওভাররাইড করতে পারেন:

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

অথবা উভয় পন্থায় যোগদান করুন ...

Question 17

এই সত্যটি অন্বেষণ করে Number.MAX_VALUE < 171!, আমরা কেবল একটি সম্পূর্ণ লক টেবিল ব্যবহার করতে পারি কেবলমাত্র 171 কমপ্যাক্ট অ্যারে উপাদানগুলির সাথে 1.4 কিলোবাইটের চেয়ে কম মেমরি গ্রহণ করে ।

রানটাইম জটিলতা ও (1) এবং ন্যূনতম অ্যারে অ্যাক্সেস ওভারহেড সহ একটি দ্রুত অনুসন্ধানের ফাংশনটি নীচের মত দেখতে হবে:

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

স্নিপেট প্রসারিত করুন

এটি যতটা সুনির্দিষ্ট এবং তত দ্রুত এটি ব্যবহার করে Number ডেটাটাইপটি । জাভাস্ক্রিপ্টে সন্ধানের সারণীটি গণনা করা - অন্য কিছু উত্তর হিসাবে সূচিত হয়েছে - যখন নির্ভুলতা হ্রাস পাবে n! > Number.MAX_SAFE_INTEGER।

গিজিপের মাধ্যমে রানটাইম টেবিলটি সংকুচিত করে ডিস্কে এর আকারটি প্রায় 3.6 থেকে 1.8 কিলোবাইটে হ্রাস করে।

Question 18

এক লাইনের উত্তর:

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

স্নিপেট প্রসারিত করুন

Question 19

`BigInt`সুরক্ষার জন্য আইট্রেটিভ ফ্যাক্টরিয়াল

সমাধান ব্যবহার করে BigInt, একটি ES 2018 + / 2019 বৈশিষ্ট্য।

এটি উদাহরণস্বরূপ ব্যবহারের উদাহরণস্বরূপ BigInt, কারণ এখানে প্রচুর উত্তর Numberপ্রায় সমস্ত মুহুর্তেই (এমডিএন) এর নিরাপদ সীমানা থেকে রক্ষা পায় । এটি দ্রুততম নয় তবে এটি সহজ এবং এইভাবে অন্যান্য অপটিমাইজেশন (প্রথম 100 সংখ্যার ক্যাশের মতো) মানিয়ে নেওয়ার ক্ষেত্রে পরিষ্কার।

function factorial(nat) {
   let p = BigInt(1)
   let i = BigInt(nat)

   while (1 < i--) p *= i

   return p
}

ব্যবহারের উদাহরণ

// 9.332621544394415e+157
Number(factorial(100))

// "933262154439441526816992388562667004907159682643816214685929638952175999
//  932299156089414639761565182862536979208272237582511852109168640000000000
//  00000000000000"
String(factorial(100))

// 9332621544394415268169923885626670049071596826438162146859296389521759999
// 3229915608941463976156518286253697920827223758251185210916864000000000000
// 000000000000n
factorial(100)

nএকটি সাংখ্যিক আক্ষরিক মত শেষে 1303nইঙ্গিত এটা একটিBigInt প্রকার।
মনে রাখবেন যে আপনি স্পষ্টভাবে তাদের জোর করে না করাতে আপনার BigIntসাথে মিশ্রিত হওয়া উচিত নয় Numberএবং এটি করার ফলে নির্ভুলতার ক্ষতি হতে পারে।

Question 20

ES6 বৈশিষ্ট্য ব্যবহার করে, এক লাইনে এবং পুনরাবৃত্তি ছাড়াই কোড লিখতে পারে :

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

কোড স্নিপেট দেখান

var factorial=(n)=>Array.from(
       {length: n}, (v, k) => k+1)   /*Generate Array [1, 2, .., n -1, n]*/
     .reduce(
       (a, b) => a*b, 1 /*Multiply all aarray items; one with the next*/
     ); 
     

var n = prompt('Give us "n", we will calculate "n!" ?');

if (n) {
  alert(`${n}! = ${factorial(n)}`)
}

স্নিপেট প্রসারিত করুন

Question 21

কেবল সম্পূর্ণতার জন্য, এখানে একটি পুনরাবৃত্ত সংস্করণ যা টেল কল অপ্টিমাইজেশনের অনুমতি দেবে। আমি নিশ্চিত নই যে জাভাস্ক্রিপ্টে টেল কল অপ্টিমাইজেশন করা হয় কিনা ..

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

এটি কল করতে:

rFact(x, 1);

Question 22

এটি একটি পুনরাবৃত্তি সমাধান যা কম স্ট্যাক স্পেস ব্যবহার করে এবং স্ব-স্মৃতি আকারে আগের গণিত মানগুলি সংরক্ষণ করে:

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

এছাড়াও নোট করুন যে আমি এটি ম্যাথ অবজেক্টে যুক্ত করছি যা একটি অবজেক্ট আক্ষরিক তাই কোনও প্রোটোটাইপ নেই। বরং কেবল এটিকে সরাসরি ফাংশনে আবদ্ধ করুন।

Question 23

আমি বিশ্বাস করি যে উপরের মন্তব্যগুলি থেকে নিম্নলিখিতটি সর্বাধিক টেকসই এবং কার্যকর কোড। আপনি এটি আপনার বৈশ্বিক অ্যাপ্লিকেশন জেএস আর্কিটেকচারে ব্যবহার করতে পারেন ... এবং একাধিক নেমস্পেসে এটি লেখার বিষয়ে চিন্তা করবেন না (যেহেতু এটি একটি কার্য যা সম্ভবত খুব বেশি বৃদ্ধির প্রয়োজন হয় না)। আমি 2 পদ্ধতির নাম অন্তর্ভুক্ত করেছি (পছন্দ অনুসারে) তবে উভয়টি কেবলমাত্র উল্লেখ হিসাবে ব্যবহৃত হতে পারে।

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

Question 24

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

এটি ফ্লাইতে প্রথম 100 টি মানগুলির ক্যাচিং করে এবং ক্যাশেটির জন্য সুযোগের বাহ্যিক পরিবর্তনশীল প্রবর্তন করে না, মানগুলি ফাংশনটির বস্তুর বৈশিষ্ট্য হিসাবে সংরক্ষণ করে, যার অর্থ যদি আপনি জানেন factorial(n)যে ইতিমধ্যে গণনা করা হয়েছে তবে আপনি কেবল এটি হিসাবে উল্লেখ করুন factorial[n], যা কিছুটা বেশি দক্ষ। এই প্রথম 100 টি মানটি চালাতে আধুনিক ব্রাউজারগুলিতে সাব-মিলিসেকেন্ড সময় লাগবে।

Question 25

এখানে এমন একটি বাস্তবায়ন যা ইতিবাচক এবং নেতিবাচক ফ্যাকটোরিয়াল উভয়ই গণনা করে। এটি দ্রুত এবং সহজ।

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

Question 26

এখানে আমি নিজে তৈরি করেছি, 170 বা তার বেশি বয়সী সংখ্যা ব্যবহার করবেন না numbers

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

Question 27

এখানে আমার কোড

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

Question 28

ক্যাশেড লুপটি দ্রুততম হওয়া উচিত (কমপক্ষে একাধিকবার কল করার সময়)

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

Question 29

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

দ্বারা প্রদান করা http://javascript.info/tutorial/number-math যদি একটি বস্তু গণনা জন্য একটি সঠিক পূর্ণসংখ্যা নির্ণয় করা একটি সহজ উপায় হিসাবে।

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

মেমোয়াইজড ফ্যাক্টরিয়ালগুলির একটি সহজ সেট যা অপ্রয়োজনীয় গণনার প্রয়োজন হয়, "1 দ্বারা গুণিত" দিয়ে প্রক্রিয়াজাত করা যেতে পারে বা এমন একটি অঙ্ক হয় যা একটি সাধারণ সমীকরণ যা লাইভ প্রসেসিংয়ের পক্ষে মূল্যহীন।

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

অন্যান্য সদস্যদের কাছ থেকে ইনপুট পর্যালোচনা করার পরে (লগ পরামর্শটি বাদ দিয়ে, যদিও আমি পরে এটি বাস্তবায়ন করতে পারি) আমি এগিয়ে গিয়েছিলাম এবং একসাথে সরল একটি স্ক্রিপ্ট একসাথে ফেলেছিলাম। আমি একটি সাধারণ অশিক্ষিত জাভাস্ক্রিপ্ট ওওপি উদাহরণ দিয়ে শুরু করেছি এবং ফ্যাকটোরিয়ালগুলি হ্যান্ডেল করার জন্য একটি ছোট্ট ক্লাস তৈরি করেছি। তারপরে আমি আমার সংস্করণটির সংস্করণটি প্রয়োগ করেছি যা উপরে প্রস্তাবিত হয়েছিল। আমি শর্টহ্যান্ড ফ্যাক্টরিয়ালাইজেশনও বাস্তবায়ন করেছি তবে আমি একটি ছোট ত্রুটি সমন্বয় করেছি; আমি "এন <2" কে "এন <3" এ পরিবর্তন করেছি। "n <2" এখনও n = 2 প্রক্রিয়া করবে যা নষ্ট হবে, কারণ আপনি 2 * 1 = 2 এর জন্য পুনরাবৃত্তি করবেন; এটি আমার মতে অপব্যয়। আমি এটিকে "n <3" এ পরিবর্তন করেছি; কারণ এন যদি 1 বা 2 হয় তবে এটি সহজেই এন ফিরে আসবে, যদি এটি 3 বা তার বেশি হয় তবে এটি স্বাভাবিকভাবে মূল্যায়ন করবে। অবশ্যই নিয়মগুলি প্রয়োগ করার সাথে সাথে, আমি আমার ফাংশনগুলি ধরে নেওয়া কার্যকর করার ক্রমবর্ধমান ক্রমে রেখেছি। আমি বুল (সত্য | মিথ্যা) বিকল্পে যোগ করেছি স্মৃতিচারণ ও স্বাভাবিক সম্পাদনের মধ্যে দ্রুত পরিবর্তন করার অনুমতি দেওয়ার জন্য ("শৈলী" পরিবর্তন করার প্রয়োজন ছাড়াই আপনি কখনই আপনার পৃষ্ঠায় অদলবদল করতে চান তা কখনই জানতে পারবেন না) যেমনটি আমি আগে বলেছি মেমোজাইজড ফ্যাটোরিয়াল ভেরিয়েবলটি 3 টি শুরুর অবস্থানের সাথে সেট করা হয়, 4 টি অক্ষর গ্রহণ করে এবং অপচয়মূলক গণনা হ্রাস করে। তৃতীয় পুনরাবৃত্তির অতীতের সমস্ত কিছুই আপনি দ্বি সংখ্যার গণিত প্লাস পরিচালনা করছেন। আমি যদি বুঝতে পারি যে আপনি যদি এটির বিষয়ে যথেষ্ট স্টিকার থাকেন তবে আপনি কোনও ফ্যাক্টরিয়াল টেবিলের উপর চালিত হন (প্রয়োগ হিসাবে)। 4 টি অক্ষর গ্রহণ করা এবং অপব্যয়মূলক গণনা হ্রাস করা। তৃতীয় পুনরাবৃত্তির অতীতের সমস্ত কিছুই আপনি দ্বি সংখ্যার গণিত প্লাস পরিচালনা করছেন। আমি যদি বুঝতে পারি যে আপনি যদি এটির বিষয়ে যথেষ্ট স্টিকার থাকেন তবে আপনি কোনও ফ্যাক্টরিয়াল টেবিলের উপর চালিত হন (প্রয়োগ হিসাবে)। 4 টি অক্ষর গ্রহণ করা এবং অপব্যয়মূলক গণনা হ্রাস করা। তৃতীয় পুনরাবৃত্তির অতীতের সমস্ত কিছুই আপনি দ্বি সংখ্যার গণিত প্লাস পরিচালনা করছেন। আমি যদি বুঝতে পারি যে আপনি যদি এটির বিষয়ে যথেষ্ট স্টিকার থাকেন তবে আপনি কোনও ফ্যাক্টরিয়াল টেবিলের উপর চালিত হন (প্রয়োগ হিসাবে)।

এর পরে আমি কী পরিকল্পনা করেছি? স্থানীয় এবং | সেশন স্টোরেজ প্রয়োজনীয় পুনরাবৃত্তির কেস দ্বারা কেসের জন্য মঞ্জুরি দেওয়ার জন্য প্রয়োজনীয়ভাবে উপরে বর্ণিত "টেবিল" ইস্যুটি পরিচালনা করে। এটি ব্যাপকভাবে ডাটাবেস এবং সার্ভারের পাশের স্থান সংরক্ষণ করবে। তবে, যদি আপনি লোকালস্টোরের সাথে যান তবে আপনি অবশ্যই আপনার ব্যবহারকারীদের কম্পিউটারে নাম্বারগুলির একটি তালিকা সঞ্চয় করতে এবং তাদের পর্দা আরও দ্রুত দেখানোর জন্য প্রয়োজনীয় স্থানটি সন্ধান করতে চাইবেন, তবে একটি দীর্ঘ সময়ের মধ্যে এটি একটি অতি প্রয়োজনীয়তার সাথে ধীরে ধীরে হবে। আমি ভাবছি সেশনস্টোরেজ (ট্যাব পাতার পরে সাফ করা) আরও ভাল রুট হবে। সম্ভবত এটি একটি স্বয়ং ব্যালেন্সিং সার্ভার / স্থানীয় নির্ভর ক্যাশে যুক্ত করুন? ব্যবহারকারী এ এর এক্স পুনরুক্তি প্রয়োজন। ব্যবহারকারীর বি এর পুনরাবৃত্তি প্রয়োজন। এক্স + ওয়াই / 2 = স্থানীয়ভাবে ক্যাশে থাকা পরিমাণের প্রয়োজন। তারপরে লোড-টাইম সহ কেবল সনাক্ত করুন এবং বেড়ান এবং প্রতিটি ব্যবহারকারীর জন্য সঞ্চালনের সময় বেঞ্চমার্ক লাইভ করে যতক্ষণ না এটি নিজের জন্য সাইটের জন্য অনুকূলিতকরণের সাথে নিজেকে সামঞ্জস্য করে। ধন্যবাদ!

সম্পাদনা 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);
});

এই সম্পাদনাটি স্ট্যাকের অন্য একটি পরামর্শ কার্যকর করেছে এবং আমাকে ফাংশনটি ফ্যাকটোরিয়াল (সত্য) (5) হিসাবে কল করতে দেয় যা আমার লক্ষ্যগুলির মধ্যে একটি ছিল setting : 3 আমি কিছু অযথা অ্যাসাইনিংও সরিয়ে দিয়েছি এবং কিছু অ-সর্বজনীন ভেরিয়েবলের নাম সংক্ষিপ্ত করেছি।

Question 30

এখানে নতুন জাভাস্ক্রিপ্ট ফাংশনগুলি পূরণ , মানচিত্র , হ্রাস এবং নির্মাণকারী (এবং চর্বিযুক্ত তীর সিনট্যাক্স) ব্যবহার করে এখানে রয়েছে:

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

সম্পাদনা: এন === 0 হ্যান্ডেল করতে আপডেট হয়েছে

Question 31

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

জাভাস্ক্রিপ্টের দ্রুততম ফ্যাক্টরিয়াল ফাংশনটি কী? [বন্ধ]

সম্পাদনা করুন: 21.08.2014

সমাধান 2

দ্রুততম ফ্যাক্টরিয়াল ফাংশন

BigIntসুরক্ষার জন্য আইট্রেটিভ ফ্যাক্টরিয়াল

ব্যবহারের উদাহরণ

`BigInt`সুরক্ষার জন্য আইট্রেটিভ ফ্যাক্টরিয়াল