আমি কীভাবে ধনাত্মক সংখ্যার ফ্যাক্টরিয়ালটি খুঁজে পাব?

18

চ্যালেঞ্জ:

এমন একটি প্রোগ্রাম বা একটি ফাংশন লিখুন যা একটি ধনাত্মক সংখ্যার তথ্য দেয় এবং এর ফ্যাক্টরিয়াল ফেরত দেয় ।

দ্রষ্টব্য: এটি একটি কোড-ট্রোলিং প্রশ্ন। দয়া করে প্রশ্ন এবং / অথবা উত্তরগুলি গুরুত্ব সহকারে নেবেন না। আরও তথ্য এখানে । প্রতিটি কোড-ট্রোলিং প্রশ্নও একটি জনপ্রিয়তা-প্রতিযোগিতামূলক প্রশ্ন, তাই সর্বাধিক ভোট দেওয়া উত্তর জিততে পারে।

popularity-contest  code-trolling 
— alephalpha
সূত্র
6
— পেটর পুদলেক
4
-1, দুঃখিত, কারণ আমরা এই কোড ট্রোলিং প্রশ্নগুলির একটি বিশাল বন্যা পাচ্ছি এবং এটি তাদের কাছে সত্যিকার অর্থে নতুন কিছু যোগ করে না
— ডুরকনব
— পল
সরকারী অবস্থান অনুযায়ী কোড-ট্রোলিং অপসারণের প্রক্রিয়া চলছে । এই প্রশ্নের অনেক উত্তর সহ মোটামুটি ভোট রয়েছে, যার মধ্যে অনেকগুলি চূড়ান্তভাবে ভোট হয়েছে। এটি জরিপে 50% এরও বেশি "ডিলিট" ভোট পেয়েছে , তবে এটি এতটা উত্তর এবং ভোট পেয়েছে এটি অনন্য, তাই আমি এটি itতিহাসিক তাত্পর্য হিসাবে লক করছি।
— ডুরকনব

উত্তর:

46

এটি একটি খুব সাধারণ সংখ্যামূলক কম্পিউটিং সমস্যা যা আমরা স্ট্রিলিংয়ের সমীকরণের সাথে সমাধান করতে পারি :

স্ট্রিলিংয়ের আনুমানিক সূত্র

আপনি দেখতে পাচ্ছেন যে, সেই সূত্রে একটি বর্গক্ষেত্রের বৈশিষ্ট্য রয়েছে, যার আনুমানিক প্রায় একটি উপায়ও আমাদের প্রয়োজন হবে। এটির জন্য আমরা তথাকথিত "ব্যাবিলনীয় পদ্ধতি" বেছে নেব কারণ এটি তর্কযোগ্যভাবে সহজতম:

ব্যাবিলনীয় পদ্ধতি

নোট করুন যে বর্গমূলকে এভাবে গণনা করা পুনরাবৃত্তির একটি ভাল উদাহরণ।

পাইথন প্রোগ্রামে এগুলি একসাথে রাখলে তা আপনার সমস্যার নিম্নলিখিত সমাধান দেয়:

def sqrt(x, n): # not the same n as below
    return .5 * (sqrt(x, n - 1) + x / sqrt(x, n - 1)) if n > 0 else x

n = float(raw_input())
print (n / 2.718) ** n * sqrt(2 * 3.141 * n, 10)

একটি সাধারণ পরিবর্তনের মাধ্যমে উপরের প্রোগ্রামটি ফ্যাকটোরিয়ালগুলির একটি ঝরঝরে টেবিল আউটপুট করতে পারে:

1! =    0.92215
2! =    1.91922
3! =    5.83747
4! =   23.51371
5! =  118.06923
6! =  710.45304
7! = 4983.54173
8! = 39931.74015
9! = 359838.58817

বেশিরভাগ অ্যাপ্লিকেশনগুলির জন্য এই পদ্ধতিটি যথেষ্ট সঠিক হওয়া উচিত।

— nwk
সূত্র
16
+1 এই পদ্ধতির সরলতা এবং নির্ভুলতা এটিকে একটি স্পষ্ট বিজয়ী করে তোলে
— জো ব্যক্তি
44

সি শার্প

দুঃখিত, তবে আমি পুনরাবৃত্তির কাজটি ঘৃণা করি।

public string Factorial(uint n) {
    return n + "!";
}
— টিয়া
সূত্র
1
প্রযুক্তিগতভাবে, আপনি সংক্ষিপ্ত সন্তুষ্ট! ;) সংক্ষিপ্ত নির্যাতনের জন্য +1
— ওয়ালিওয়েস্ট
36

জাভা

public int factorial ( int n ) {
switch(n){
case 0: return 1;
case 1: return 1;
case 2: return 2;
case 3: return 6;
case 4: return 24;
case 5: return 120;
case 6: return 720;
case 7: return 5040;
case 8: return 40320;
case 9: return 362880;
case 10: return 3628800;
case 11: return 39916800;
case 12: return 479001600;
default : throw new IllegalArgumentException();
}
}
— Emory
সূত্র
16
আমি চেষ্টা করেছিলাম - খুব দক্ষ পরের রিলিজ সহ জাহাজীকরণ করবে। :)
— জোহানেস
"ম্যাজিকাল নাম্বার সিন্ড্রোম" পাশাপাশি, এন এন 13 এর চেয়ে অনেক কম স্ট্যাকের ক্ষেত্রে এটি আসলে একটি ভাল বাস্তবায়ন হতে পারে। এটি লিখুন "কেস 4: রিটার্ন 4 * 3 * 2;" এবং আপনি একটি পুরাতন পুনরাবৃত্ত ক্লাস চেয়ে অনেক দ্রুত, একটি শালীন বর্গ চাই।
— ফাবিনআউট
6
@ ফ্যাবিনআউট, বাস্তবায়ন এমনকি এন> = 13 এর জন্যও সঠিক। 13!> Integer.MAX_VALUE।
— এমুরি 21
21

পাইথন

অবশ্যই কোনও সমস্যা সমাধানের সর্বোত্তম উপায় হ'ল নিয়মিত এক্সপ্রেশন ব্যবহার করা:

import re

# adapted from http://stackoverflow.com/q/15175142/1333025
def multiple_replace(dict, text):
  # Create a regular expression  from the dictionary keys
  regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
  # Repeat while any replacements are made.
  count = -1
  while count != 0:
    # For each match, look-up corresponding value in dictionary.
    (text, count) = regex.subn(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
  return text

fdict = {
    'A': '@',
    'B': 'AA',
    'C': 'BBB',
    'D': 'CCCC',
    'E': 'DDDDD',
    'F': 'EEEEEE',
    'G': 'FFFFFFF',
    'H': 'GGGGGGGG',
    'I': 'HHHHHHHHH',
    'J': 'IIIIIIIIII',
    'K': 'JJJJJJJJJJJ',
    'L': 'KKKKKKKKKKKK',
    'M': 'LLLLLLLLLLLLL',
    'N': 'MMMMMMMMMMMMMM',
    'O': 'NNNNNNNNNNNNNNN',
    'P': 'OOOOOOOOOOOOOOOO',
    'Q': 'PPPPPPPPPPPPPPPPP',
    'R': 'QQQQQQQQQQQQQQQQQQ',
    'S': 'RRRRRRRRRRRRRRRRRRR',
    'T': 'SSSSSSSSSSSSSSSSSSSS',
    'U': 'TTTTTTTTTTTTTTTTTTTTT',
    'V': 'UUUUUUUUUUUUUUUUUUUUUU',
    'W': 'VVVVVVVVVVVVVVVVVVVVVVV',
    'X': 'WWWWWWWWWWWWWWWWWWWWWWWW',
    'Y': 'XXXXXXXXXXXXXXXXXXXXXXXXX',
    'Z': 'YYYYYYYYYYYYYYYYYYYYYYYYYY'}

def fact(n):
    return len(multiple_replace(fdict, chr(64 + n)))

if __name__ == "__main__":
    print fact(7)
— পেটর পুডলক
সূত্র
1
অবশ্যই প্রকৃতপক্ষে :)
— পিয়েরে আরলাড
15

Haskell,

শর্ট কোড হ'ল দক্ষ কোড, তাই এটি ব্যবহার করে দেখুন।

fac = length . permutations . flip take [1..]

কেন এটি ট্রোলিং হচ্ছে:

আমি যে কোনও কোডার এটি লিখেছি তা নিয়ে আমি হাসি ... অদক্ষতাটি সুন্দর। এছাড়াও সম্ভবত কোনও হাস্কেল প্রোগ্রামার যারা বুদ্ধিমান কোনও ফাংশন লিখতে পারেন না তার কাছে বোধগম্য।

সম্পাদনা: আমি এখনই এটি পোস্ট করেছি কিছুক্ষণ আগে, তবে আমি ভেবেছিলাম যে আমি ভবিষ্যতের লোক এবং যারা হাস্কেল পড়তে পারে না তাদের জন্য স্পষ্ট করে দেব।

এখানে কোডটি 1 থেকে n এর সংখ্যার তালিকা গ্রহণ করে, সেই তালিকার সমস্ত অনুমানের তালিকা তৈরি করে এবং সেই তালিকাটির দৈর্ঘ্য প্রদান করে। আমার মেশিনে এটি 13 এর জন্য 20 মিনিট সময় নেয়! এবং তারপরে 14 এর জন্য চার ঘন্টা সময় নেওয়া উচিত! এবং তারপরে আড়াই দিনের জন্য 15! এটির কোনও পর্যায়ে ব্যতীত আপনার স্মৃতি শেষ হয়ে যায়।

সম্পাদনা 2: আসলে হাস্কেল হওয়ার কারণে আপনি সম্ভবত স্মৃতি থেকে সরে যাবেন না (নীচের মন্তব্যটি দেখুন)। আপনি সম্ভবত তালিকাটি মূল্যায়ন করতে এবং এটি কোনওভাবে স্মৃতিতে ধরে রাখতে বাধ্য করতে সক্ষম হতে পারেন তবে কীভাবে এটি করা যায় তা জানতে হ্যাশেলকে অনুকূলকরণ (এবং অপরিশোধিতকরণ) সম্পর্কে আমি পর্যাপ্ত পরিমাণে জানি না।

— jgon
সূত্র
ঘৃণ্য এবং এখনও তাই মার্জিত, সব একই সময়ে।
— পিএলএল
1
আপনি কি মেমরি সমস্যা সম্পর্কে নিশ্চিত? যে কোনও এক পর্যায়ে, আপনাকে মেমরি ধরে রাখতে হবে: - তালিকা [1..n]। - [1..n]একটির নির্দিষ্ট ক্রিয়াকলাপ, বাকী অনুমতিগুলির জন্য একটি অংশকে গণ্য করা হয়েছে (বহুভিত্তিক n)। - lengthফাংশনের জন্য একটি সঞ্চয়ী ।
— জন ডিভোরাক
ফেয়ার পয়েন্ট, সম্ভবত আসলে না। সত্যিই এটি সম্পর্কে খুব বেশি ভাবেনি। আমি নীচে একটি মন্তব্য যুক্ত করব।
— জাগন
10

সি শার্প

যেহেতু এটি একটি গণিত সমস্যা, তাই এই গণনাটি করার জন্য গণিতের সমস্যাগুলি সমাধান করার জন্য বিশেষভাবে ডিজাইন করা অ্যাপ্লিকেশনটি ব্যবহার করা বোধগম্য হয় ...

ধাপ 1:

ম্যাটল্যাব ইনস্টল করুন। আমার মনে হয় একটি ট্রায়াল কাজ করবে, তবে এই অতি জটিল সমস্যাটি অ্যাপ্লিকেশনটির পুরো সংস্করণ কেনার যোগ্যতার জন্য যথেষ্ট গুরুত্বপূর্ণ।

ধাপ ২:

আপনার অ্যাপ্লিকেশনটিতে ম্যাটল্যাব সিওএম উপাদান অন্তর্ভুক্ত করুন।

ধাপ 3:

public string Factorial(uint n) {
    MLApp.MLApp matlab = new MLApp.MLApp();
    return matlab.Execute(String.Format("factorial({0})", n);
}
— মোশে কাটজ
সূত্র
শিক্ষার্থীদের জন্য মতলব $ 100 থেকে শুরু হয়। পেশাদার সংস্করণ বা সাইটের লাইসেন্স হাজারে যেতে পারে।
— মোশে কাটজ
4
মোশে কাটজ - যুক্তিযুক্ত কারণ।
— মাইক এইচ।
9

সি শার্প

কারখানাগুলি একটি উচ্চ স্তরের গণিত অপারেশন যা একসাথে সমস্ত হজম করা কঠিন হতে পারে। এর মতো প্রোগ্রামিং সমস্যার সর্বোত্তম সমাধান হ'ল একটি বড় কাজকে ছোট ছোট কাজের মধ্যে বিভক্ত করা।

এখন, এন! 1 * 2 * ... * n হিসাবে সংজ্ঞায়িত করা হয়েছে, সুতরাং মূলত পুনরাবৃত্তি গুণক এবং গুণক পুনরাবৃত্তি যোগ করা ছাড়া কিছুই নয়। সুতরাং, এই বিষয়টি মাথায় রেখে, নিম্নলিখিতগুলি এই সমস্যাটি সমাধান করে:

long Factorial(int n)
{
    if(n==0)
    {
        return 1;
    }

    Stack<long> s = new Stack<long>();
    for(var i=1;i<=n;i++)
    {
        s.Push(i);
    }
    var items = new List<long>();
    var n2 = s.Pop();
    while(s.Count >0)
    {
        var n3 = s.Pop();
        items.AddRange(FactorialPart(n2,n3));
        n2 = items.Sum();
    }
    return items.Sum()/(n-1);
}

IEnumerable<long> FactorialPart(long n1, long n2)
{
    for(var i=0;i<n2;i++){
        yield return n1;
    }
}
— ম্যাট সিকার
সূত্র
আপনার কাছে একটি সিপিইউ বা কোরের মাধ্যমে এই সমস্ত প্রেরণ করার একটি বাধা রয়েছে যা আমি মনে করি আমি আমার উত্তরটি সমাধান করেছি :-)
— পল
9 
#include <math.h>

int factorial(int n)
{
    const double g = 7;
    static const double p[] = { 0.99999999999980993, 676.5203681218851,
                                -1259.1392167224028, 771.32342877765313,
                                -176.61502916214059, 12.507343278686905,
                                -0.13857109526572012, 9.9843695780195716e-6,
                                1.5056327351493116e-7 };
    double z = n - 1 + 1;
    double x = p[0];
    int i;
    for ( i = 1; i < sizeof(p)/sizeof(p[0]); ++i )
        x += p[i] / (z + i);
    return sqrt(2 * M_PI) * pow(z + g + 0.5, z + 0.5)  * exp(-z -g -0.5) * x + 0.5;
}

ট্রলস:

  • ফ্যাকটোরিয়াল গণনা করার একটি 100% সঠিক উপায় যা এটি পুনরুক্ত বা পুনরাবৃত্তভাবে করার দ্বারা সম্পূর্ণরূপে মিস করে।
  • এটি কেন কাজ করে আপনার কোনও ধারণা নেই এবং এটি অন্য কিছু করার জন্য সাধারণকরণ করতে পারেন নি।
  • এটি কেবল পূর্ণসংখ্যার গণিতের সাথে গণনা করার চেয়ে বেশি ব্যয়বহুল।
  • সর্বাধিক সুস্পষ্ট "সাবপটিমাল" কোড ( z = n - 1 + 1) আসলে স্ব-ডকুমেন্টিং যা আপনি যদি জানেন যে কী চলছে।
  • অতিরিক্ত ট্রোলিংয়ের জন্য আমার p[]সিরিজ সহগগুলির একটি পুনরাবৃত্ত গণনা ব্যবহার করে গণনা করা উচিত !

(এটি গ্যামার ফাংশনের ল্যানকসোস আনুমানিক )

— বেন জ্যাকসন
সূত্র
এখানে কোন মানে আছে - 1 + 1? আমার সংকলক এটিটিকে অনুকূল করে তোলে (এটি ভাসমান পয়েন্ট নম্বর নয় যেখানে এর মতো কোডটি অনুকূলকরণ করা বিপজ্জনক হতে পারে), সুতরাং এটি অপরিবর্তিত বলে মনে হয়।
— কনরাড বোরোস্কি
4
@xfix: double z = n - 1গামা ফাংশনটির আনুমানিক অংশ। এই + 1সম্পর্ক থেকে যে gamma(n + 1) = n!পূর্ণসংখ্যার জন্য এন।
— বেন জ্যাকসন
9

কলেজ থেকে আমরা সকলেই জানি যে একটি গুণকে গণনা করার সবচেয়ে কার্যকরী উপায় হ'ল লগারিদম ব্যবহারের মাধ্যমে। সর্বোপরি, লোকেরা কেন কয়েকশ বছর ধরে লগারিদম টেবিল ব্যবহার করবে?

সুতরাং পরিচয় থেকে a*b=e^(log(a)+log(b))আমরা নিম্নলিখিত পাইথন কোড গঠন করি:

from math import log,exp

def fac_you(x):
    return round(exp(sum(map(log,range(1,x+1)))))

for i in range(1,99):
    print i,":",fac_you(i)

এটি থেকে সংখ্যার একটি তালিকা তৈরি 1করে x, (দ্য+1 পাইথন সাফল্যের কারণে এটি প্রয়োজনীয়) প্রতিটিটির লগারিদম গণনা করে, সংখ্যার যোগফল যোগ করে, যোগফলকে ই যোগায় এবং অবশেষে মানটি নিকটতম পূর্ণসংখ্যার সাথে বেঁধে দেয় (কারণ পাইথন সফল হয়) । পাইথনের ফ্যাকটোরিয়াল গণনা করার জন্য একটি অন্তর্নির্মিত ফাংশন রয়েছে তবে এটি কেবল পূর্ণসংখ্যার জন্য কাজ করে, সুতরাং এটি বড় সংখ্যক উত্পাদন করতে পারে না (কারণ পাইথন চুষে দেয়)। এজন্য উপরের ফাংশনটি প্রয়োজন।

বিটিডব্লিউ, শিক্ষার্থীদের জন্য একটি সাধারণ টিপ হ'ল কিছু যদি প্রত্যাশা অনুযায়ী কাজ না করে, সম্ভবত ভাষাটি সফল হয়।

— nitro2k01
সূত্র
আশা করি আমি বর্ণনার জন্য সেখানে কিছু অতিরিক্ত ভোট দিতে পারলাম, তবে পাইথন
— মার্ক কে কোয়ান
1
আমি "
— ফ্যাক্স ইউ
8

দুর্ভাগ্যক্রমে, জাভাস্ক্রিপ্টটির মধ্যে ফ্যাক্টরিয়াল গণনা করার জন্য অন্তর্নির্মিত উপায় নেই। তবে, এরপরেও মানটি নির্ধারণ করতে আপনি সংযুক্তিগুলিতে এর অর্থটি ব্যবহার করতে পারেন:

একটি সংখ্যার এন এর ফ্যাকটোরিয়াল হ'ল সেই আকারের তালিকার ক্রম সংখ্যা।

সুতরাং, আমরা এন-সংখ্যা সংখ্যার প্রতিটি তালিকা তৈরি করতে পারি, এটি ক্রমান্বন কিনা তা পরীক্ষা করে দেখতে পারি এবং যদি তাই হয় তবে কাউন্টারকে বাড়িয়ে তুলতে হবে:

window.factorial = function($nb_number) {
  $nb_trials = 1
  for($i = 0; $i < $nb_number; $i++) $nb_trials *= $nb_number
  $nb_successes = 0
  __trying__:
  for($nb_trial = 0; $nb_trial < $nb_trials; $nb_trial++){
    $a_trial_split = new Array
    $nb_tmp = $nb_trial
    for ($nb_digit = 0; $nb_digit < $nb_number; $nb_digit++){
      $a_trial_split[$nb_digit] = $nb_tmp - $nb_number * Math.floor($nb_tmp / $nb_number)
      $nb_tmp = Math.floor($nb_tmp / $nb_number)
    }
    for($i = 0; $i < $nb_number; $i++)
      for($j = 0; $j < $nb_number; $j++)
        if($i != $j)
          if($a_trial_split[$i] == $a_trial_split[$j])
            continue __trying__
    $nb_successes += 1
  }
  return $nb_successes
}

alert("input a number")
document.open()
document.write("<input type = text onblur = alert(factorial(parseInt(this.value))))>")
document.close()

ট্রলস:

  • প্রকারের হবিগ্রন্থের স্বরলিপি, সর্প_কক্ষ এবং অযৌক্তিক সিগিলস । এটা কতটা খারাপ?
  • জাম্প লেবেলগুলির জন্য আমার নিজস্ব কনভেনশন উদ্ভাবন করেছে, এই সম্মেলনের বর্তমান ব্যবহারের সাথে বেমানান।
  • প্রতিটি সম্ভাব্য পরিবর্তনশীল দুর্ঘটনাক্রমে বিশ্বব্যাপী।
  • সমাধান হয় না O(n) নয় O(n!), তবে নয় O(n^n)। এটিই এখানে যোগ্যতা অর্জনের পক্ষে যথেষ্ট ছিল।
  • একটি সংখ্যা বৃদ্ধি এবং তারপরে বেস-এন রূপান্তর করা ক্রমগুলির তালিকা তৈরির জন্য একটি খারাপ উপায়। আমরা নকল চাইলেও। রহস্যজনকভাবে এন> 13 এর জন্য বিরতি একমাত্র কারণ নয়।
  • অবশ্যই আমরা ব্যবহার করতে পারতাম number.toString(base), তবে এটি 36 এর উপরে ভিত্তিগুলির জন্য কাজ করে না Yes হ্যাঁ, আমি জানি 36! ইহা একটি অনেক , কিন্তু এখনও ...
  • আমি কি জাভাস্ক্রিপ্টের মডুলাস অপারেটরটি উল্লেখ করেছি? অথবাMath.pow ? কোন? আচ্ছা ভালো.
  • ব্যবহার প্রত্যাখ্যান ++ -লুপের বাইরের এটিকে আরও রহস্যময় করে তুলেছে। এছাড়াও, ==খারাপ।
  • গভীরভাবে নেস্টেড ব্রেসলেস লুপিং নির্মাণগুলি। এছাড়াও, AND এর পরিবর্তে নেস্টেড শর্তাদি। এছাড়াও, বাইরের অবস্থাটি অভ্যন্তরীণ লুপটি এড়িয়ে শেষ করে এড়ানো যেত$i ।
  • ফাংশন new Array, document.write(বন্ধুদের সাথে) এবংalert (ক প্রম্পট বা একটি ইনপুট ট্যাগ পরিবর্তে) ফাংশন পছন্দ পাপের সম্পূর্ণ trifecta গঠন করে। কেন ইনপুট সব পরে গতিশীল যুক্ত করা হয়?
  • ইনলাইন ইভেন্ট হ্যান্ডলারগুলি। ওহ, এবং গভীর পাইপিং ডিবাগ করা জাহান্নাম।
  • অব্যক্ত বৈশিষ্ট্যগুলি মজাদার এবং চারপাশের স্পেস = তাদের পড়া আরও শক্ত তোলে।
  • আমি ইতিমধ্যে আমি সেমিকোলনগুলি ঘৃণা করেছি উল্লেখ করেছি?
— জন ডিভোরাক
সূত্র
8

রুবি এবং ওল্ফ্রামআল্ফা

এই দ্রষ্টব্যটি কল্পনাটি গণনা করতে ওল্ফ্রামআল্ফা আরএসটি এপিআই ব্যবহার করে, সমাধানটি আনার জন্য রেস্টক্লিয়েন্ট এবং পার্স করার জন্য নোকোগিরি with এটি কোনও চাকা পুনরায় উদ্ভাবন করে না এবং সর্বাধিক আধুনিক পদ্ধতিতে ফলাফল পেতে ভাল পরীক্ষিত এবং জনপ্রিয় প্রযুক্তি ব্যবহার করে।

require 'rest-client'
require 'nokogiri'

n = gets.chomp.to_i
response = Nokogiri::XML(RestClient.get("http://api.wolframalpha.com/v2/query?input=#{n}!&format=moutput&appid=YOUR_APP_KEY"))
puts response.xpath("//*/moutput/text()").text
— migimunz
সূত্র
7

জাভাস্ক্রিপ্ট

জাভাস্ক্রিপ্ট একটি কার্যকরী প্রোগ্রামিং ভাষা, এর অর্থ আপনাকে প্রত্যেকটির জন্য ফাংশন ব্যবহার করতে হবে কারণ এটির দ্রুত।

function fac(n){
    var r = 1,
        a = Array.apply(null, Array(n)).map(Number.call, Number).map(function(n){r = r * (n + 1);});
    return r;
}
— Luka থেকে
সূত্র
1
তুমি কি ব্যাখ্যা করতে পারো?
— Mhmd
7
1 কোনও ফাংশন নয়। আপনার কোড এইভাবে ধীর।
— পিয়ের আরলাড
4
@ আরলাডপিয়ার r = -~(function(){})অবশ্যই তা সমাধান করবে।
— nitro2k01
4
আমি একটি ওয়ার্ক মেশিনে আছি তাই আমি সত্যই এই ভাষাটি ইনস্টল করতে চাই না। আমার ব্রাউজারে চলবে এমন একটি সংস্করণ আমি কোথায় পাব?
— জোয়েটউইডল
3
আমি গুগল ব্যবহার করতে কিছুটা ভয় পেয়েছি কারণ আমার বসের সাথে তাদের একাউন্ট আছে এবং আমি চাই না যে তাকে জানানো উচিত আমি কর্মক্ষেত্রে গল্ফ খেলছি। আমি ফায়ারফক্সের জাভাস্ক্রিপ্ট চালাতে পারে এমন একটি এক্সটেনশান খুঁজছিলাম, তবে আমি এটির সন্ধান করতে পারি না। আমার কিছু বন্ধু jsfiddle.net এ জাভাস্ক্রিপ্ট চালায় তবে এটি অন্য কারও বিদ্যুত ব্যবহার করছে যা চুরির মতো। আমার আম্মু বলেছিল আমার মতো লোকদের সাথে আমার চারপাশে ঘুরে বেড়ানো উচিত নয়, তবে তারা আমার বন্ধু তাই আমি কী করতে পারি? যাইহোক তিনি কখনও কখনও তার প্রয়োজনের চেয়ে বেশি ক্রিমার গ্রহণ করেন। টিপসের জন্য ধন্যবাদ, আমি ফায়ারফক্সে Ctrl-Shift-J বা K ব্যবহার করি। দাবি
— অস্বীকার
5

জাভাতে বোগো-বাছাই করা ব্যবহার করা

public class Factorial {
    public static void main(String[] args) {
        //take the factorial of the integers from 0 to 7:
        for(int i = 0; i < 8; i++) {
            System.out.println(i + ": " + accurate_factorial(i));
        }
    }

    //takes the average over many tries
    public static long accurate_factorial(int n) {
        double sum = 0;
        for(int i = 0; i < 10000; i++) {
            sum += factorial(n);
        }
        return Math.round(sum / 10000);
    }

    public static long factorial(int n) {
        //n! = number of ways to sort n
        //bogo-sort has O(n!) time, a good approximation for n!
        //for best results, average over several passes

        //create the list {1, 2, ..., n}
        int[] list = new int[n];
        for(int i = 0; i < n; i++)
            list[i] = i;

        //mess up list once before we begin
        randomize(list);

        long guesses = 1;

        while(!isSorted(list)) {
            randomize(list);
            guesses++;
        }

        return guesses;
    }

    public static void randomize(int[] list) {
        for(int i = 0; i < list.length; i++) {
            int j = (int) (Math.random() * list.length);

            //super-efficient way of swapping 2 elements without temp variables
            if(i != j) {
                list[i] ^= list[j];
                list[j] ^= list[i];
                list[i] ^= list[j];
            }
        }
    }

    public static boolean isSorted(int[] list) {
        for(int i = 1; i < list.length; i++) {
            if(list[i - 1] > list[i])
                return false;
        }
        return true;
    }
}

এটি আসলে খুব ধীরে ধীরে কাজ করে এবং উচ্চতর সংখ্যার জন্য এটি সঠিক নয়।

— জেমস হ্যাগবার্গ
সূত্র
4

PERL

কারখানা একটি কঠিন সমস্যা হতে পারে। একটি মানচিত্র / কৌশল যেমন হ্রাস - যেমন গুগল ব্যবহার করে - একগুচ্ছ প্রক্রিয়া বন্ধ করে ফলাফল সংগ্রহ করে গণিতকে বিভক্ত করতে পারে। এটি শীতকালে শীতের রাতে আপনার সিস্টেমে এই সমস্ত কোর বা সিপাসের ভাল ব্যবহার করবে।

আপনি এটি চালাতে পারবেন কিনা তা নিশ্চিত করার জন্য f.perl এবং chmod 755 হিসাবে সংরক্ষণ করুন। আপনার কাছে প্যাথলজিক্যালি ইলেক্টিক জঞ্জাল লিস্টার ইনস্টল আছে, তাই না?

#!/usr/bin/perl -w                                                              
use strict;
use bigint;
die "usage: f.perl N (outputs N!)" unless ($ARGV[0] > 1);
print STDOUT &main::rangeProduct(1,$ARGV[0])."\n";
sub main::rangeProduct {
    my($l, $h) = @_;
    return $l    if ($l==$h);
    return $l*$h if ($l==($h-1));
    # arghhh - multiplying more than 2 numbers at a time is too much work       
    # find the midpoint and split the work up :-)                               
    my $m = int(($h+$l)/2);
    my $pid = open(my $KID, "-|");
      if ($pid){ # parent                                                       
        my $X = &main::rangeProduct($l,$m);
        my $Y = <$KID>;
        chomp($Y);
        close($KID);
        die "kid failed" unless defined $Y;
        return $X*$Y;
      } else {
        # kid                                                                   
        print STDOUT &main::rangeProduct($m+1,$h)."\n";
        exit(0);
    }
}

ট্রলস:

  • কাঁটাচামচ হে (লগ 2 (এন)) প্রক্রিয়াগুলি
  • আপনার কতটি সিপিইউ বা কোর রয়েছে তা যাচাই করে না
  • প্রতিটি প্রক্রিয়াতে ঘটে এমন প্রচুর বিগিন্ট / পাঠ্য রূপান্তরগুলি আড়াল করে
  • লুপের জন্য এ প্রায়শই এই কোডের চেয়ে দ্রুত হয়
— পল
সূত্র
তিল যে পার্ল ARGV[0]আসলে প্রথম যুক্তি এবং না স্ক্রিপ্ট!
— থিংকোওস
@ পিএলজি আমি বিশ্বাস করি যে $ 0 এ স্ক্রিপ্ট ফাইলের নাম থাকতে পারে তবে এটি $ আরজিভি [0] এর মতো নয়
— পৌল
হ্যাঁ, এটাই আমি পড়েছি। আমি কেবল অবাক করেই দেখেছি যে পার্লটিতে এটি নয় $ARGV[0]কারণ বেশিরভাগ ভাষাগুলি আমি কিছুটা জানি সেখানে এটি রয়েছে
— থিঙ্কচোস
4

পাইথন

ঘটনাকারী সন্ধানের জন্য কেবল একটি O (n! * N ^ 2) অ্যালগরিদম। বেস কেস পরিচালনা করা। ওভারফ্লো নেই।

def divide(n,i):
    res=0
    while n>=i:
         res+=1
         n=n-i
    return res

def isdivisible(n,numbers):
    for i in numbers:
         if n%i!=0:
             return 0
         n=divide(n,i)
    return 1

def factorial(n):
    res = 1
    if n==0: return 1 #Handling the base case
    while not isdivisible(res,range(1,n+1)):
         res+=1
    return res
— সুধারন মোহন
সূত্র
3

ঠিক আছে, গল্ফস্ক্রিপ্টে একটি সহজ সমাধান রয়েছে। আপনি একটি গল্ফস্ক্রিপ্ট দোভাষী ব্যবহার করতে পারেন এবং এই কোডটি চালাতে পারেন:

.!+,1\{)}%{*}/

সহজ হাহ :) শুভকামনা!

— মার্টিজান আদালত
সূত্র
2
আমি গল্ফস্ক্রিপ্ট জানি না, তবে এটি আমাকে হতাশ করে ... এই সাইটের অন্যান্য গল্ফস্ক্রিপ্ট উদাহরণগুলির উপর ভিত্তি করে আমি উত্তরটি প্রত্যাশা করতাম!
— মিস্টার লিস্টার
1
তা হ'ল নেগেশন অপারেটর। 0 থেকে 1 হয়ে যায় এবং অন্য সব কিছুর 0. হয়ে
— Martijn Courteaux
3

ম্যাথামেটিকাল

factorial[n_] := Length[Permutations[Table[k, {k, 1, n}]]]

11 টিরও বেশি সংখ্যকগুলির পক্ষে এটি কাজ বলে মনে হচ্ছে না এবং ফ্যাক্টরিয়াল [11] আমার কম্পিউটারকে হিমশীতল করেছে।

— স্টিফেন মন্টগোমেরি-স্মিথ
সূত্র
3

চুনি

f=->(n) { return 1 if n.zero?; t=0; t+=1 until t/n == f[n-1]; t }

ধীরে ধীরে ওয়ান-লাইনারটি আমি কল্পনা করতে পারি। এটি i7 প্রসেসরে গণনা করতে 2 মিনিট সময় নেয় 6!।

— পুনর্লিখিত
সূত্র
2

এই কঠিন গণিত সমস্যার জন্য সঠিক পদ্ধতির একটি ডিএসএল। সুতরাং আমি এটি একটি সাধারণ ভাষার ক্ষেত্রে মডেল করব

data DSL b a = Var x (b -> a)
             | Mult DSL DSL (b -> a)
             | Plus DSL DSL (b -> a)
             | Const Integer (b -> a)

আমাদের ডিএসএলকে সুন্দরভাবে লিখতে, এটি বীজগণিতীয় ফান্টেক্টর দ্বারা উত্পাদিত একটি মুক্ত মনড হিসাবে দেখতে সহায়ক

F X = X + F (DSL b (F X)) -- Informally define + to be the disjoint sum of two sets

আমরা হাস্কেল হিসাবে এটি লিখতে পারে

Free b a = Pure a
         | Free (DSL b (Free b a))

এর তুচ্ছ বাস্তবায়নটি পাঠকের কাছে ছেড়ে দেব

join   :: Free b (Free b a) -> Free b a
return :: a -> Free b a
liftF  :: DSL b a -> Free b a

এখন আমরা এই ডিএসএলে একটি ফ্যাকটোরিয়াল মডেল করার জন্য একটি অপারেশনকে মেনে নিতে পারি

factorial :: Integer -> Free Integer Integer
factorial 0 = liftF $ Const 1 id
factorial n = do
  fact' <- factorial (n - 1)
  liftF $ Mult fact' n id

এখন আমরা এটি মডেল করেছি, আমাদের কেবল আমাদের মুক্ত মোনাডের জন্য একটি আসল ব্যাখ্যা ফাংশন সরবরাহ করা দরকার।

denote :: Free Integer Integer -> Integer
denote (Pure a) = a
denote (Free (Const 0 rest)) = denote $ rest 0
...

এবং বাক্য নির্ধারণের বাকী অংশটি পাঠকের কাছে রেখে দেব।

পঠনযোগ্যতা উন্নত করতে, কখনও কখনও ফর্মের একটি কংক্রিট এএসটি উপস্থাপন করতে সহায়ক

data AST = ConstE Integer
         | PlusE AST AST
         | MultE AST AST

এবং তারপরে একটি তুচ্ছ প্রতিচ্ছবি ডানদিকে দিন

reify :: Free b Integer -> AST

এবং তারপরে এটিএসটির পুনরাবৃত্তির সাথে মূল্যায়ন করা সোজা।

— ড্যানিয়েল গ্রেটজার
সূত্র
2

পাইথন

নীচে সমাধানটির পাইথন সংস্করণ দেওয়া আছে, যা পাইথনের পূর্ণসংখ্যার জন্য 32 বিট (বা খুব সাম্প্রতিক সিস্টেমে bit৪ বিট) সীমাবদ্ধ নয়। এই সীমাবদ্ধতাটি পেতে, আমরা factorialরুটিনের জন্য ইনপুট এবং আউটপুট হিসাবে একটি স্ট্রিং ব্যবহার করব এবং গুণটি সম্পাদন করতে সক্ষম হতে স্ট্রিংটিকে তার অঙ্কগুলিতে অভ্যন্তরীণভাবে বিভক্ত করব।

সুতরাং কোডটি এখানে: getDigitsফাংশনটি তার অঙ্কগুলিতে একটি সংখ্যাকে উপস্থাপন করে একটি স্ট্রিং বিভক্ত করে, তাই "1234" হয়ে যায়[ 4, 3, 2, 1 ] (বিপরীত ক্রমটি কেবলমাত্র increaseএবং multiplyকার্যকারিতা আরও সহজ করে তোলে )। increaseফাংশন যেমন একটি তালিকা এবং এটা এক করে বৃদ্ধি লাগে। নামটি যেমন বোঝায়, multiplyফাংশনটি বহুগুণ হয়, যেমন multiply([2, 1], [3])ফিরে আসে returns[ 6, 3 ] কারণ 12 বার 3 36 একই ভাবে এই কাজ আপনি সংখ্যাবৃদ্ধি কলম এবং কাগজ সঙ্গে কিছু would হিসাবে।

তারপরে অবশেষে factorial ফাংশনটি এই সহায়ক সহায়ক ফাংশনটি প্রকৃত ফ্যাক্টরিয়াল গণনা করতে ব্যবহার করে, উদাহরণস্বরূপ এটির আউটপুট হিসাবে factorial("9")দেয় "362880"।

import copy

def getDigits(n):
    digits = []
    for c in n:
        digits.append(ord(c) - ord('0'))

    digits.reverse()
    return digits

def increase(d):
    d[0] += 1
    i = 0
    while d[i] >= 10:
        if i == len(d)-1:
            d.append(0)

        d[i] -= 10
        d[i+1] += 1
        i += 1

def multiply(a, b):
    subs = [ ]
    s0 = [ ]
    for bi in b:

        s = copy.copy(s0)
        carry = 0
        for ai in a:
            m = ai * bi + carry
            s.append(m%10)
            carry = m//10

        if carry != 0:
            s.append(carry)

        subs.append(s)
        s0.append(0)

    done = False
    res = [ ]
    termsum = 0
    pos = 0
    while not done:
        found = False
        for s in subs:
            if pos < len(s):
                found = True
                termsum += s[pos]

        if not found:
            if termsum != 0:
                res.append(termsum%10)
                termsum = termsum//10
            done = True
        else:
            res.append(termsum%10)
            termsum = termsum//10
            pos += 1

    while termsum != 0:
        res.append(termsum%10)
        termsum = termsum//10

    return res

def factorial(x):
    if x.strip() == "0" or x.strip() == "1":
        return "1"

    factorial = [ 1 ]
    done = False
    number = [ 1 ]
    stopNumber = getDigits(x)
    while not done:
        if number == stopNumber:
            done = True

        factorial = multiply(factorial, number)
        increase(number)

    factorial.reverse()

    result = ""
    for c in factorial:
        result += chr(c + ord('0'))

    return result

print factorial("9")

মন্তব্য

অজগরটিতে একটি পূর্ণসংখ্যার কোনও সীমা থাকে না, সুতরাং আপনি যদি ম্যানুয়ালি এটি করতে চান তবে আপনি ঠিক করতে পারেন

fac = 1
for i in range(2,n+1): 
    fac *= i

খুব সুবিধাজনকও আছে math.factorial(n) ফাংশনও আছে।

এই সমাধানটি যতটা প্রয়োজন তার চেয়ে স্পষ্টতই জটিল, তবে এটি কাজ করে এবং বাস্তবে এটি চিত্রিত করে যে আপনি যদি 32 বা 64 বিটের দ্বারা সীমাবদ্ধ থাকেন তবে আপনি কীভাবে ফ্যাক্টরিয়ালটি গণনা করতে পারবেন। সুতরাং কেউ যদি বিশ্বাস করবে না যে এই সমাধানটি আপনি এই সহজ (অন্তত পাইথনে অন্তত) সমস্যার জন্য নিয়ে এসেছেন তবে আপনি আসলে কিছু শিখতে পারেন।

— BRM
সূত্র
পাইথনে পূর্ণসংখ্যার কোনও সীমা নেই ... তাই না? আপনার এটি আরও ভালভাবে ব্যাখ্যা করার প্রয়োজন হতে পারে।
— Riking
@ রাইকিং হ্যাঁ, অজগরটিতে পূর্ণসংখ্যার কোনও সীমা নেই। আরও স্পষ্ট করার জন্য আমি কয়েকটি নোট যুক্ত করেছি।
— brm
2

পাইথন

সর্বাধিক যুক্তিসঙ্গত সমাধানটি সমস্ত সংখ্যার মাধ্যমে পরিষ্কার হওয়া পর্যন্ত আপনি যতক্ষণ না খুঁজে পেয়েছেন যে প্রদত্ত সংখ্যার ফ্যাক্টরিয়াল।

print('Enter the number')
n=int(input())
x=1
while True:
    x+=1
    tempx=int(str(x))
    d=True
    for i in range(1, n+1):
        if tempx/i!=round(tempx/i):
            d=False
        else:
            tempx/=i
    if d:
        print(x)
        break
— PygameNerd
সূত্র
2

সি এর মধ্যে একটি খুব মার্জিত পুনরাবৃত্ত সমাধান

প্রত্যেকেই জানেন যে ফ্যাকটোরিয়ালগুলির সর্বাধিক মার্জিত সমাধান পুনরাবৃত্ত হয়।

গৌণিক:

0! = 1
1! = 1
n! = n * (n - 1)!

তবে গুণকে ক্রমাগত সংযোজন হিসাবে পুনরাবৃত্তভাবে সংজ্ঞায়িত করা যায়।

গুণ:

n * 0 = 0
n * 1 = n
n * m = n + n * (m - 1)

এবং তাই ক্রমাগত বৃদ্ধি হিসাবে যোগ করতে পারেন।

সংযোজন:

n + 0 = n
n + 1 = (n + 1)
n + m = (n + 1) + (m - 1)

ইন C, আমরা আদিম এবং যথাক্রমে পরিচালনা করতে ++xএবং --xপরিচালনা করতে পারি, তাই আমাদের সংজ্ঞায়িত সমস্ত কিছু রয়েছে।(x + 1)(x - 1)

#include <stdlib.h>
#include <stdio.h>

// For more elegance, use T for the type
typedef unsigned long T;

// For even more elegance, functions are small enough to fit on one line

// Addition
T A(T n, T m) { return (m > 0)? A(++n, --m) : n; }

// Multiplication
T M(T n, T m) { return (m > 1)? A(n, M(n, --m)): (m? n: 0); }

// Factorial
T F(T n) { T m = n; return (m > 1)? M(n, F(--m)): 1; }

int main(int argc, char **argv)
{
    if (argc != 2)
        return 1;

    printf("%lu\n", F(atol(argv[1])));

    return 0;
}

আসুন এটি ব্যবহার করে দেখুন:

$ ./factorial 0
1
$ ./factorial 1
1
$ ./factorial 2
2
$ ./factorial 3
6
$ ./factorial 4
24
$ ./factorial 5
120
$ ./factorial 6
720
$ ./factorial 7
5040
$ ./factorial 8
40320

পারফেক্ট, যদিও 8! কোনও কারণে দীর্ঘ সময় নিয়েছে। ওহ ভাল, সর্বাধিক মার্জিত সমাধানগুলি সবসময় দ্রুত হয় না। চল অবিরত রাখি:

$ ./factorial 9

হুম, ফিরে আসার সময় আমি আপনাকে জানাব ...

2

পাইথন

@ ম্যাট_সাইকারের উত্তর হিসাবে ইঙ্গিত দেওয়া হয়েছে যে, ফ্যাক্টরিয়ালগুলি অতিরিক্ত বিভাজন হতে পারে - কেন, কার্যগুলি ভাঙা প্রোগ্রামিংয়ের মূল বিষয়। তবে, আমরা এটিকে 1 দ্বারা যোগ করে ভেঙে ফেলতে পারি!

def complicatedfactorial(n):
    def addby1(num):
        return num + 1
    def addnumbers(a,b):
        copy = b
        cp2 = a
        while b != 0:
            cp2 = addby1(cp2)
            b -= 1
    def multiply(a,b):
        copy = b
        cp2 = a
        while b != 0:
            cp2 = addnumbers(cp2,cp2)
    if n == 0:
        return 1
    else:
        return multiply(complicatedfactorial(n-1),n)

আমি মনে করি এই কোডটি একটি এসও ত্রুটির গ্যারান্টি দেয় , কারণ

  1. পুনরাবৃত্তি - এটি উষ্ণ

  2. প্রতিটি স্তর গুণনের জন্য কল উত্পন্ন করে

  3. যা অ্যাড নম্বরগুলিতে কল উত্পন্ন করে

  4. যা addby1 এ কল উত্পন্ন করে!

অনেক বেশি কাজ, তাই না?

— ড্যান দ্য ম্যান
সূত্র
1

টিআই-বেসিক 84

:yumtcInputdrtb@gmail And:cReturnbunchojunk@Yahoo A!op:sEnd:theemailaddressIS Crazy ANSWER LOL

এটা সত্যিই কাজ করেছে :)

— Timtech
সূত্র
1

জাভাস্ক্রিপ্ট

স্পষ্টতই একজন প্রোগ্রামারের কাজ হ'ল যথাসম্ভব কম কাজ করা এবং যতটা সম্ভব লাইব্রেরি ব্যবহার করা। অতএব, আমরা jQuery এবং math.js আমদানি করতে চাই । এখন, টাস্কটি এটি সহজ:

$.alert=function(message){
    alert(message);
}$.factorial=function(number){
    alert(math.eval(number+"!"));
    return math.eval(number+"!");
}
$.factorial(10);
— scrblnrd3
সূত্র
1

পাইথন

স্ট্যান্ডার্ড পুনরাবৃত্তীয় কল্পিত বাস্তবায়নের সামান্য পরিবর্তন করে, এটি এন> 10 এর জন্য অসহনীয়ভাবে ধীর হয়ে যায়।

def factorial(n):
    if n in (0, 1):
        return 1
    else:
        result = 0
        for i in range(n):
            result += factorial(n - 1)
        return result
— dan04
সূত্র
1

সজোরে আঘাত

#! /bin/bash

function fact {
    if [[ ${1} -le 1 ]]; then
        return 1
    fi;

    fact $((${1} - 1))
    START=$(date +%s)
    for i in $(seq 1 $?); do sleep ${1}; done
    END=$(date +%s)
    RESULT=$(($END - $START))
    return $RESULT
}

fact ${1}
echo $?
— alaroldai
সূত্র
1

মন্টে কার্লো পদ্ধতি দ্বারা এটি করার চেষ্টা করা যাক । আমরা সকলেই জানি যে দুটি এলোমেলো এন- পারম্পিটেশন সমান হওয়ার সম্ভাবনা হুবহু 1 / n! । অতএব আমরা সিটি হিট না হওয়া পর্যন্ত কেবলমাত্র কতগুলি পরীক্ষার প্রয়োজন তা পরীক্ষা করতে পারি (আসুন এই নাম্বারে বি কল করুন ) । তারপরে, এন! ~ খ / সি ।

সেজে, পাইথনেও কাজ করা উচিত

def RandomPermutation(n) :           
    t = range(0,n)                   
    for i in xrange(n-1,0,-1):       
        x = t[i]                     
        r = randint(0,i)             
        t[i] = t[r]                  
        t[r] = x                     
    return t                         

def MonteCarloFactorial(n,c) :   
    a = 0                            
    b = 0                            
    t = RandomPermutation(n)         
    while a < c :                
        t2 = list(t)                 
        t = RandomPermutation(n)     
        if t == t2 :                 
            a += 1                   
        b += 1                       
    return round(b/c)            

MonteCarloFactorial(5,1000)
# returns an estimate of 5!
— ইয়ো '
সূত্র
1

সজোরে আঘাত

কারখানাগুলি সহজেই বাশ থেকে সুপরিচিত কমান্ড লাইন সরঞ্জামগুলির সাথে নির্ধারিত হয়।

read -p "Enter number: " $n
seq 1 $n | xargs echo | tr ' ' '*' | bc

@ অ্যারন ডেভিস মন্তব্যগুলিতে যেমন উল্লেখ করেছেন, এটি দেখতে অনেক পরিশ্রমী এবং আমরা সকলেই একটি সুন্দর এবং পরিচ্ছন্ন প্রোগ্রাম চাই, তাই না?

read -p "Enter number: " $n
seq 1 $n | paste -sd\* | bc
— jippie
সূত্র
1
আমি উচ্চ-আন্ডাররেটেড pasteকমান্ডের পরামর্শ দিচ্ছি :seq 1 $n | paste -sd\* | bc
— অ্যারন ডেভিস
2
@ অ্যারোনড্যাভিস pasteএকটি নিয়মিত ইংরেজি শব্দের মতো এবং মনে রাখা সহজ with আমরা কি সত্যিই তা চাই? ; ও)
— জিপি
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.