मैं एक सकारात्मक संख्या के भाज्य को कैसे जान सकता हूँ?

Question

चुनौती:

एक प्रोग्राम या एक फ़ंक्शन लिखें जो एक सकारात्मक संख्या का आदान-प्रदान करता है और इसके तथ्य को वापस करता है ।

^{नोट: यह एक कोड-ट्रोलिंग प्रश्न है। कृपया प्रश्न और / या उत्तर को गंभीरता से न लें। अधिक जानकारी यहाँ । प्रत्येक कोड-ट्रोलिंग प्रश्न भी एक लोकप्रियता-प्रतियोगिता का प्रश्न है, इसलिए सबसे अधिक मतदान उत्तर जीतता है।}

Comments

हास्केल प्रोग्रामर का विकास भी देखें ।

— पेट्र पुडलक

-1, माफ करना, क्योंकि हम इन कोड trolling सवालों की एक बड़ी बाढ़ हो रही है और यह वास्तव में उनके लिए कुछ भी नया नहीं जोड़ता है

— दरवाज़े

संबंधित: codegolf.stackexchange.com/questions/1635/forking-factorials

— पॉल

कोड-ट्रोलिंग आधिकारिक रुख के अनुसार हटाए जाने की प्रक्रिया में है । इस प्रश्न में कई उत्तरों के साथ उचित मात्रा में वोट होते हैं, जिनमें से बहुत से अत्यधिक मतदान होते हैं। इसने मतदान पर केवल 50% "हटाएं" वोटों को प्राप्त किया , लेकिन यह अद्वितीय है कि इसने इतने सारे उत्तर और वोट प्राप्त किए, इसलिए मैं इसे ऐतिहासिक महत्व के लिए बंद कर रहा हूं।

— दरवाज़े

Answer 1

यह एक बहुत ही सरल संख्यात्मक कंप्यूटिंग समस्या है जिसे हम स्टर्लिंग के अनुमान से हल कर सकते हैं :

जैसा कि आप देख सकते हैं, उस सूत्र में एक वर्गमूल है, जिसे हमें अनुमानित रूप से एक रास्ता भी चाहिए। हम इसके लिए तथाकथित "बेबीलोनियन पद्धति" का चयन करेंगे क्योंकि यह यकीनन सबसे सरल है:

ध्यान दें कि इस तरह से वर्गमूल की गणना करना पुनरावृत्ति का एक अच्छा उदाहरण है।

अजगर कार्यक्रम में यह सब एक साथ रखना हमें आपकी समस्या का समाधान देता है:

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

यह विधि अधिकांश अनुप्रयोगों के लिए पर्याप्त रूप से सटीक होनी चाहिए।

Comments

+1 इस पद्धति की सादगी और सटीकता इसे एक स्पष्ट विजेता बनाती है

— जो व्यक्ति 12

Answer 2

सी#

क्षमा करें, लेकिन मैं पुनरावर्ती कार्य से नफरत करता हूं।

public string Factorial(uint n) {
    return n + "!";
}

Comments

तकनीकी रूप से, आपने संक्षिप्त को संतुष्ट कर दिया है! ;) संक्षिप्त दुरुपयोग के लिए +1

— वैलीवेस्ट

Answer 3

जावा

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

Comments

मैंने इसे आजमाया - बहुत कुशल। अगले रिलीज के साथ जहाज जाएगा :)

— जोहान्स

"जादुई संख्या सिंड्रोम" के अलावा, यह वास्तव में एक अच्छा कार्यान्वयन हो सकता है जब तक n <13, बहुत कम स्टैक। इसे लिखें "केस 4: रिटर्न 4 * 3 * 2;" और आपके पास एक सभ्य वर्ग होगा, जो पुराने पुनरावर्ती की तुलना में बहुत तेज है।

— फेनबाउट

@ फेनआउट, कार्यान्वयन n> = 13 के लिए भी सही है। 13!> Integer.MAX_VALUE।

— एमोरी

Answer 4

अजगर

बेशक किसी भी समस्या को हल करने का सबसे अच्छा तरीका नियमित अभिव्यक्ति का उपयोग करना है:

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)

Comments

बेशक वास्तव में :)

— पियरे अरलाउड

Answer 5

हास्केल

शॉर्ट कोड कुशल कोड है, इसलिए यह प्रयास करें।

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

ट्रोलिंग क्यों है:

मैं किसी भी कोडर पर हंसूँगा जिसने यह लिखा है ... अक्षमता सुंदर है। किसी भी हास्केल प्रोग्रामर के लिए शायद यह समझ से बाहर है जो वास्तव में एक फैक्टरियल फ़ंक्शन नहीं लिख सकता है।

संपादित करें: मैंने इसे कुछ समय पहले पोस्ट किया था, लेकिन मुझे लगा कि मैं भविष्य के लोगों और उन लोगों के लिए स्पष्ट करूंगा जो हास्केल नहीं पढ़ सकते हैं।

यहाँ कोड संख्या 1 से n की सूची लेता है, उस सूची के सभी क्रमपरिवर्तन की सूची बनाता है और उस सूची की लंबाई लौटाता है। मेरी मशीन पर 13 के लिए लगभग 20 मिनट लगते हैं!। और फिर इसे 14 घंटे के लिए चार घंटे लेने चाहिए! और फिर 15 के लिए ढाई दिन! सिवाय इसके कि कुछ बिंदु पर आप स्मृति से बाहर हैं।

संपादित करें 2: वास्तव में आप शायद हस्केल होने के कारण स्मृति से बाहर नहीं भागेंगे (नीचे टिप्पणी देखें)। आप इसे सूची का मूल्यांकन करने और इसे किसी भी तरह से मेमोरी में रखने के लिए बाध्य करने में सक्षम हो सकते हैं, लेकिन मुझे यह जानने के लिए पर्याप्त अनुकूलन (और असत्यापन) हास्केल के बारे में पता नहीं है कि यह कैसे करना है।

Comments

घृणित और अभी तक बहुत सुंदर, सभी एक ही समय में।

— पीएलएल

क्या आप मेमोरी इश्यू के बारे में निश्चित हैं? किसी भी एक बिंदु पर, आपको स्मृति में रखने की आवश्यकता है: - सूची [1..n]। - एक विशेष क्रमपरिवर्तन [1..n], शेष क्रमपरिवर्तन (बहुपद में n) के लिए एक कांटे की ओर । - lengthफ़ंक्शन के लिए एक संचायक ।

— जॉन ड्वोरक

उचित बिंदु, शायद वास्तव में नहीं। वास्तव में इसके बारे में बहुत ज्यादा नहीं सोचा था। मैं नीचे एक टिप्पणी जोड़ूंगा।

— गुड़

Answer 6

सी#

चूंकि यह एक गणित की समस्या है, इसलिए यह गणना करने के लिए विशेष रूप से गणित की समस्याओं को हल करने के लिए डिज़ाइन किए गए एप्लिकेशन का उपयोग करने के लिए समझ में आता है ...

चरण 1:

MATLAB स्थापित करें। एक परीक्षण काम करेगा, मुझे लगता है, लेकिन यह सुपर-जटिल समस्या संभावित रूप से महत्वपूर्ण है जो आवेदन के पूर्ण संस्करण को खरीदने के लिए योग्यता है।

चरण 2:

अपने आवेदन में MATLAB COM घटक शामिल करें।

चरण 3:

public string Factorial(uint n) {
    MLApp.MLApp matlab = new MLApp.MLApp();
    return matlab.Execute(String.Format("factorial({0})", n);
}

Comments

छात्रों के लिए मतलाब $ 100 से शुरू होता है। पेशेवर संस्करण या साइट लाइसेंस हजारों में जा सकते हैं।

— मोशे काटज़

मोशे काट्ज़ - तथ्यपूर्ण क्योंकि न्यायसंगत।

— माइक एच।

Answer 7

सी#

Factorials एक उच्च स्तरीय गणित ऑपरेशन है जो सभी को एक बार में पचाने में मुश्किल हो सकता है। इस तरह की प्रोग्रामिंग समस्याओं में सबसे अच्छा समाधान है, एक बड़े कार्य को छोटे कार्यों में तोड़ना।

अब, n! को 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;
    }
}

Comments

आपके पास एक सीपीयू या कोर के माध्यम से यह सब भेजने वाली अड़चन है, जो मुझे लगता है कि मैंने अपने उत्तर में हल किया हो सकता है :-)

— पॉल

Answer 8

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

trolls:

• कंप्यूटिंग फैक्टरियल का एक 100% सही तरीका है जो पूरी तरह से या तो पुनरावृत्ति या पुनरावृत्ति करने की बात को याद करता है।
• आपको पता नहीं है कि यह क्यों काम करता है और इसे और कुछ करने के लिए सामान्यीकृत नहीं किया जा सकता है।
• केवल पूर्णांक गणित के साथ गणना करने की तुलना में अधिक महंगा है।
• z = n - 1 + 1यदि आप जानते हैं कि क्या चल रहा है, तो सबसे स्पष्ट "उप-रूपी" कोड ( ) वास्तव में स्व-दस्तावेजीकरण है।
• अतिरिक्त ट्रोलिंग के लिए मुझे p[]श्रृंखला गुणांक की पुनरावर्ती गणना का उपयोग करके गणना करनी चाहिए !

(यह गामा समारोह का लैंक्ज़ोस सन्निकटन है )

Comments

क्या इसमें कोई दम - 1 + 1है? मेरा कंपाइलर इसे ऑप्टिमाइज़ करता है (यह फ्लोटिंग पॉइंट नंबर नहीं है, जहाँ इस तरह का कोडिंग कोड खतरनाक हो सकता है), इसलिए यह अनावश्यक प्रतीत होता है।

— कोनराड बोरोस्की

@ एक्सफ़िक्स: double z = n - 1गामा फ़ंक्शन के सन्निकटन का हिस्सा है। + 1रिश्ता है कि से है gamma(n + 1) = n!पूर्णांक के लिए एन।

— बेन जैक्सन

Answer 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 की जरूरत है क्योंकि अजगर बेकार) प्रत्येक के लघुगणक की गणना करता है, संख्या का योग, योग e की घात को जन्म देती है और अंत में निकटतम पूर्णांक तक मूल्य दौर (क्योंकि अजगर बेकार) । पायथन में फैक्टरियल की गणना के लिए एक अंतर्निहित फ़ंक्शन है, लेकिन यह केवल पूर्णांकों के लिए काम करता है, इसलिए यह बड़ी संख्या में उत्पादन नहीं कर सकता है (क्योंकि पायथन चूसता है)। यही कारण है कि ऊपर फ़ंक्शन की आवश्यकता है।

Btw, छात्रों के लिए एक सामान्य टिप यह है कि अगर कुछ उम्मीद के मुताबिक काम नहीं करता है, तो यह शायद इसलिए है क्योंकि भाषा बेकार है।

Comments

काश मैं वर्णन के लिए कुछ अतिरिक्त वोट दे पाता, लेकिन पायथन चूसता है

— मार्क के कोवान

मैं "

— फेस यू

Answer 10

दुर्भाग्य से, जावास्क्रिप्ट में तथ्यात्मक गणना करने के लिए एक अंतर्निहित तरीके का अभाव है। लेकिन, फिर भी आप मूल्य अर्थ निर्धारित करने के लिए संयोजन में इसके अर्थ का उपयोग कर सकते हैं:

किसी संख्या n का भाज्य उस आकार की सूची के क्रमपरिवर्तन की संख्या है।

इसलिए, हम एन-अंक संख्या की प्रत्येक सूची उत्पन्न कर सकते हैं, जांचें कि क्या यह क्रमपरिवर्तन है, और यदि ऐसा है, तो एक काउंटर बढ़ाएँ:

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

---

---

trolls:

• प्रकार आयु संकेतन, साँप_केस और sigils। कितनी बुराई है?
• इस लेबल के वर्तमान उपयोग के साथ असंगत, जंप लेबल के लिए मेरे अपने सम्मेलन का आविष्कार किया।
• हर संभव चर संयोगवश वैश्विक है।
• समाधान नहीं है O(n) नहीं है O(n!), लेकिन नहीं है O(n^n)। यह अकेले यहाँ योग्यता प्राप्त करने के लिए पर्याप्त होता।
• संख्या बढ़ाना और फिर बेस-एन के रूप में परिवर्तित करना अनुक्रमों की सूची उत्पन्न करने का एक बुरा तरीका है। भले ही हम डुप्लिकेट चाहते थे। N> 13 के लिए रहस्यमय तरीके से टूटना एकमात्र कारण नहीं है।
• बेशक हम इस्तेमाल कर सकते थे number.toString(base), लेकिन यह 36 से ऊपर के अड्डों के लिए काम नहीं करता है। हां, मुझे पता है कि 36! एक है बहुत कुछ , लेकिन अभी भी ...
• क्या मैंने उल्लेख किया कि जावास्क्रिप्ट में मापांक ऑपरेटर था? याMath.pow ? नहीं? ओह अच्छा।
• उपयोग करने से मना करना ++फॉर-लूप के बाहर इसे और भी रहस्यमय बनाता है। इसके अलावा, ==बुरा है।
• गहरी नेस्टलेस ब्रेसिंग लूपिंग कंस्ट्रक्शन। इसके अलावा, नेस्टेड कंडीशन्स AND के बजाय। इसके अलावा, आंतरिक स्थिति को आंतरिक लूप को समाप्त करने से बचा जा सकता था$i ।
• कार्य new Array, document.write(दोस्तों के साथ) औरalert (एक प्रॉम्प्ट या इनपुट लेबल के बजाय) फंक्शन चॉइस पापों का एक पूरा ट्राइफेक्ट बनाते हैं। इनपुट को गतिशील रूप से क्यों जोड़ा गया है?
• इनलाइन घटना संचालकों। ओह, और गहरी पाइपिंग डीबग करने के लिए नरक है।
• निर्विवाद विशेषताएं मज़ेदार हैं, और चारों ओर रिक्त स्थान हैं = उन्हें पढ़ने के लिए और भी कठिन बनाते हैं।
• क्या मैंने पहले ही उल्लेख किया है कि मुझे अर्धविराम से नफरत है?

Answer 11

रूबी और वोल्फ्रामअल्फा

इस समाधान को हल करने के लिए RestClient के साथ और इसे पार्स करने के लिए नोक्गिरि के साथ फैक्टरियल की गणना करने के लिए वुल्फ्रामअल्फा रीस्ट एपीआई का उपयोग करता है। यह किसी भी पहिये को सुदृढ़ नहीं करता है और सबसे आधुनिक तरीके से परिणाम प्राप्त करने के लिए अच्छी तरह से परीक्षण की गई और लोकप्रिय तकनीकों का उपयोग करता है।

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

Answer 12

जावास्क्रिप्ट

जावास्क्रिप्ट एक कार्यात्मक प्रोग्रामिंग भाषा है, इसका मतलब है कि आपको हर चीज के लिए फ़ंक्शंस का उपयोग करना होगा क्योंकि यह तेज़ है।

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

Comments

क्या तुम समझा सकते हो?

— मुहम्मद

1 एक फ़ंक्शन नहीं है। इस प्रकार आपका कोड धीमा है।

— पियरे अरलाउड

@ArlaudPierre r = -~(function(){})निश्चित रूप से हल करेगा।

— नाइट्रो 2k01

मैं एक वर्क मशीन पर हूं इसलिए मैं वास्तव में इस भाषा को स्थापित नहीं करना चाहता। मुझे एक संस्करण कहां मिल सकता है जो मेरे ब्राउज़र में चलेगा?

— joeytwiddle

मैं Google का उपयोग करने से थोड़ा डरता हूं क्योंकि मेरे बॉस का उनके साथ एक खाता है, और मैं नहीं चाहता कि मुझे पता चले कि मैं काम में गोल्फ खेल रहा हूं। मैं फ़ायरफ़ॉक्स के लिए एक एक्सटेंशन की तलाश कर रहा था जो जावास्क्रिप्ट को चला सकता है, लेकिन मैं एक खोजने के लिए प्रतीत नहीं कर सकता। मेरे कुछ दोस्त jasfiddle.net पर जावास्क्रिप्ट चलाते हैं लेकिन वह किसी और की बिजली का उपयोग कर रहा है जो चोरी करने जैसा है। मेरी माँ ने कहा कि मुझे उस तरह के लोगों के साथ घूमना नहीं चाहिए, लेकिन वे मेरे दोस्त हैं इसलिए मैं क्या कर सकती हूं? वैसे भी वह कभी-कभी जरूरत से ज्यादा क्रीमर लेती है। सुझावों के लिए धन्यवाद, मैं फ़ायरफ़ॉक्स में Ctrl-Shift-J या K का उपयोग करता हूं। डिस्क्लेमर: # कमेंट-ट्रोलिंग

— joeytwiddle

Answer 13

जावा में बोगो-सॉर्ट का उपयोग करना

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

यह वास्तव में काम करता है, बस बहुत धीरे-धीरे, और यह उच्च संख्या के लिए सटीक नहीं है।

Answer 14

PERL

फैक्टरियल एक कठिन समस्या हो सकती है। एक नक्शा / तकनीक की तरह कम - जैसे Google उपयोग करता है - प्रक्रियाओं का एक गुच्छा बंद करके और परिणाम एकत्र करके गणित को विभाजित कर सकता है। यह सर्दी की रात में आपके सिस्टम में उन सभी कोर या सीपस का अच्छा उपयोग करेगा।

सुनिश्चित करें कि आप इसे चला सकते हैं बनाने के लिए 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);
    }
}

trolls:

• कांटे ओ (log2 (एन)) प्रक्रियाओं
• आपके पास कितने CPU या कोर की जाँच नहीं है
• हर प्रक्रिया में होने वाले बहुत से बिग्नेट / टेक्स्ट रूपांतरण को छुपाता है
• लूप के लिए अक्सर इस कोड से तेज होता है

Comments

TIL कि पर्ल ARGV[0]वास्तव में पहला तर्क है और स्क्रिप्ट नहीं!

— थिंकचैटोस

@plg मेरा मानना ​​है कि $ 0 में स्क्रिप्ट फ़ाइल नाम हो सकता है, लेकिन यह $ ARGV [0] के समान नहीं है

— पॉल

हां, यही मैंने पढ़ा है। मुझे बस यह आश्चर्यजनक लगा कि पर्ल में ऐसा नहीं है $ARGV[0]क्योंकि अधिकांश भाषाओं को मैं जानता हूँ कि यह थोड़ा सा है

— थिंकचैस

Answer 15

अजगर

बस एक ओ (एन! * एन ^ 2) एल्गोरिथ्म fact fact को खोजने के लिए। आधार मामला संभाला कोई ओवरफ्लो नहीं।

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

Answer 16

वैसे, गोल्फस्क्रिप्ट में एक आसान समाधान है। आप एक गोल्फस्क्रिप्ट दुभाषिया का उपयोग कर सकते हैं और इस कोड को चला सकते हैं:

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

आसान हुह :) शुभकामनाएँ!

Comments

मैं गोल्फस्क्रिप्ट नहीं जानता, लेकिन यह मुझे निराश करता है ... इस साइट पर अन्य गोल्फस्क्रिप्ट उदाहरणों के आधार पर, मुझे उत्तर की उम्मीद होगी!

— श्री लिस्टर

वह निगेटिव ऑपरेटर है। 0 1 हो जाता है और बाकी सब कुछ 0. बन जाता है

— मार्टिज़न कोर्टो

Answer 17

मेथेमेटिका

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

यह 11 से बड़े नंबरों के लिए काम नहीं करता है, और फैक्टरियल [11] ने मेरे कंप्यूटर को फ्रीज कर दिया है।

Answer 18

माणिक

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

सबसे धीमी वन-लाइनर जिसकी मैं कल्पना कर सकता हूं। गणना करने के लिए एक i7 प्रोसेसर पर 2 मिनट लगते हैं 6!।

Answer 19

इन कठिन गणित समस्याओं के लिए सही दृष्टिकोण एक डीएसएल है। इसलिए मैं इसे सरल भाषा के रूप में मॉडल करूँगा

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

हमारे DSL को अच्छी तरह से लिखने के लिए, इसे बीजगणितीय फ़नकार द्वारा उत्पन्न एक मुफ्त मोनाड के रूप में देखना उपयोगी है

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

और फिर एएसटी का पुनर्मूल्यांकन करना सीधा है।

Answer 20

अजगर

नीचे समाधान का एक पायथन संस्करण है, जो कि पायथन में पूर्णांक संख्याओं के लिए 32 बिट (या बहुत हाल की प्रणाली पर 64 बिट) तक सीमित नहीं है। इस सीमा के आस-पास जाने के लिए, हम एक स्ट्रिंग को इनपुट के रूप में उपयोग करेंगे और factorialरूटीन के लिए आउटपुट और आंतरिक रूप से स्ट्रिंग को उस अंक में विभाजित करेंगे जो गुणा करने में सक्षम हो।

इसलिए यहां कोड है: getDigitsफ़ंक्शन अपने अंकों में एक संख्या का प्रतिनिधित्व करने वाले स्ट्रिंग को विभाजित करता है, इसलिए "1234" बन जाता है [ 4, 3, 2, 1 ](रिवर्स ऑर्डर बस कार्य increaseऔर multiplyकार्यों को सरल बनाता है)। increaseसमारोह में इस तरह के एक सूची है और यह एक के बाद बढ़ जाती है लेता है। जैसा कि नाम से पता चलता है, multiplyफ़ंक्शन कई गुना है, उदाहरण के लिए multiply([2, 1], [3])रिटर्न[ 6, 3 ] क्योंकि 12 बार 3 36. उसी तरह से यह काम करता है है आप गुणा पेन और कागज के साथ कुछ करते।

फिर अंत में, 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 बिट्स द्वारा सीमित होने पर तथ्य की गणना कैसे कर सकते हैं। इसलिए जब कोई विश्वास नहीं करेगा कि यह समाधान है जो आप इस सरल (कम से कम पायथन) समस्या के लिए लेकर आए हैं, तो आप वास्तव में कुछ सीख सकते हैं।

Comments

पायथन में पूर्णांक संख्या पर कोई सीमा नहीं है ... सही है? आपको इसे बेहतर ढंग से समझाने की आवश्यकता हो सकती है।

— रेकिंग

@Riking हाँ, अजगर में पूर्णांकों के लिए कोई सीमा नहीं है। मैंने इसे और अधिक स्पष्ट करने के लिए कुछ नोट्स जोड़े हैं।

— brm

Answer 21

अजगर

सबसे उचित समाधान स्पष्ट रूप से सभी नंबरों के माध्यम से जांच करना है जब तक कि आप उस नंबर को नहीं पाते हैं जो दी गई संख्या का भाज्य है।

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

Answer 22

सी में सबसे सुरुचिपूर्ण पुनरावर्ती समाधान

हर एक तथ्य के सबसे सुरुचिपूर्ण समाधान जानता है कि वे पुनरावर्ती हैं।

क्रमगुणित:

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

हम्म, मैं तुम्हें बता दूँगा जब यह वापस हो जाता है ...

Answer 23

अजगर

जैसा कि @ Matt_Sieker के उत्तर में संकेत दिया गया है, फैक्टर्यूल्स को जोड़ दिया जा सकता है- क्यों, कार्यों को तोड़ना प्रोग्रामिंग का सार है। लेकिन, हम इसे 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)

मुझे लगता है कि यह कोड एक SO त्रुटि की गारंटी देता है , क्योंकि

1. पुनरावर्तन- इसे गर्म करता है

2. प्रत्येक परत कॉल को गुणा करने के लिए उत्पन्न करती है

3. जो व्यसनों को कॉल करता है

4. जो addby1 के लिए कॉल उत्पन्न करता है!

बहुत अधिक कार्य, सही?

Answer 24

बस Google पर जाएं और अपने भाज्य में टाइप करें:

5!

http://lmgtfy.com/?q=5!

Answer 25

टीआई-बेसिक 84

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

यह सचमुच काम करता है :)

Answer 26

जावास्क्रिप्ट

जाहिर है एक प्रोग्रामर का काम जितना संभव हो उतना कम काम करना है, और जितना संभव हो उतने पुस्तकालयों का उपयोग करना है। इसलिए, हम jQuery और math.js आयात करना चाहते हैं । अब, यह कार्य सरल है:

$.alert=function(message){
    alert(message);
}$.factorial=function(number){
    alert(math.eval(number+"!"));
    return math.eval(number+"!");
}
$.factorial(10);

Answer 27

अजगर

मानक पुनरावर्ती भाज्य कार्यान्वयन के सिर्फ एक मामूली संशोधन के साथ, यह n> 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

Answer 28

दे घुमा के

#! /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 $?

Answer 29

आइए इसे मोंटे कार्लो विधि द्वारा करने का प्रयास करें । हम सभी जानते हैं कि दो रैंडम n -परमुटेशन के बराबर होने की संभावना 1 / n है! । इसलिए हम अभी जांच कर सकते हैं कि कितने परीक्षण की जरूरत है (चलो फोन इस नंबर ख ) जब तक हम मिल ग हिट। फिर, एन! ~ B / c ।

ऋषि, अजगर में भी काम करना चाहिए

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!

Answer 30

दे घुमा के

फैक्टर्स आसानी से बैश से प्रसिद्ध कमांड लाइन उपकरण के साथ निर्धारित किए जाते हैं।

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

जैसा कि @Aaron Davies ने टिप्पणियों में उल्लेख किया है, यह बहुत ही स्पष्ट दिखता है और हम सभी एक अच्छा और सुव्यवस्थित कार्यक्रम चाहते हैं, क्या हम नहीं?

read -p "Enter number: " $n
seq 1 $n | paste -sd\* | bc

Comments

मैं अत्यधिक-अंडररेटेड pasteकमांड की सिफारिश करता हूं :seq 1 $n | paste -sd\* | bc

— आरोन डेविस

@AaronDavies pasteएक नियमित अंग्रेजी शब्द की तरह दिखता है और याद रखने में आसान है। क्या हम वास्तव में ऐसा चाहते हैं? ; ओ)

— जिप्पी