कैटलन नंबर

36

कातालान संख्या ( OEIS ) प्राकृतिक संख्या अक्सर साहचर्य में प्रदर्शित होने के एक दृश्य है।

Nth कैटलन नंबर डाइक शब्दों की संख्या है (कोष्ठक या कोष्ठक के संतुलित तार जैसे कि [[][]]; औपचारिक रूप से दो वर्णों का उपयोग करते हुए एक स्ट्रिंग के रूप में परिभाषित किया गया है और बी जैसे कि शुरुआत से शुरू होने वाले किसी भी विकल्प में संख्या की तुलना में अधिक या बराबर वर्ण होते हैं। बी अक्षर के, और पूरे स्ट्रिंग में लंबाई 2 एन के साथ एक और बी अक्षर की संख्या) है। Nth कैटलन संख्या (n> = 0 के लिए) को भी स्पष्ट रूप से परिभाषित किया गया है:

N = 0 से शुरू होकर, पहले 20 कैटलन नंबर हैं:

1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190...

चुनौती

एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें जो STDIN या स्वीकार्य विकल्प के माध्यम से एक गैर-नकारात्मक पूर्णांक n लेता है, और nth कैटलॉग संख्या को आउटपुट करता है। आपके प्रोग्राम को न्यूनतम 0-19 इनपुट के लिए काम करना चाहिए।

आई / ओ

इनपुट

आपके प्रोग्राम को STDIN, फ़ंक्शन आर्ग्यूमेंट्स या इस मेटा पोस्ट के अनुसार स्वीकार्य विकल्पों में से किसी एक से इनपुट लेना होगा । आप इनपुट की गई संख्या को उसके मानक दशमलव रिपोटेशन, यूरी प्रतिनिधित्व या बाइट्स के रूप में पढ़ सकते हैं।

  • यदि (और केवल अगर) आपकी भाषा एसटीडीआईएन या किसी स्वीकार्य विकल्प से इनपुट नहीं ले सकती है, तो यह प्रोग्राम में हार्डकोडेड वेरिएबल या उपयुक्त समकक्ष से इनपुट ले सकता है।

उत्पादन

आपका कार्यक्रम इस मेटा पोस्ट के अनुसार STDOUT, फ़ंक्शन परिणाम या किसी भी स्वीकार्य विकल्प के लिए nth कैटलॉग नंबर को आउटपुट करना होगा । आप कैटलन संख्या को उसके मानक दशमलव प्रतिनिधित्व, एकात्मक प्रतिनिधित्व या बाइट्स में आउटपुट कर सकते हैं।

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

यह उस भाषा को खोजने के बारे में नहीं है जो सबसे छोटी है। यह हर भाषा में सबसे छोटा कार्यक्रम खोजने के बारे में है। इसलिए, मैं एक उत्तर स्वीकार नहीं करूंगा।

इस चुनौती में, चुनौती से नई भाषाएं तब तक स्वीकार्य होती हैं जब तक उनका कार्यान्वयन होता है। यह अनुमति दी जाती है (और यहां तक ​​कि प्रोत्साहित किया जाता है) कि इस दुभाषिया को पहले से बिना पढ़ी हुई भाषा के लिए स्वयं लिखें। इसके अलावा, कोड-गोल्फ के सभी मानक नियमों का पालन ​​करना चाहिए। अधिकांश भाषाओं में प्रस्तुतियाँ बाइट्स में एक उपयुक्त preexisting एन्कोडिंग (आमतौर पर UTF-8) में बनाई जाएंगी। यह भी ध्यान दें कि एनटी कैटलन संख्या की गणना के लिए बिल्ट-इन की अनुमति है।

सूची

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  sequence  number-theory  combinatorics  balanced-string 
— एक स्पैगेटो
स्रोत
क्या हम एक पूर्णांक के बजाय एक फ्लोट प्रिंट / वापस कर सकते हैं?
— एलेक्स ए।
@AlexA। यह स्वीकार्य है।
— एक स्पेगेटो
क्या कोई टैग ओईस होगा ?
— वि।
1
@Vi। कुछ समय पहले इस बारे में एक मेटा चर्चा हुई थी और हम सहमत हुए थे कि ओइज़ अनावश्यक था
— एक
@Vi। यहाँ मेटा पोस्ट है: meta.codegolf.stackexchange.com/a/5546/8478 । कुछ तर्क के रूप में, आप OEIS- शैली की चुनौतियों को काफी मज़बूती से अनुक्रम और संख्या या संख्या-सिद्धांत के साथ पा सकते हैं । चाहे दिए गए अनुक्रम वास्तव में है OEIS में, पूरी तरह से चुनौती के लिए अप्रासंगिक है।
— मार्टिन एंडर

जवाबों:

26

सी, 78 52 39 34 33 बाइट्स

और भी सी जादू (धन्यवाद xsot):

c(n){return!n?:(4+6./~n)*c(n-1);}

?: एक GNU एक्सटेंशन है ।

इस बार नीचे पुनरावृत्ति का विस्तार करके (धन्यवाद xnor और थॉमस क्वा):

अभी तक एक और पुनरावृत्ति

c(n){return n?(4+6./~n)*c(n-1):1;}

-(n+1)द्वारा प्रतिस्थापित किया जाता है ~n, जो दो पूरक में बराबर है और 4 बाइट्स बचाता है।

एक समारोह के रूप में फिर से, लेकिन इस बार निम्नलिखित पुनरावृत्ति का शोषण:

पुनरावृत्ति होना

c(n){return n?2.*(2*n++-1)/n*c(n-2):1;}

c(n)नकारात्मक के लिए एक अनंत पुनरावृत्ति में प्रवेश करता है n, हालांकि यह इस चुनौती के लिए प्रासंगिक नहीं है।

फ़ंक्शन को कॉल करने के बाद से I / O कंसोल के लिए एक स्वीकार्य विकल्प लगता है:

c(n){double c=1,k=2;while(k<=n)c*=1+n/k++;return c;}

c(n)एक लेता है intऔर एक रिटर्न देता है int।

मूल प्रविष्टि:

main(n){scanf("%d",&n);double c=1,k=2;while(k<=n)c*=1+n/k++;printf("%.0f",c);}

परिभाषा की सीधे गणना करने के बजाय, सूत्र को फिर से लिखा गया है:

पुनर्लेखन

सूत्र मानता है n >= 2, लेकिन कोड भी n = 0और के लिए खाता n = 1है।

ऊपर सी गड़बड़ी में, nऔर kसूत्र के रूप में एक ही भूमिका है, जबकि cउत्पाद को जमा करता है। सभी गणना फ़्लोटिंग पॉइंट का उपयोग करके की जाती है double, जो लगभग हमेशा एक बुरा विचार है, लेकिन इस मामले में परिणाम n = 19 तक सही हैं, इसलिए यह ठीक है।

float 1 बाइट बचाई होगी, दुर्भाग्य से यह पर्याप्त सटीक नहीं है।

— स्टेफानो सैनफिलिपो
स्रोत
मैं अब इसका परीक्षण नहीं कर सकता, लेकिन मुझे लगता है कि आप इसे और छोटा कर सकते हैं:c(n){return!n?:(4+6./~n)*c(n-1);}
— xsot
धन्यवाद @xsot, मुझे नहीं पता था ?:! जाहिर है, यह एक ग्नू सी विस्तार है, लेकिन मुझे लगता है कि यह अभी भी योग्य है।
— स्टेफानो सैनफिलिपो
23

जेली , 4 बाइट्स

Ḥc÷‘

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

यह काम किस प्रकार करता है

Ḥc÷‘    Left argument: z

Ḥ       Compute 2z.
 c      Hook; apply combinations to 2z and z.
  ÷‘    Divide the result by z+1.
— डेनिस
स्रोत
1
"हुक 'का क्या अर्थ है? कैसे cमिलता है 2zऔर zइसके तर्क के रूप में?
— xnor
@xnor एक हुक का अर्थ है f (x, g (x)) जैसे कार्यों का मूल्यांकन। जब एक डायडिक फंक्शन होता है, उसके बाद एक अन्य डेडिक फंक्शन होता है, तो पार्सर पहले हुक के रूप में मूल्यांकन करता है।
— lirtosiast
5
@ डेनिस क्या वाकई 4 बाइट्स हैं? उन गैर-ASCII वर्णों के साथ, mothereff.in/byte-counter 9 बाइट्स कहता है
— लुइस
@LuisMendo शायद यह एक अलग एन्कोडिंग है
— अंडरग्राउंडोरेल
3
@LuisMendo जेली अपने स्वयं के, कस्टम एन्कोडिंग डिफ़ॉल्ट का उपयोग करता है, जहां प्रत्येक वर्ण एकल बाइट है। UTF-8 के साथ, स्रोत कोड वास्तव में 9 बाइट्स लंबा है।
— डेनिस
11

CJam, 12 बाइट्स

ri_2,*e!,\)/

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

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

व्याख्या

CJam में द्विपद गुणांक के लिए बिल्ट-इन नहीं है, और उन्हें तीन फैक्टरियल से कंप्यूटिंग करने में बहुत सारे बाइट्स लगते हैं ... इसलिए हमें इससे बेहतर कुछ करना होगा। :)

ri  e# Read input and convert it to integer N.
_   e# Duplicate.
2,  e# Push [0 1].
*   e# Repeat this N times, giving [0 1 0 1 ... 0 1] with N zeros and N ones.
e!  e# Compute the _distinct_ permutations of this array.
,   e# Get the number of permutations - the binomial. There happen to be 2n-over-n of
    e# of them. (Since 2n-over-n is the number of ways to choose n elements out of 2n, and
    e# and here we're choosing n positions in a 2n-element array to place the zeros in.)
\   e# Swap with N.
)/  e# Increment and divide the binomial coefficient by N+1.
— मार्टिन एंडर
स्रोत
यह वास्ताव में अच्छा है। +1
— एक स्पेगेटी
यह चतुर है। मैंने इसे तथ्यात्मक गणना के साथ आजमाया। यह केवल सामान्य तीन में से दो लेता है क्योंकि उनमें से दो समान हैं। यह अभी भी ri_2*m!1$m!_*/\)/मेरे कार्यान्वयन में 17 बाइट्स ( ) का उपयोग करता है। केवल अच्छी बात यह है कि यह बहुत तेज है। :)
— रेटो कोराडी
11

गणितज्ञ, १६ १३ बाइट्स

CatalanNumber

बिल्ट-इन, एमिरिट फेलस: /

गैर-निर्मित संस्करण (21 बाइट्स):

Binomial[2#,#]/(#+1)&

एक द्विपद-कम संस्करण (25 बाइट्स):

Product[(#+k)/k,{k,2,#}]&
— एक स्पैगेटो
स्रोत
10

टीआई-बेसिक, 11 बाइट्स

(2Ans) nCr Ans/(Ans+1

अजीब बात है, एनसीआर में गुणन की तुलना में अधिक पूर्वता है।

— lirtosiast
स्रोत
10

पायथन 3, 33 बाइट्स

f=lambda n:0**n or(4+6/~n)*f(n-1)

पुनरावृत्ति का उपयोग करता है

f(0) = 1
f(n) = (4-6/(n+1)) * f(n-1)

0 के आधार मामले को संभाला जाता है 0**n or, जो 1तब बंद हो जाता है जब n==0और अन्यथा दाईं ओर पुनरावर्ती अभिव्यक्ति का मूल्यांकन करता है। बिटवाइज ऑपरेटर ~n==-n-1हर को छोटा करता है और परेंस को बचाता है।

पायथन 3 का उपयोग इसके फ्लोट डिवीजन के लिए किया जाता है। पायथन 2 लिखने के लिए एक और बाइट के साथ एक ही कर सकता था 6.।

— XNOR
स्रोत
n<1बजाय इसके क्यों नहीं 0**n?
— feersum
@ Faersum यह बजाय के Trueलिए लौटता n==0है 1। बेशक, True == 1लेकिन True is not 1यह अलग तरह से प्रिंट करता है। मुझे उम्मीद है कि यह अनुमति नहीं दी जाएगी। क्या आप जानते हैं कि क्या हमारे पास इस पर शासन है?
— xnor
मेरा मानना ​​है कि यह ठीक है। isinstance(True, int) is Trueआख़िरकार।
— १
2
मुझे लगता है कि यह अभी भी सामान्य मामला और यहाँ moreso में iffy है जहाँ चुनौती एक संख्या या उसके प्रतिनिधित्व के रूप में आउटपुट को निर्दिष्ट करती है। लेकिन, @quartata
— xnor
7

जे, 8 बाइट्स

>:%~]!+:

यह एक मोनडिक ट्रेन है; यह (2x nCr x) / (x + 1) सूत्र का उपयोग करता है। इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत
7

पी एल, 4 बाइट्स

☼ç▲÷

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

व्याख्या

Pl में, फ़ंक्शन स्टैक से अपने तर्क लेते हैं और परिणाम को स्टैक पर वापस धकेलते हैं। आम तौर पर जब स्टैक पर पर्याप्त तर्क नहीं होते हैं, तो फ़ंक्शन केवल चुपचाप विफल हो जाता है। हालाँकि, कुछ विशेष तब होता है जब स्टैक पर तर्कों की मात्रा फ़ंक्शन की समता से एक है - इनपुट चर _को तर्क सूची में जोड़ा जाता है:

☼ç▲÷

☼      double: takes _ as the argument since there is nothing on the stack
 ç     combinations: since there is only one item on the stack (and arity is 2), it adds _ to the argument list (combinations(2_,_))
  ▲    increment last used var (_)
   ÷   divide: adds _ to the argument list again

वास्तव में, यह छद्मकोश है:

divide(combinations(double(_),_),_+1);
— एक स्पैगेटो
स्रोत
6

सेसोस , 94 86 68 बाइट्स

संस्करण 1 से संस्करण 2 तक भाज्य-एर को बदलकर 8 बाइट्स।

n!(n+1)!एक कदम में कंप्यूटिंग द्वारा 18 बाइट्स । लगभग डेनिस की मौलिकता के परीक्षण एल्गोरिथ्म से प्रेरित है ।

Hexdump:

0000000: 16f8de a59f17 a0ebba 7f4cd3 e05f3f cf0fd0 a0ebde  ..........L.._?......
0000015: b1c1bb 76fe18 8cc1bb 76fe1c e0fbda 390fda bde3d8  ...v.....v.....9.....
000002a: 000fbe af9d1b b47bc7 cfc11c b47bc7 cff1fa e07bda  .......{.....{.....{.
000003f: 39e83e cf07                                       9.>..

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

सूत्र का उपयोग करता है a(n) = (2n)! / (n!(n+1)!)।

  • भाज्य-एर: संस्करण 1 (इन-प्लेस, निरंतर मेमोरी), संस्करण 2 (इन-प्लेस, लीनियर मेमोरी)
  • गुणक: यहाँ (जगह में, निरंतर स्मृति)
  • विभक्त: यहाँ (यदि विभाज्य नहीं है तो रुकना नहीं)

कोडांतरक

set numin
set numout
get
jmp,sub 1,fwd 1,add 1,fwd 2,add 2,rwd 3,jnz
fwd 1,add 1
jmp
  jmp,sub 1,rwd 1,add 1,rwd 1,add 1,rwd 1,add 1,fwd 3,jnz
  rwd 1,sub 1,rwd 1,sub 1,rwd 1
  jmp,sub 1,fwd 3,add 1,rwd 3,jnz
  fwd 1
jnz
fwd 3
jmp
  jmp
    sub 1,rwd 1
    jmp,sub 1,rwd 1,add 1,rwd 1,add 1,fwd 2,jnz
    rwd 2
    jmp,sub 1,fwd 2,add 1,rwd 2,jnz
    fwd 3
  jnz
  rwd 1
  jmp,sub 1,jnz
  rwd 1
  jmp,sub 1,fwd 2,add 1,rwd 2,jnz
  fwd 3
jnz 
fwd 1
jmp
  jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
  fwd 1,sub 1,fwd 1
  jmp,sub 1,rwd 2,add 1,fwd 2,jnz
  rwd 1
jnz
rwd 2
jmp
  jmp
    sub 1,fwd 1
    jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
    fwd 2
    jmp,sub 1,rwd 2,add 1,fwd 2,jnz
    rwd 3
  jnz
  fwd 1
  jmp,sub 1,jnz
  fwd 1
  jmp,sub 1,rwd 2,add 1,fwd 2,jnz
  rwd 3
jnz 
fwd 1
jmp
  fwd 1,add 1,rwd 3
  jmp,sub 1,fwd 1,add 1,fwd 1,sub 1,rwd 2,jnz
  fwd 1
  jmp,sub 1,rwd 1,add 1,fwd 1,jnz
  fwd 1
jnz
fwd 1
put

ब्रेनफक बराबर

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

[->+>>++<<<]>+
[[-<+<+<+>>>]<-<-<[->>>+<<<]>]>>>
[[-<[-<+<+>>]<<[->>+<<]>>>]<[-]<[->>+<<]>>>]>
[[->+>+<<]>->[-<<+>>]<]<<
[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>
[>+<<<[->+>-<<]>[-<+>]>]>
— लीक नन
स्रोत
5

गंभीरता से, 9 बाइट्स

,;;u)τ╣E\

हेक्स डंप:

2c3b3b7529e7b9455c

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

स्पष्टीकरण:

,                   Read in evaluated input n
 ;;                 Duplicate it twice
   u)               Increment n and rotate it to bottom of stack
     τ╣             Double n, then push 2n-th row of Pascal's triangle
       E            Look-up nth element of the row, and so push 2nCn
        \           Divide it by the n+1 below it.
— quintopia
स्रोत
आप इस तथ्य का फायदा उठाकर एक बाइट को बचा सकते हैं कि पास्कल के त्रिकोण की पंक्तियां सममित हैं, इसलिए 2nवें पंक्ति का माध्यिका है C(2n,n)। इस प्रकार: ,;u@τ╣║/8 बाइट्स के लिए।
— मेगो
क्या? 2nn 2nth पंक्ति की अधिकतम सीमा नहीं है?
— क्विंटोपिया
हाँ, और यह मंझला भी है। तो, दोनों ║और Mकाम करेगा।
— मेगो
अगर मैं कुछ माध्यिका और अधिकतम दोनों के मामले में हो सकता है कि सूची एक ही नंबर नहीं है, तो मैं आपके मध्यस्थ के कार्यान्वयन के बारे में चिंता करता हूं। यदि आपका मतलब "सूची के बीच में" है, तो आप इसके लिए एक अलग नाम चुन सकते हैं ...
— क्विंटोपिया
हां, यह सूची के बीच में है। सॉर्ट की गई सूचियों के लिए, यह विशिष्ट सांख्यिकीय मंझला है, लेकिन बिना सूचीबद्ध सूचियों के लिए यह सिर्फ मध्य (या औसतन 2 मध्यम तत्व) है
— Mego
4

जावास्क्रिप्ट (ईएस 6), 24 बाइट्स

पायथन उत्तर के आधार पर ।

c=x=>x?(4+6/~x)*c(x-1):1

यह काम किस प्रकार करता है

c=x=>x?(4+6/~x)*c(x-1):1
c=x=>                     // Define a function c that takes a parameter x and returns:
     x?               :1  //  If x == 0, 1.
       (4+6/~x)           //  Otherwise, (4 + (6 / (-x - 1)))
               *c(x-1)    //  times the previous item in the sequence.

मुझे लगता है कि यह सबसे छोटा हो सकता है, लेकिन सुझावों का स्वागत है!

— ETHproductions
स्रोत
4

जूलिया, 23 बाइट्स

n->binomial(2n,n)/(n+1)

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और एक फ्लोट देता है। यह मूल द्विपद सूत्र का उपयोग करता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=n->...।

— एलेक्स ए।
स्रोत
4

मतलाब, 35 25 बाइट्स

@(n)nchoosek(2*n,n)/(n+1)

ऑक्टेव, 23 बाइट्स

@(n)nchoosek(2*n,n++)/n
— costrom
स्रोत
2
आप @(n)फ़ंक्शन के बजाय उपयोग कर सकते हैं , अनाम फ़ंक्शन ठीक हैं।
— FryAmTheEggman
मैंने यहाँ कई उत्तर देखे हैं इससे पहले कि कार्यक्षेत्र चर का उपयोग किया जा रहा था (इसका अर्थ है कि वे पहले से ही उपयोगकर्ता द्वारा कहीं और सेट किए गए थे)। MATLAB / ऑक्टेव में लिपियों को भी सरल स्निपेट के रूप में प्रदर्शित किया जा सकता है। मैं इसे अभी के लिए एक समारोह में फिर से बनाया है ...
— costrom
1
आप पोस्ट-इंक्रीमेंट करके 2 और बाइट्स मार सकते हैं n:@(n)nchoosek(2*n,n++)/n
— बीकर
@ टिप के लिए धन्यवाद! यह केवल ऑक्टेव में काम करता है, न कि मैटलैब पर, इसलिए मैंने इसे अलग कर दिया है
— कॉस्ट्रोमन
@ कॉस्ट्रोम यह दिलचस्प है। मुझे लगता .../++nहै कि या तो काम नहीं करता है। : /
— बीकर
4

S, 3 चार्ट / 6 बाइट्स

Мƅï

Try it here (Firefox only).

बिल्‍डरों ने फूट डाला! इसलिए मुझे खुशी है कि मैंने जल्द ही गणित लागू किया।

बोनस समाधान, 12 चार्ट / 19 बाइट्स

Мơ 2*ï,ï)/⧺ï

Try it here (Firefox only).

एय! 19 वां बाइट!

छद्म- ES6 के रूप में मूल्यांकन:

nchoosek(2*input,input)/(input+1)
— मामा फन रोल
स्रोत
3

हास्केल, 27 बाइट्स

g 0=1
g n=(4-6/(n+1))*g(n-1)

एक पुनरावर्ती सूत्र। वहाँ एक तरह से parens को बचाने के लिए मिल गया है ...

सीधे उत्पाद लेने में 2 बाइट्स लंबा था:

g n=product[4-6/i|i<-[2..n+1]]
— XNOR
स्रोत
आपका कोड स्टडिन से कहां तक ​​पढ़ता है या स्टडआउट को लिखता है?
— user2845840
2
@ user2845840 कार्य कल्पना में जुड़े स्वीकार्य विकल्पों में से एक हैं।
— xnor
g(n-1)=> g$n-1एक बाइट बचाता है। संपादित करें: वास्तव में यह काम नहीं करता है क्योंकि तब सूत्र की व्याख्या की जाती है (...*g) (n-1)।
— मोनिका
3

दिल्लोग एपीएल, 9 बाइट्स

+∘1÷⍨⊢!+⍨

यह एक मोनडिक ट्रेन है; यह (2x nCr x) / (x + 1) सूत्र का उपयोग करता है। इसे यहाँ ऑनलाइन आज़माएँ ।

— lirtosiast
स्रोत
3

सी, 122 121 119 108 बाइट्स

main(j,v)char**v;{long long p=1,i,n=atoi(v[1]);for(j=0,i=n+1;i<2*n;p=(p*++i)/++j);p=n?p/n:p;printf("%d",p);}

मैंने विंडोज़ साइबरिन वातावरण में संकलित करने के लिए gcc (GCC) 3.4.4 (cygming special, gdc 0.12, dmd 0.125 का उपयोग किया) का उपयोग किया। कमांड लाइन पर इनपुट आता है। यह शर्लक 9 के पायथन समाधान के समान है, लेकिन छोरों को अतिप्रवाह से बचने और 20 वें कैटलन नंबर (n = 19) तक आउटपुट प्राप्त करने के लिए एक में जोड़ा जाता है।

— cleblanc
स्रोत
1
आप mainएक बाइट को बचाने के लिए परिभाषा में अल्पविराम के बाद स्थान को हटा सकते हैं ।
— एलेक्स ए।
अच्छा, मैं अब पोस्ट को संपादित
— करूंगा
आप char**vइसके बजाय 2 और बाइट्स बचा सकते हैं char *v[]। (पहले की जगह की *जरूरत नहीं है, और प्रकार समतुल्य हैं।)
— Mat
यकीन है कि काफी काम करता है। धन्यवाद मैट
— क्लीबैंक
यह इसे छोटा करने के लिए टिप्स पेज से कुछ सामान का उपयोग करता है। ध्यान दें कि हालांकि Ideone के लिए मैंने एक मान को हार्डकोड किया था n।
— FryAmTheEggman 21
3

जवागोनी , 223 बाइट्स

public class C{public static int f(int a,int b){try{int z=1/(b-a);}catch(Exception e){return 1;}return a*f(a+1,b);}public static void main(String[]s){int m=Integer.parseInt(s[0])+1;System.out.println(f(m,2*m-1)/f(1,m)/m);}}

पूरी तरह से विस्तारित:

public class C {
    public static int f(int a,int b){
        try {
            int z=1/(b-a);
        } catch (Exception e){
            return 1;
        }
        return a*f(a+1,b);
    }
    public static void main(String[] s){
        int m=Integer.parseInt(s[0])+1;
        System.out.println(f(m,2*m-1)/f(1,m)/m);
    }
}
— flawr
स्रोत
Esolangs की प्रविष्टि से कोई फर्क नहीं पड़ता - जब तक आप प्रतियोगिता से पहले बने एक दुभाषिया का उपयोग करते हैं, यह सब अच्छा और मान्य है।
— Addison Crump
वैसे भी जीतने वाला नहीं है ^ ^
— दोष
यह जावा है, इसलिए हाँ।
— R
1
@ रिकर खैर, यह जावा से भी बदतर है।
— जैकब
2

जाप, 16 बाइट्स

यहां तक ​​कि गणितज्ञ भी छोटा है। :-/

U*2ª1 o àU l /°U

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

अपुष्ट और व्याख्या

U*2ª 1 o àU l /° U
U*2||1 o àU l /++U

         // Implicit: U = input number
U*2||1   // Take U*2. If it is zero, take 1.
o àU     // Generate a range of this length, and calculate all combinations of length U.
l /++U   // Take the length of the result and divide by (U+1).
         // Implicit: output result

पुनरावर्ती सूत्र के आधार पर वैकल्पिक संस्करण:

C=_?(4+6/~Z *C$(Z-1):1};$C(U
— ETHproductions
स्रोत
2

विटसी , 13 बाइट्स

VV2*FVF/V1+F/
V              Capture the input as a final global variable.
 V             Push it back.
  2*           Multiply it by 2
    F          Factorial.
     VF        Factorial of the input.
       /       Divide the second to top by the first.
        V1+    1+input
           F   Factorial.
            /  Divide.

यह विटसी में एक समारोह है । इसे एक प्रोग्राम कैसे बनाएं जो यह करता है, आप पूछें? संघात करना N। सी:

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

— एडिसन क्रम्प
स्रोत
2

मिल्की वे 1.5.14 , 14 बाइट्स

':2K;*Ny;1+/A!

व्याख्या

'               # read input from the command line
 :              # duplicate the TOS
  2      1      # push integer to the stack
   K            # push a Pythonic range(0, TOS) as a list
    ;   ;       # swap the TOS and the STOS
     *          # multiply the TOS and STOS
      N         # push a list of the permutations of the TOS (for lists)
       y        # push the length of the TOS
          +     # add the STOS to the TOS
           /    # divide the TOS by the STOS
            A   # push the integer representation of the TOS
             !  # output the TOS

या, वैकल्पिक रूप से, बहुत कुछ अधिक कुशल संस्करण:

मिल्की वे 1.5.14 , 22 बाइट्स

'1%{;K£1+k1-6;/4+*}A!

व्याख्या

'                      # read input from the command line
 1     1  1 6  4       # push integer to the stack
  %{  £           }    # for loop
    ;        ;         # swap the TOS and the STOS
     K                 # push a Pythonic range(0, TOS) as a list
        +       +      # add the TOS and STOS
         k             # push the negative absolute value of the TOS
           -           # subtract the STOS from the TOS
              /        # divide the TOS by the STOS
                 *     # multiply the TOS and the STOS
                   A   # push the integer representation of the TOS
                    !  # output the TOS

प्रयोग

python3 milkyway.py <path-to-code> -i <input-integer>
— Zach गेट्स
स्रोत
2

क्लोजर / क्लोजुरस्क्रिप्ट, 53 बाइट्स

(defn c[x](if(= 0 x)1(*(c(dec x))(- 4(/ 6(inc x))))))

क्लोजुर में गोल्फ के लिए बहुत निराशा हो सकती है। यह बहुत पठनीय है, जबकि अभी भी बहुत पठनीय है, लेकिन निफ्टियर की कुछ विशेषताएं वास्तव में क्रियात्मक हैं। (inc x)की तुलना में अधिक मुहावरेदार है (+ x 1)और "लगता है" अधिक संक्षिप्त है, लेकिन वास्तव में पात्रों को नहीं बचाता है। और संचालन की श्रृंखलाएं लिखना अच्छा है (->> x inc (/ 6) (- 4)), लेकिन यह वास्तव में इसे बदसूरत तरीके से करने की तुलना में अधिक लंबा है।

— MattPutnam
स्रोत
2

प्रोलॉग, 42 बाइट्स

पुनरावृत्ति का उपयोग करना लगभग हमेशा प्रोलॉग के साथ जाने का तरीका है।

कोड:

0*1.
N*X:-M is N-1,M*Y,X is(4-6/(N+1))*Y.

उदाहरण:

19*X.
X = 1767263190.0

इसे यहाँ ऑनलाइन आज़माएँ

— Emigna
स्रोत
क्या आप *यहां प्रतीक को फिर से परिभाषित कर रहे हैं?
— पाओलो एबरमन
@ Pa @loEbermann बिल्कुल नहीं। मैं * नामक एक नए डायडिक विधेय को परिभाषित कर रहा हूं। मैं अभी भी नियमित अंकगणित का उपयोग कर सकता हूं। M * Y के ऊपर के कार्यक्रम में मेरी परिभाषित भविष्यवाणी है जबकि (4-6 / (N + 1)) * Y नियमित गुणा है।
— इमिग्ना
यह पी (एक्स, वाई) के रूप में लिखने से थोड़ा कम है: - जो कोड गोल्फ के लिए अच्छा है।
— इमिग्ना
2

सीलोन, 60 बाइट्स

Integer c(Integer n)=>(1:n).fold(1)((p,i)=>p*(n+i)/i)/(n+1);

यह सी 30 तक काम करता है , क्योंकि सीलोन के इंटेगर को 64-बिट संख्या (सी 31 के अतिप्रवाह पर हस्ताक्षर किए गए हैं , -4050872099593203 के रूप में गणना की जाएगी)।

मुझे नहीं पता कि सीलोन में कोई अंतर्निहित उच्च गणितीय कार्य है, लेकिन फिर सही पैकेज का आयात करना संभवत: केवल पैर से गणना करने से अधिक लंबा होगा।

// Catalan number C_n
//
// Question:  http://codegolf.stackexchange.com/q/66127/2338
// My answer: http://codegolf.stackexchange.com/a/66425/2338

Integer c(Integer n) =>
        // sequence of length n, starting at 1.
        (1:n)
        // starting with 1, for each element i, multiply the result
        // of the previous step by (n+i) and then divide it by i.
    .fold(1)((p, i) => p * (n + i) / i)
        // divide the result by n+1.
        / (n + 1);
— पाओलो एबरमन
स्रोत
2

आर, 35 28 16 बाइट्स

numbers::catalan

संपादित करें: संख्या पैकेज बिलिन का उपयोग करें।

— mnel
स्रोत
2

05AB1E , 6 बाइट्स

Dxcr>/

स्पष्टीकरण:

Code:     Stack:               Explanation:

Dxcr>/

D         [n, n]               # Duplicate of the stack. Since it's empty, input is used.
 x        [n, n, 2n]           # Pops a, pushes a, a * 2
  c       [n, n nCr 2n]        # Pops a,b pushes a nCr b
   r      [n nCr 2n, n]        # Reverses the stack
    >     [n nCr 2n, n + 1]    # Increment on the last item
     /    [(n nCr 2n)/(n + 1)] # Divides the last two items
                               # Implicit, nothing has printed, so we print the last item
— अदनान
स्रोत
2

आर, 28 बाइट्स

पैकेज का उपयोग नहीं कर रहा है, इसलिए पिछले उत्तर की तुलना में थोड़ा लंबा है 

choose(2*(n=scan()),n)/(n+1)
— फ़्रेडरिक
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.