तथ्य का पता लगाएं!

Question

सबसे छोटा प्रोग्राम या फ़ंक्शन बनाएं जो एक गैर-नकारात्मक पूर्णांक के भाज्य को पाता है ।

इस !तथ्य को, इस तरह से परिभाषित किया गया है

$$n!:=\begin{cases}1 & n=0\\n\cdot(n-1)!&n>0\end{cases}$$

सादे अंग्रेजी में 0 का भाज्य 1 और n का भाज्य है, जहाँ n 0 से बड़ा है, n से n से कम का गुणक है।

आपके कोड को मानक विधियों का उपयोग करके इनपुट और आउटपुट करना चाहिए।

आवश्यकताएँ:

• किसी भी अंतर्निहित पुस्तकालयों का उपयोग नहीं करता है जो तथ्य की गणना कर सकते हैं (इसमें किसी भी रूप में शामिल है eval)
• 125 तक की संख्या के लिए भाज्य गणना कर सकते हैं
• संख्या 0 के लिए भाज्य की गणना कर सकते हैं (1 के बराबर)
• 125 तक की संख्या के लिए एक मिनट से कम में पूरा करता है

सबसे कम सबमिशन जीतता है, टाई के मामले में सबसे अधिक वोटों के साथ जवाब जीतता है।

Comments

दिए गए उत्तरों में से कितने वास्तव में 125 तक की गणना कर सकते हैं! पूर्णांक अतिप्रवाह के बिना? क्या वह आवश्यकताओं में से एक नहीं था? क्या घातीय सन्निकटन स्वीकार्य हैं (यानी 125! = 1.88267718 × 10 ^ 209)?

— अमी

@SHiNKiROU, यहां तक ​​कि गोल्फस्क्रिप्ट 125 का प्रबंधन कर सकते हैं! एक सेकंड के 1/10 से कम और यह और व्याख्या की गई भाषा है!

— gnibbler

@ दो-वर्ण समाधान का अन्य प्रश्न के लिए बनाया गया एक अंतर्निहित फ़ैक्टोरियल फ़ंक्शन का उपयोग करता है। चुनौती के इस संस्करण में इसकी अनुमति नहीं है।

— माइकल स्टर्न

एक मिनट के भीतर पूर्णता बहुत ही हार्डवेयर-निर्भर आवश्यकता लगती है। क्या हार्डवेयर पर एक मिनट के तहत पूरा ?

— सेरगिओल

@sergiol अविश्वसनीय रूप से पिछले 2 वर्षों में एक मुद्दा नहीं रहा है, मुझे संदेह है कि अधिकांश भाषाएं इसे एक मिनट से कम समय में पूरा कर सकती हैं।

— केविन ब्राउन

Answer 1

गोल्फस्क्रिप्ट - 12 वर्ण

{,1\{)*}/}:f

---

गोल्फस्क्रिप्ट के साथ शुरुआत करना - कदम-कदम पर फैक्टरियल

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

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

# pseudocode: f(n){c=1;while(n>1){c*=n;n--};return c}
{:n;1:c;{n 1>}{n c*:c;n 1-:n;}while c}:f

व्हॉट्सएप का उपयोग बहुत कम ही गोल्फ में होता है। व्हाट्सएप से छुटकारा पाने के लिए सबसे आसान ट्रिक है विभिन्न वेरिएबल नामों का उपयोग करना। प्रत्येक टोकन को एक चर के रूप में इस्तेमाल किया जा सकता है ( वाक्यविन्यास पृष्ठ देखें )। उपयोगी टोकन के रूप में चर की तरह विशेष वर्णों को उपयोग करने के लिए |, &, ?आम तौर पर कुछ भी नहीं कोड में कहीं और इस्तेमाल किया -। इन्हें हमेशा सिंगल कैरेक्टर टोकन के रूप में रखा जाता है। इसके विपरीत, चर की तरह nएक संख्या के बाद ढेर को धकेलने के लिए स्थान की आवश्यकता होगी। संख्याएं अनिवार्य रूप से पूर्व-निर्धारित चर हैं।

हमेशा की तरह, ऐसे कथन होने जा रहे हैं जिन्हें हम अंतिम परिणाम को प्रभावित किए बिना बदल सकते हैं। Golfscript में, सब कुछ को छोड़कर सही का आकलन 0, [], "", और {}(देखें इस )। यहां, हम लूप निकास स्थिति को बस में बदल सकते हैं {n}(हम एक अतिरिक्त समय लूप करते हैं, और जब n = 0 समाप्त होता है)।

किसी भी भाषा को गोल्फ के साथ उपलब्ध कार्यों को जानने में मदद करता है। सौभाग्य से यह सूची गोल्फस्क्रिप्ट के लिए बहुत कम है। हम एक और चरित्र को बचाने के 1-लिए बदल सकते हैं (। वर्तमान में कोड इस तरह दिखता है: (हम प्रयोग किया जा सकता है 1के बजाय |यहां अगर हम चाहते थे, जो प्रारंभ छोड़ देगी।)

{:n;1:|;{n}{n|*:|;n(:n;}while|}:f

सबसे कम समाधान (अभ्यास अभ्यास अभ्यास) प्राप्त करने के लिए स्टैक का उपयोग करना महत्वपूर्ण है। आमतौर पर, यदि मान केवल कोड के एक छोटे खंड में उपयोग किए जाते हैं, तो उन्हें चर में संग्रहीत करना आवश्यक नहीं हो सकता है। चल रहे उत्पाद चर को हटाकर और केवल स्टैक का उपयोग करके, हम काफी पात्रों को बचा सकते हैं।

{:n;1{n}{n*n(:n;}while}:f

यहाँ कुछ और सोचने के लिए है। हम nलूप बॉडी के अंत में स्टैक से वैरिएबल को हटा रहे हैं , लेकिन फिर इसे तुरंत बाद धकेल रहे हैं। वास्तव में, लूप शुरू होने से पहले हम इसे स्टैक से भी निकालते हैं। हमें इसके बजाय इसे स्टैक पर छोड़ देना चाहिए, और हम लूप की स्थिति को खाली रख सकते हैं।

{1\:n{}{n*n(:n}while}:f

शायद हम चर को पूरी तरह से खत्म भी कर सकते हैं। ऐसा करने के लिए, हमें हर समय वैरिएबल को स्टैक पर रखना होगा। इसका मतलब है कि हमें स्थिति की जांच के अंत में स्टैक पर चर की दो प्रतियों की आवश्यकता है ताकि हम इसे चेक के बाद खो न दें। जिसका अर्थ है कि हम 0लूप के समाप्त होने के बाद स्टैक पर निरर्थक होंगे , लेकिन इसे ठीक करना आसान है।

यह हमें हमारे इष्टतम whileलूप समाधान की ओर ले जाता है !

{1\{.}{.@*\(}while;}:f

अब हम इसे छोटा करना चाहते हैं। स्पष्ट लक्ष्य शब्द होना चाहिए while। प्रलेखन को देखते हुए, दो व्यवहार्य विकल्प हैं - प्रकट करना और करना । जब आपके पास दोनों के लाभों को लेने, प्रयास करने और वजन करने के लिए विभिन्न मार्गों का विकल्प होता है। अनफोल्ड 'बहुत अधिक समय तक लूप' है, इसलिए एक अनुमान के रूप में हम 5 चरित्र whileको 4 से कम कर देंगे /। के रूप में do, हम while3 वर्णों में कटौती करते हैं , और दो ब्लॉकों को मर्ज करने के लिए मिलता है, जो एक और चरित्र या दो को बचा सकता है।

doलूप का उपयोग करने में वास्तव में एक बड़ी खामी है । चूंकि शरीर द्वारा एक बार निष्पादित किए जाने के बाद हालत की जांच की जाती है, इसलिए मूल्य 0गलत होगा, इसलिए हमें एक बयान की आवश्यकता हो सकती है। मैं अब आपको बताता हूं कि अनफॉल्ड कम है (कुछ समाधान doअंत में दिए गए हैं)। आगे बढ़ो और इसे आज़माओ, हमारे पास पहले से मौजूद कोड में न्यूनतम बदलाव की आवश्यकता है।

{1\{}{.@*\(}/;}:f

महान! हमारा समाधान अब सुपर-शॉर्ट हो गया है और हम यहीं पर हैं? नहीं। यह 17 वर्ण है, और J में 12 वर्ण हैं। हार कभी न मानें!

---

अब आप सोच रहे हैं ... पुनरावृत्ति

पुनरावर्तन का उपयोग करने का मतलब है कि हमें एक शाखा संरचना का उपयोग करना चाहिए । दुर्भाग्यपूर्ण, लेकिन जैसा कि तथ्यात्मक रूप से इतने संक्षिप्त रूप से व्यक्त किया जा सकता है, यह पुनरावृत्ति के लिए एक व्यवहार्य विकल्प जैसा लगता है।

# pseudocode: f(n){return n==0?n*f(n-1):1}
{:n{n.(f*}1if}:f # taking advantage of the tokeniser

खैर यह आसान था - क्या हमने पहले पुनरावृत्ति की कोशिश की थी, हम एक whileलूप का उपयोग करने पर भी ध्यान नहीं दे सकते थे ! फिर भी, हम केवल 16 वर्णों पर हैं।

---

Arrays

ऐरे आम तौर पर दो तरीकों से बनाए जाते हैं - [और ]वर्णों का उपयोग करके , या ,फ़ंक्शन के साथ । यदि स्टैक के शीर्ष पर एक पूर्णांक के साथ निष्पादित किया जाता है, तो ,गिरफ्तारी [i] = i के साथ उस लंबाई की एक सरणी देता है।

सरणियों पर पुनरावृत्ति के लिए, हमारे पास तीन विकल्प हैं:

1. {block}/: धक्का, ब्लॉक, धक्का, ब्लॉक, ...
2. {block}%: [धक्का, ब्लॉक, धक्का, ब्लॉक, ...] (यह कुछ बारीकियों है, उदाहरण के लिए मध्यवर्ती मूल्यों को प्रत्येक से ढेर से हटा दिया जाता है)
3. {block}*: धक्का, धक्का, ब्लॉक, धक्का, ब्लॉक, ...

गोल्फस्क्रिप्ट प्रलेखन में {+}*एक सरणी की सामग्री का योग करने का एक उदाहरण है । इससे पता चलता है कि हम {*}*किसी सरणी का उत्पाद प्राप्त करने के लिए उपयोग कर सकते हैं ।

{,{*}*}:f

दुर्भाग्य से, यह इतना आसान नहीं है। सभी तत्व एक के [0 1 2]बजाय एक (बंद [1 2 3]) हैं। हम {)}%इस समस्या को सुधारने के लिए उपयोग कर सकते हैं ।

{,{)}%{*}*}:f

खैर काफी नहीं। यह शून्य को सही तरीके से नहीं संभालता है। हम इसे सुधारने के लिए (n + 1)! / (N + 1) की गणना कर सकते हैं, हालांकि यह बहुत अधिक लागत है।

{).,{)}%{*}*\/}:f

हम n = 1 के रूप में एक ही बाल्टी में n = 0 को संभालने की भी कोशिश कर सकते हैं। यह आपके द्वारा किए गए सबसे कम समय के लिए करने, प्रयास करने और काम करने के लिए वास्तविक अत्यंत छोटा है।

इतना अच्छा नहीं है, 7 अक्षरों में: छँटाई [1\]$1=। ध्यान दें कि इस सॉर्टिंग तकनीक में उपयोगी उद्देश्य होते हैं, जैसे कि किसी संख्या पर सीमाएं लगाना (जैसे `[0 \ 100] $ 1 =)
यहाँ विजेता केवल 3 वर्णों के साथ है:! +!

यदि हम एक ही ब्लॉक में वृद्धि और गुणा करना चाहते हैं, तो हमें सरणी में प्रत्येक तत्व पर पुनरावृति करना चाहिए। चूँकि हम कोई सरणी नहीं बना रहे हैं, इसका मतलब है कि हमें इसका उपयोग करना चाहिए {)*}/, जो हमें सबसे छोटे गोल्फस्प्रेक्टर को फैक्टरियल के कार्यान्वयन में लाता है! 12 वर्णों पर, यह J से बंधा है!

{,1\{)*}/}:f

---

बोनस समाधान

ifएक doलूप के लिए एक सीधा समाधान के साथ शुरू :

{.{1\{.@*\(.}do;}{)}if}:f

हम इसमें से एक जोड़े को निचोड़ सकते हैं। थोड़ा जटिल है, इसलिए आपको खुद को इन कामों के लिए राजी करना होगा। सुनिश्चित करें कि आप इन सभी को समझते हैं।

{1\.!!{{.@*\(.}do}*+}:f
{.!{1\{.@*\(.}do}or+}:f
{.{1\{.@*\(.}do}1if+}:f

एक बेहतर विकल्प गणना (एन + 1) है! / (एन + 1), जो एक ifसंरचना की आवश्यकता को समाप्त करता है ।

{).1\{.@*\(.}do;\/}:f

लेकिन यहां सबसे छोटा doसमाधान 0 से 1 के नक्शे तक कुछ वर्णों को ले जाता है, और बाकी सब अपने आप को - इसलिए हमें किसी शाखा की जरूरत नहीं है। इस तरह का अनुकूलन याद करने में बेहद आसान है।

{.!+1\{.@*\(.}do;}:f

रुचि रखने वाले किसी व्यक्ति के लिए, ऊपर की लंबाई के साथ कुछ वैकल्पिक पुनरावर्ती समाधान यहां दिए गए हैं:

{.!{.)f*0}or+}:f
{.{.)f*0}1if+}:f
{.{.(f*}{)}if}:f

---

* नोट: मैंने वास्तव में इस पोस्ट में कोड के कई टुकड़ों का परीक्षण नहीं किया है, इसलिए यदि कोई त्रुटि हो तो सूचित करें।

Comments

दिलचस्प है, जब आप स्पॉइलर में कोड का उपयोग करते हैं, तो स्पॉइलर मार्कडाउन में एक बग लगता है ... मेटा पर इसका उल्लेख करने के लिए कोई भी परवाह करता है?

— इवो ​​फ्लिप

मुझे यह दिलचस्प लगता है कि गोल्फस्क्रिप्ट - एक गोल्फिंग भाषा - मल्टी-लेटर चर नामों और "

— व्हाट्स

Answer 2

हास्केल, 17

f n=product[1..n]

Comments

मैं हास्केल को नहीं जानता ... लेकिन क्या यह 0

— राजा के लिए

@ राजा: हाँ, यह होगा। [1..0] ==> []औरproduct [] ==> 1

— JB

मैं तर्क देता हूं कि यह "बिल्ट-इन लाइब्रेरी" का उपयोग करता है कि समस्या निषिद्ध है। फिर भी, दूसरी विधि f 0=1;f n=n*f$n-117 वर्णों की भी है।

— अनन्तमट्ट

@eternalmatt: प्रतिबंधों का वह हिस्सा मुझे रेखांकित किया गया है। दोनों product, कहते हैं, (*)या (-)"तथ्य की गणना कर सकते हैं", और वे सभी प्रस्तावना के माध्यम से परिभाषित किए गए हैं। एक शांत क्यों होगा और दूसरा नहीं?

— जे.बी.

@YoYoYonnY: मैं 17 पात्रों को गिनता हूं, कम (व्यक्तिपरक) पठनीयता के लिए। IMHO यह टिप्पणियों में ठीक है।

— जेबी

Answer 3

अजगर - 27

बस:

f=lambda x:0**x or x*f(x-1)

Comments

अच्छी चाल 0**x:।

— अलेक्जेंड्रू

किस बारे में math.factorial? यह बिल्ट-इन नहीं है, क्या यह है?

@JackBates जो एक बेसिन के रूप में गिना जाता है, क्योंकि आपने भाज्य गणना करने के लिए कोड नहीं लिखा था।

— पलटें

क्या कोई बता सकता है कि पीछे क्या तरकीब है 0**x?

— पवित्रा

@Pavitra: 0 0 = 1, और यह पहली चीज है जो इसका मूल्यांकन करती है इसलिए यह वापस आ जाती है। किसी भी अन्य n, 0 n = 0 के लिए, इस प्रकार का पहला ऑपरेंड गलत है, जैसे कि दूसरे ऑपरेंड का मूल्यांकन किया जाता है।

— मेगा मैन

Answer 4

एपीएल (4)

×/∘⍳

एक अनाम फ़ंक्शन के रूप में काम करता है:

    ×/∘⍳ 5
120

यदि आप इसे 6 अक्षर देना चाहते हैं:

f←×/∘⍳

Comments

मैं एपीएल नहीं बोलता, यहाँ क्या हो रहा है?

— माइकल स्टर्न

@MichaelStern: ⍳यानी एक सूचकांक वेक्टर बनाता है, ⍳5है 1 2 3 4 5। ×(जाहिर है) गुणा है, /कम है, और ∘फ़ंक्शन रचना है। तो, ×/∘⍳एक फ़ंक्शन है जो एक तर्क लेता है xऔर संख्याओं का उत्पाद देता है [1..x]।

— मारीनस

आह, @Yves Klett के Mathematica समाधान के रूप में एक ही दृष्टिकोण। बहुत अच्छा।

— माइकल स्टर्न

@ एनबीजेड: यह 2011 में अभी तक मौजूद नहीं था जब यह प्रश्न लिखा गया था, और न ही 2012 में जब मैंने यह उत्तर लिखा था। ट्रेनों को केवल Dyalog 14.0 में जोड़ा गया था, जो 2014 में सामने आई।

— marinus

Answer 5

जे (12)

J में एक मानक परिभाषा:

f=:*/@:>:@i.

125 के लिए 1sec से कम!

उदाहरण के लिए:

 f 0
 1
 f 5
 120
  f 125x
 1882677176888926099743767702491600857595403
 6487149242588759823150835315633161359886688
 2932889495923133646405445930057740630161919
 3413805978188834575585470555243263755650071
 31770880000000000000000000000000000000

Comments

क्यों न सिर्फ * />: i। ?

— Andbdrew

क्योंकि ओपी एक फ़ंक्शन के लिए पूछता है और जे में सबसे अच्छा हम एक क्रिया को परिभाषित कर सकते हैं।

— बारहवीं

कोई कारण नहीं है कि यह एक अनाम फ़ंक्शन सही नहीं हो सकता है? जैसे ([:*/1+i.)10 अंक, या 8 भी के रूप में कोष्ठक केवल फ़ंक्शन को कॉल करने के लिए आवश्यक हैं , परिभाषा के लिए नहीं।

— jpjacobs 22

पिछले एक में, f 125xक्या करता xहै? क्या यह एक विशेष प्रकार की संख्या है?

— साइओस

@ कोको, हाँ, यह विस्तारित सटीक पूर्णांक है।

— बारह

Answer 6

गोल्फस्क्रिप्ट - 13 वर्ण (SYM)

फ़ंक्शन को परिभाषित करता है !

{),()\{*}/}:!             # happy robot version \{*}/ 

वैकल्पिक 13 चार संस्करण

{),()+{*}*}:! 

पूरे कार्यक्रम का संस्करण 10 वर्ण है

~),()+{*}*

वृषण 1/10 सेकंड से कम समय लेते हैं:

इनपुट:

0!

उत्पादन

1

इनपुट

125!

उत्पादन

188267717688892609974376770249160085759540364871492425887598231508353156331613598866882932889495923133646405445930057740630161919341380597818883457558547055524326375565007131770880000000000000000000000000000000

Comments

प्रतीकात्मक गोल्फ प्रविष्टि के लिए +1! काश मैं एक से अधिक बार उत्थान कर पाता। :

— क्रिस जस्टर-यंग

@ क्रिसजस्टर-यंग मैं आपके लिए करूंगा।

— साइओस

Answer 7

पर्ल 6: 13 वर्ण

$f={[*]1..$_}

[*]हास्केल के रूप में एक ही है product, और 1..$_1 से एक तक की गिनती है $_, तर्क।

Comments

[*]अब ("एक पंक्ति में दो शब्द" त्रुटि संदेश) के बाद किसी स्थान का उपयोग नहीं करने की अनुमति नहीं है ।

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

आपको एक चर सेट करने की आवश्यकता नहीं है, एक नंगे कोड ब्लॉक एक स्वीकार्य उत्तर है क्योंकि यह एक कार्य करता है। यह भी 0 के लिए अभी भी काम करता है?

— फिल एच।

Answer 8

मतलूब, १५

f=@(x)prod(1:x)

परीक्षण के मामलों

>> f(0)
ans =
     1
>> f(4)
ans =
    24
>> tic,f(125),toc
ans =
  1.8827e+209
Elapsed time is 0.000380 seconds.

Answer 9

पायथन, 28 बाइट्स

f=lambda x:x/~x+1or x*f(x-1)

(अलेक्जेंड्रू के समाधान पर आधारित)

Answer 10

MATL , 2 बाइट्स

:p

व्याख्या की:

:    % generate list 1,2,3,...,i, where i is an implicit input
p    % calculate the product of of all the list entries (works on an empty list too)

इसे ऑनलाइन आज़माएं!

Comments

: हे

— एनड्रास Deak

मैं वास्तव में यह पोस्ट करने जा रहा था :-) आप कोड और एक उदाहरण इनपुट को शामिल करने के लिए लिंक को संशोधित करना चाह सकते हैं

— लुइस मेंडो

जैसा कि आप आज्ञा देते हैं, मेरे प्रभु।

— त्रुटिपूर्ण

@AndrasDeak, नहीं, कि 1 से i तक सभी नंबरों का उत्पादन होगा ...

— YoYoYonnY

Answer 11

रूबी - 21 वर्ण

f=->n{n>1?n*f[n-1]:1}

परीक्षा

irb(main):009:0> f=->n{n>1?n*f[n-1]:1}
=> #<Proc:0x25a6d48@(irb):9 (lambda)>
irb(main):010:0> f[125]
=> 18826771768889260997437677024916008575954036487149242588759823150835315633161
35988668829328894959231336464054459300577406301619193413805978188834575585470555
24326375565007131770880000000000000000000000000000000

Answer 12

जावा, 85 शुल्क

BigInteger f(int n){return n<2?BigInteger.ONE:new BigInteger(""+n).multiply(f(n-1));}

Comments

यह आयात को याद करता है: import java.math.*;(इसलिए, +19 बाइट्स)।

— ओलिवियर ग्रेजायर

निष्पक्ष बिंदु। ............

— st0le

Answer 13

पोस्टस्क्रिप्ट, 26 वर्ण

/f{1 exch -1 1{mul}for}def

उदाहरण:

GS> 0 f =
1
GS> 1 f =
1
GS> 8 f =
40320

समारोह में केवल 21 अक्षर लगते हैं; बाकी इसे एक चर में बाँधना है। एक बाइट को बचाने के लिए, कोई इसे एक अंक में बाँध सकता है, जैसे:

GS> 0{1 exch -1 1{mul}for}def
GS> 8 0 load exec =
40320

Comments

घोस्टस्क्रिप्ट 125 को नहीं संभाल सकता है! 34 से आगे कुछ भी! के रूप में बाहर आता है 1.#INF। (मैं x64 विंडोज के लिए जीएनयू घोस्टस्क्रिप्ट 9.0.7 संकलित स्टॉक का उपयोग करता था।)

— रॉस प्रेसर

Answer 14

जावास्क्रिप्ट, २५

function f(n)!n||n*f(n-1)

कॉफी, १ ९

f=(n)->!n||n*f(n-1)

trueN = 0 के मामले में लौटाता है, लेकिन जावास्क्रिप्ट वैसे भी 1 टाइप करेगा।

Comments

आपको returnजावास्क्रिप्ट फ़ंक्शन में एक बयान की आवश्यकता नहीं है?

— जस्टिन मॉर्गन

अपडेट: पवित्र धुआं, आपको इसकी आवश्यकता नहीं है return! पर क्यों नहीं?

— जस्टिन मॉर्गन

यह JavaScript 1.8 ( developer.mozilla.org/en/new_in_javascript_1.8 ) है। पूर्ण प्रकटीकरण, यह केवल फ़ायरफ़ॉक्स पर काम करता है!

— केसी चु

अच्छा लगा, मुझे जावास्क्रिप्ट 1.8 के रिटर्न स्टेटमेंट को छोड़ने के बारे में नहीं पता था। इसके अलावा, आप एक ही लंबाई कोड के साथ n = 0 मामले के लिए सच के बजाय 1 की गारंटी दे सकते हैं: function f(n)n?n*f(--n):1

— Briguy37

ईएस 6, 17: f=n=>!n||n*f(n-1)वह, कॉफीस्क्रिप्ट ले लो!

— Ry-

Answer 15

रूबी - 30 29 अक्षर

def f(n)(1..n).inject 1,:*end

परीक्षा

f(0) -> 1
f(5) -> 120

Comments

आप एक नई लाइन या अर्धविराम के बिना endसीधे डाल सकते हैं :*।

— sepp2k

# कॉल करने के लिए # 1 पास करने की आवश्यकता नहीं है। (1..10).inject :*# => 3628800

— डॉगबर्ट

@ डॉगबर्ट, किस बारे में f(0)?

— नेमो 157

@ निमो 157, आह! उस के बारे में भूल गया।

— डॉगबर्ट

1.9 लैम्ब्डा सिंटैक्स का उपयोग करने के लिए छोटा f=->n{(1..n).inject 1,:*}:। इसके साथ बुलाओ f[n]।

— माइकल कोहल

Answer 16

एफ #: 26 चार्ट

एफ # में कोई इनबिल्ट उत्पाद फ़ंक्शन नहीं है, लेकिन आप एक गुना के साथ एक बना सकते हैं

let f n=Seq.fold(*)1{1..n}

Answer 17

C #, 20 या 39 अक्षर आपकी बात पर निर्भर करता है

पारंपरिक उदाहरण विधि के रूप में (39 वर्ण; यहाँ परीक्षण ):

double f(int x){return 2>x?1:x*f(x-1);}

लैम्ब्डा अभिव्यक्ति के रूप में (20 अक्षर, लेकिन अस्वीकरण देखें; यहां परीक्षण किया गया ):

f=x=>2>x?1:x*f(x-1);

हम उपयोग करने के लिए doubleहै, क्योंकि 125! == 1.88 * 10 ²⁰⁹ , जो की तुलना में बहुत अधिक है ulong.MaxValue।

लैम्ब्डा संस्करण की वर्ण गणना के बारे में अस्वीकरण:

यदि आप C # लैम्ब्डा में पुनरावृत्ति करते हैं, तो आपको स्पष्ट रूप से लैम्ब्डा को एक नामित चर में संग्रहित करना होगा ताकि वह स्वयं को कॉल कर सके। लेकिन (उदाहरण के लिए) जावास्क्रिप्ट के विपरीत, एक स्व-रेफ़रिंग लैम्ब्डा को घोषित किया जाना चाहिए और पिछली पंक्ति पर आरंभीकृत किया जाना चाहिए । आप फ़ंक्शन को उसी स्टेटमेंट में नहीं कह सकते हैं जिसमें आप वैरिएबल को घोषित और / या आरंभ करते हैं।

दूसरे शब्दों में, यह काम नहीं करता है :

Func<int,double> f=x=>2>x?1:x*f(x-1); //Error: Use of unassigned local variable 'f'

लेकिन यह करता है :

Func<int,double> f=null;            
f=x=>2>x?1:x*f(x-1);  

इस प्रतिबंध का कोई अच्छा कारण नहीं है, क्योंकि fजिस समय यह चलता है उस समय कभी भी अनसाइन नहीं किया जा सकता है। Func<int,double> f=null;लाइन की आवश्यकता सी # का एक क्विक है। चाहे वह चरित्र गिनती में इसे अनदेखा करना उचित बनाता है या नहीं, यह पाठक पर निर्भर है।

कॉफीस्क्रिप्ट, असली के लिए 21 19 अक्षर

f=(x)->+!x||x*f x-1

यहाँ परीक्षण किया गया: http://jsfiddle.net/0xjdm971/

Answer 18

ब्रेकीलॉग , 7 6 बाइट्स

एक सीमा बनाकर और इसे गुणा करके

-1 बाइट टैंक से लेकर अधिकतम () फ़ंक्शन का उपयोग करने का विचार है

;1⌉⟦₁×

व्याख्या

;1          --  If n<1, use n=1 instead (zero case)
  ⟦₁        --      Construct the range [1,n]
    ×       --      return the product of said range

इसे ऑनलाइन आज़माएं!

---

ब्रेकीलॉग , 10 9 बाइट्स

प्रत्यावर्तन

≤1|-₁↰;?×

व्याख्या

            --f(n):
≤1          --  if n ≤ 1: return 1
|           --  else:
 -₁↰        --      f(n-1)
    ;?×     --            *n

इसे ऑनलाइन आज़माएं!

Comments

यह 6 बाइट्स के लिए काम करता है। एकल के रूप में इनपुट लेना डिफ़ॉल्ट रूप से अनुमत है।

— अंडा २।

@ovs धन्यवाद लेकिन ;इसके बजाय ,केवल एक नियमित संख्यात्मक इनपुट के लिए अनुमति देता है। वैसे भी -बेटे

— क्रॉपेब

Answer 19

सी (39 वर्ण)

double f(int n){return n<2?1:n*f(n-1);}

Comments

अच्छा लगा। लेकिन कुछ पात्रों को बचा सकते हैं: double f(n){return!n?1:n*f(n-1);}- 33 वर्ण।

— ugoren

f(125)अतिप्रवाह होगा

— jkabrg

Answer 20

D: 45 वर्ण

T f(T)(T n){return n < 2 ? 1 : n * f(n - 1);}

अधिक कानूनी रूप से:

T f(T)(T n)
{
    return n < 2 ? 1 : n * f(n - 1);
}

एक कूलर (हालांकि अधिक लंबा संस्करण) टेम्पलेटेड है जो यह सब संकलन समय ( 64 अक्षर ) पर करता है:

template F(int n){static if(n<2)enum F=1;else enum F=n*F!(n-1);}

अधिक कानूनी रूप से:

template F(int n)
{
    static if(n < 2)
        enum F = 1;
    else
        enum F = n * F!(n - 1);
}

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

Comments

व्हॉट्सएप को बाहर निकालें और आप इसे 36 वर्णों तक नीचे ला सकते हैं

— शाफ़्ट फ्रीक

@ क्या आप समझा सकते हैं?

— YoYoYonnY

साइट में आपका स्वागत है, @ user272735। ध्यान दें कि हम यहां सुधार करने के लिए लोगों के समाधान संपादित नहीं करते हैं। इसके बजाय, हम उन सुधारों का सुझाव देते हुए टिप्पणी छोड़ते हैं, जैसा कि शाफ़्ट फ्रीक ने किया था।

— शैगी

Answer 21

पॉवरशेल - 36

भोली:

filter f{if($_){$_*(--$_|f}else{1}}

परीक्षा:

> 0,5,125|f
1
120
1,88267717688893E+209

Answer 22

स्काला, 39 वर्ण

def f(x:BigInt)=(BigInt(1)to x).product

अधिकांश वर्ण यह सुनिश्चित कर रहे हैं कि BigInts का उपयोग किया जाता है इसलिए 125 तक के मानों की आवश्यकता पूरी होती है।

Comments

कुछ छोटे विकल्प:(x:Int)=>(BigInt(1)to x).product def f(x:Int)=(BigInt(1)to x).product def f(x:BigInt)=(x.to(1,-1)).product def f(x:BigInt)=(-x to-1).product.abs

— LRLucena

Answer 23

जावास्क्रिप्ट, ईएस 6 17

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

ES6:

• तीर का कार्य

Comments

ES6 इस चुनौती से छोटा है यदि मैं सही ढंग से याद कर रहा हूं और इसलिए पात्र नहीं हूं।

— lirtosiast

सशर्त ऑपरेटर के साथ अजीब अजीब है। दो कॉलन क्यों हैं?

— क्वर्टी

@ क्वर्टी आप सही कह रहे हैं, यह एक टाइपो था, धन्यवाद।

— अफोंसो माटोस

Answer 24

पॉवरशेल, 42 बाइट्स

( फ़ंक्शन के बजाय फ़िल्टर का उपयोग करके सहेजे गए 2 वर्ण )

filter f($x){if(!$x){1}else{$x*(f($x-1))}}

आउटपुट:

PS C:\> f 0
1
PS C:\> f 5
120
PS C:\> f 1
1
PS C:\> f 125
1.88267717688893E+209

Comments

अब यह तरीका पुराना है, लेकिन ... अगर / बाकी पीछे से 1 और वर्ण बचा सकते हैं: filter f($x){if($x){$x*(f($x-1))}else{1}}। और इसे 36 वर्णों तक और कम किया जा सकता है यदि इसे पाइपलाइन के माध्यम से बुलाया जाता है क्योंकि यह एक फिल्टर है (जैसे 125|f):filter f{if($_){$_*($_-1|f)}else{1}}

— एंड्रयू

Answer 25

रैकेट (योजना) 40 35 29 बाइट्स

गणना 0! 1 होना चाहिए, और 125 गणना करता है! टाइमर के अनुसार 0 सेकंड में। नियमित पुनरावर्ती दृष्टिकोण

(define(f n)(if(= n 0)1(* n(f(- n 1)))))

आम लिस्प को हराने के लिए नया संस्करण: सूची के सभी तत्वों को गुणा करता है (उसी हास्केल समाधान के रूप में)

(λ(n)(apply *(build-list n add1)))

नया संस्करण दूसरे स्कीम सॉल्यूशन को बीट करने के लिए और दूसरे रैकेट सॉल्यूशन को गणित के लिए लागू करने के बजाय फोल्ड करके और लाइन्स लिस्ट के बजाय रेंज का उपयोग करके

(λ(n)(foldl * n(range 1 n)))

Answer 26

मॉर्निंगटन क्रिसेंट , 1827 1698 वर्ण

मुझे लगा कि आज मैं एक नई भाषा सीख रहा हूं, और यही वह है जिस पर मैं उतरा हूं ... (मैं अपने आप से ऐसा क्यों करता हूं?) यह प्रविष्टि किसी भी पुरस्कार को नहीं जीतेगी, लेकिन यह सभी 0 अन्य उत्तरों को अब तक का उपयोग करते हुए धड़कता है। एक ही भाषा!

Take Northern Line to Bank
Take Central Line to Holborn
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Acton Town
Take District Line to Hammersmith
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Parsons Green
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Temple
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take District Line to Upney
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upney
Take District Line to Bank
Take Circle Line to Embankment
Take Circle Line to Embankment
Take Northern Line to Angel
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent

इसे ऑनलाइन आज़माएं!

जो कोई भी लंदन का चक्कर लगा रहा है, वह तुरंत ही समझ जाएगा, इसलिए मुझे यकीन है कि मुझे पूरी जानकारी देने की आवश्यकता नहीं है।

शुरुआत में ज्यादातर काम 0 केस को संभालने में होता है। उत्पाद को 1 पर आरंभीकृत करने के बाद, मैं इस तथ्य का लाभ उठाते हुए, नया इनपुट प्राप्त करने के लिए अधिकतम (इनपुट, 1) की गणना कर सकता हूं! = 1! फिर मुख्य लूप शुरू हो सकता है।

(EDIT: ट्राइसेप्स का एक पूरा गुच्छा "हीथ्रो टर्मिनलों 1, 2, 3" से 1 को अलग करके सेव किया गया है। इसे 7 (सिस्टर्स) में विभाजित करके इसे जेनरेट करने के बजाय। मैं -1 को जेनरेट करने के लिए एक सस्ता तरीका भी इस्तेमाल करता हूं। अगला चरण।)

मॉर्निंगटन क्रिसेंट में घटाव महंगा है (हालांकि ट्यूब से कम महंगा है)। चीजों को और अधिक कुशल बनाने के लिए, मैं एक पार्स 0 के नोट को ले कर एक उत्पन्न करता हूं और स्टोर करता हूं कि हैमरस्मिथ में लूप के लिए बहुत कुछ है।

---

मैंने इसमें कुछ महत्वपूर्ण काम किया है, लेकिन चूंकि यह मॉर्निंगटन क्रिसेंट (वास्तव में किसी भी भाषा में मेरा पहला प्रयास ) में गोल्फ के लिए मेरा पहला प्रयास है , मुझे उम्मीद है कि मैं यहां और वहां कुछ अनुकूलन से चूक गया। यदि आप स्वयं इस भाषा में प्रोग्रामिंग करने में रुचि रखते हैं (और आप ऐसा क्यों नहीं करेंगे?), Esoteric IDE - अपने डिबग मोड और वॉच विंडो के साथ - एक चाहिए!

Answer 27

Befunge - 2x20 = 40 वर्ण

0\:#v_# 1#<\$v *\<
    >:1-:#^_$>\:#^_$

यह एक ऐसा कार्य है जिसमें यह रैपराउंड का उपयोग नहीं करने वाले कोड का एक स्टैंडअलोन ब्लॉक है। आपको स्टैक के शीर्ष पर तर्क को रखना है फिर ऊपर-बाएं से दाएं दर्ज करें, फ़ंक्शन स्टैक के शीर्ष पर परिणाम के साथ नीचे-दाएं दाहिने से बाहर निकल जाएगा।

उदाहरण के लिए 125 के भाज्य की गणना करना

555**   0\:#v_# 1#<\$v *\<
            >:1-:#^_$>\:#^_$    .@

परीक्षण करना ०

0   0\:#v_# 1#<\$v *\<
        >:1-:#^_$>\:#^_$    .@

Comments

मुझे पता है कि यह बहुत पुराना है, लेकिन मुझे लगता है कि यह कुछ हद तक छोटा और तेज है: &:!#@_>:# 1# -# :# _$>\# :#* _$.@(जहां और इनपुट द्वारा प्रतिस्थापित किया जाना चाहिए)। यह 32 वर्ण / बाइट्स है

— FliiFe

Answer 28

जे - 6 अक्षर

*/>:i.

क्या यह गिनती है? मुझे पता है कि यह पहले के जे उदाहरण के समान है, लेकिन यह थोड़ा छोटा है :)

मैं J से एक शुरुआत कर रहा हूँ, लेकिन यह अब तक बहुत मज़ेदार है!

Answer 29

सी में (23 वर्ण)

यह GCC "सुविधा" का दुरुपयोग करता है जो अंतिम असाइनमेंट को रिटर्न के रूप में गिनता है यदि कोई रिटर्न निर्दिष्ट नहीं है।

f(a){a=a>0?f(a-1)*a:1;}

उचित सी में, 28 अक्षर

f(a){return a>0?f(a-1)*a:1;}

Comments

GCC "सुविधा" के लिए +1। मुझे लगता है कि जीसीसी भी एक ब्लॉक रिटर्न वैल्यू की अनुमति देता है (कुछ इस तरह से याद कर सकते हैं)0 == ({printf("Hello, world!"); 0;});

— YoYoYonnY

Answer 30

कोना ( 11 6)

*/1.+!

कश्मीर से काम करता है दाएँ-से-बाएँ (अधिकांश भाग के लिए), तो हम गणना x(एक सूची / से संख्या की सरणी बनाने 0के लिए x-1), जोड़ने 1(सूची पर्वतमाला यह करने 0के लिए x), तो सभी नंबरों को एक साथ गुणा। यदि यह गणना करने की आवश्यकता नहीं थी 125!, तो मैं .बगल में समाप्त करके 1 और बाइट बचा सकता था 1। किसी भी घटना में, 125! केवल मिलीसेकंड में गणना की जाती है:

  */1.+!125.
1.882677e+209

Comments

आपको इसकी बहुत अधिक आवश्यकता नहीं है। K की करी है, इसलिए पूरा उत्तर बन जाता है */1.+!: 6 बाइट्स।

— kirbyfan64sos

@ kirbyfan64sos: यह सच है और मैं इसे संपादित करूंगा। मुझे लगता है कि जब मैंने यह ~ 18 महीने पहले लिखा था, तब भी मैं हर चीज पर अड़ा रहा, जो कॉल करने योग्य होना चाहिए (यानी, फ़ंक्शन)।

— काइल कानोस