35

एकरमन फ़ंक्शन कुल, कम्प्यूटेशनल फ़ंक्शन के सबसे सरल उदाहरणों में से एक होने के लिए उल्लेखनीय है जो कि आदिम नहीं है।

हम A(m,n)दो nonnegative पूर्णांकों में जहां लेने की परिभाषा का उपयोग करेंगे

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

आप लागू कर सकते हैं

एक नामित या अनाम फ़ंक्शन इनपुट के रूप में दो पूर्णांक ले रहा है, एक पूर्णांक लौटा रहा है, या
एक प्रोग्राम जो STDIN पर दो स्पेस- या न्यूलाइन से अलग किए गए पूर्णांकों को ले रहा है, परिणामस्वरूप STDOUT को प्रिंट कर रहा है।

यदि आप मौजूद हैं, तो आप लाइब्रेरी से एक एकरमन फ़ंक्शन या हाइपरेक्सपॉइंटमेंट फ़ंक्शन का उपयोग नहीं कर सकते हैं, लेकिन आप किसी अन्य लाइब्रेरी से किसी अन्य फ़ंक्शन का उपयोग कर सकते हैं। नियमित घातांक की अनुमति है।

आपका कार्य A(m,n)एक मिनट से भी कम समय में m n 3 और n less 10 का मान ज्ञात करने में सक्षम होना चाहिए । इसे कम से कम किसी अन्य इनपुट पर सैद्धांतिक रूप से समाप्त होना चाहिए : अनंत स्टैक स्पेस, एक देशी बिगिंट प्रकार, और समय की एक लंबी अवधि के लिए, यह जवाब लौटा देगा। संपादित करें: यदि आपकी भाषा में एक डिफ़ॉल्ट पुनरावृत्ति की गहराई है जो बहुत प्रतिबंधक है, तो आप उसे किसी भी वर्ण लागत पर पुन: कॉन्फ़िगर कर सकते हैं।

कम से कम वर्णों के साथ सबमिशन जीतता है।

आपके उत्तर की जांच करने के लिए यहां कुछ मान दिए गए हैं:

  A  | n=0     1     2     3     4     5     6     7     8     9    10
-----+-----------------------------------------------------------------
 m=0 |   1     2     3     4     5     6     7     8     9    10    11
   1 |   2     3     4     5     6     7     8     9    10    11    12
   2 |   3     5     7     9    11    13    15    17    19    21    23
   3 |   5    13    29    61   125   253   509  1021  2045  4093  8189
   4 |  13 65533   big   really big...

code-golf function recursion

— algorithmshark
स्रोत

15

इससे पहले कैसे नहीं पूछा गया ??

— केल्विन के शौक

9

मुझे लगता है कि यह सबसे तेज़ कोड

— Sp3000

22

डाउनवोटिंग क्योंकि यहां कोई चुनौती नहीं है। स्पष्ट उत्तर - बस भोलेपन से कार्य को अपनी परिभाषा के अनुसार लागू करना - हमेशा सबसे अच्छा उत्तर होने वाला है। तो सवाल सिर्फ यह है कि "किस भाषा में एकरमैन के कार्य की स्पष्ट अभिव्यक्ति में सबसे कम अक्षर हैं?" सच्चा विजेता प्रोग्रामिंग भाषा है, न कि वह व्यक्ति जिसने इसमें स्पष्ट कार्यक्रम लिखा है।

— डेविड रिचेर्बी

1

क्या होगा अगर मेरी भाषा की पुनरावृत्ति सीमा गणना करने के लिए बहुत कम है A(3,8)और अन्य लोगों की तरह भोली है? क्या मुझे गैर-पुनरावृत्ति समाधान के साथ आना है, या क्या मैं इन मामलों में सिर्फ "अनंत स्टैक स्पेस मान सकता हूं"? मैं काफी हद तक निश्चित हूं, यह एक मिनट के भीतर समाप्त हो जाएगा।

— मार्टिन एंडर

5

@DavidRicherby "स्पष्ट उत्तर [...] हमेशा सबसे अच्छा उत्तर होने वाला है।" यह सभी भाषाओं के लिए सही नहीं है। मैं अपनी घरेलू भाषा में केवल एक उदाहरण के लिए थोड़ा गंदा महसूस करता हूं, लेकिन एकरमैन को व्यक्त करने के कई तरीके हैं और कुछ भाषाओं में आप उस तथ्य का उपयोग करके बचत प्राप्त कर सकते हैं। चुनौती के लिए मेरा इरादा यही था।

— एल्गोरिथमशार्क

7

अजगर , १ ९

DaGHR?atG?aGtHH1GhH

परिभाषित करता है a, जो एकरमन फ़ंक्शन के रूप में काम करता है। ध्यान दें कि यह गणना करने के लिए आज तक अनुमति दी गई आधिकारिक पाइथ संकलक की तुलना में एक उच्च पुनरावर्तन गहराई की आवश्यकता है a 3 10, इसलिए मैंने पुनरावृत्ति की गहराई बढ़ा दी। यह केवल कंपाइलर के लिए भाषा में बदलाव नहीं है।

परीक्षा:

$ time pyth -c "DaGHR?atG?aGtHH1GhH           ;a 3 10"
8189

real    0m0.092s
user    0m0.088s
sys     0m0.000s

स्पष्टीकरण:

DaGH                     def a(G,H):
    R                    return
    ?          G                (if G:
     atG                              (a(G-1,
        ?    H                               (if H:
         aGtH                                      a(G,H-1)
              1                               else:1)
                hH               else:H+1)

अनिवार्य रूप से, यह Gएच + 1 को फिर से तैयार करने या वापस करने के सत्य मूल्य पर पहली स्थिति है । यदि यह आवर्ती है, तो पहला तर्क हमेशा G-1 है, और यह सत्य मान पर है Hकि क्या a(G,H-1)दूसरे तर्क के 1रूप में उपयोग करना है, या दूसरे तर्क के रूप में उपयोग करना है।

— isaacg
स्रोत

आधुनिक Pyth में मैं आप कम या ज्यादा परिवर्तन कर सकते हैं लगता है (मैं इस इस चुनौती के बाद जोड़ दिया गया मान) DaGHRको Mऔर aकरने के लिए g। ( ?परिवर्तन के लिए तर्कों का क्रम ?)

— लिन

@ मौरिस हां, आप Mइसके बजाय उपयोग कर सकते हैं , और हां, ?तर्क क्रम बदल गया। यह अब शर्त है, सच है, झूठ है। यह सच था, हालत, झूठी थी।

— isaacg

@ लियन फन पायथ इतिहास के तथ्य: इस सवाल ने वास्तव में इसहाक को प्रभावित करने के लिए प्रभावित किया है (कम से कम) पायथ के बारे में दो बातें: पुनरावृत्ति सीमा और परिवर्तनM !

— फ्राईमईएग्गमैन

23

हास्केल, 35

0%n=1+n
m%n=iterate((m-1)%)1!!(n+1)

यह ऑपरेटर फ़ंक्शन को परिभाषित करता है %।

कि देख कर इस काम करता है m%n(जहां aएकरमैन समारोह है) अशून्य के लिए mकिया जाता है (m-1)%लागू किया n+1गुना 1। उदाहरण के लिए, जो है , उसे 3%2परिभाषित किया 2%(3%1)गया है 2%(2%(3%0))और यह है2%(2%(2%1))

— गर्वित हेकलर
स्रोत

बहुत बुरा मैं पूर्ववर्तीता 0%nके n+1कारण उपयोग नहीं कर सकता

— गर्व हैस्केलर

मैं क्या गलत कर रहा हूं?

— डेनिस

वाह, यह इतने लंबे समय के लिए गलत है, और कोई भी, खुद सहित, देखा? अच्छा कार्य। इसलिए ऐसा लगता है कि मैंने गलती से जवाब के पहले संस्करण की नकल की, जो दोषपूर्ण था, शायद गलती से या क्योंकि मुझे लगा कि यह काम कर रहा है।

— गर्वित हैकेलर

12

गोल्फस्क्रिप्ट (30)

{1$1>{1\){1$(\A}*\;}{+)}if}:A;

ऑनलाइन डेमो

बिना 1>(कौन से विशेष-मामलों में A(1, n)) कंप्यूटर A(3, 10)पर गणना करने में मुझे 9 मिनट लगते हैं , मैंने इसे परखा है। उस विशेष मामले के साथ यह काफी तेज है कि ऑनलाइन डेमो 10 सेकंड से कम समय लेता है।

ध्यान दें कि यह परिभाषा का भोला अनुवाद नहीं है। पुनरावृत्ति गहराई से घिरा हुआ है m।

विच्छेदन

{             # Function boilerplate
  1$          # Get a copy of m: stack holds m n m
  1>{         # (Optimisation): if m is greater than 1
    1         #   Take this as the value of A(m, -1)
    \){       #   Repeat n+1 times:
              #     Stack: m A(m, i-1)
      1$(\    #     Stack: m m-1 A(m, i-1)
      A       #     Stack: m A(m, i)
    }*
    \;        #   Lose that unwanted copy of m
  }{          # Else
    +)        #   A(m in {0, 1}, n) = m + n + 1
  }if
}:A;          # Function boilerplate

— पीटर टेलर
स्रोत

CJam में, आपको आवश्यकता नहीं होगी 1>। हटाने (और बदलने के बाद ifकरने के लिए ?), कंप्यूटिंग 3 10 Aजावा दुभाषिया के साथ छह सेकंड ऑनलाइन दुभाषिया के साथ 110 सेकंड और ले जाता है।

— डेनिस

7

बाइनरी लैम्ब्डा कैलकुलस , 54 बिट्स = 6.75 बाइट्स

Hexdump:

00000000: 1607 2d88 072f 68                        ..-../h

बाइनरी:

000101100000011100101101100010000000011100101111011010

यह λ m है । m (λ g । λ n । g ( n g 1)) (λ n । λ f । λ x । λ x । f ( n f x )), जहाँ सभी संख्याओं को चर्च अंकों के रूप में दर्शाया जाता है ।

— एंडर्स कसीगोर
स्रोत

6

जावास्क्रिप्ट, ईएस 6, 41 34 बाइट्स

f=(m,n)=>m?f(m-1,!n||f(m,n-1)):n+1

इसे एक नवीनतम फ़ायरफ़ॉक्स कंसोल में चलाएं और यह एक फ़ंक्शन बनाएगा, fजिसे आप कॉल कर सकते हैं जैसे mऔर इसके विभिन्न मूल्यों के साथn

f(3,2) // returns 29

या

एक नवीनतम फ़ायरफ़ॉक्स में नीचे दिए गए कोड को आज़माएं

f=(m,n)=>m?f(m-1,!n||f(m,n-1)):n+1

B.onclick=_=>alert(f(+M.value, +N.value))

#M,#N{max-width:15px;border: 1px solid;border-width:0 0 1px 0}

<div>f(<input id=M />,<input id=N />)</div><br><button id=B>Evaluate</button>

स्निपेट का विस्तार करें

— अनुकूलक
स्रोत

क्रोम में 0,1 के साथ इसका परीक्षण करने से कोई परिणाम नहीं मिलता है।

— नजला

3

Pl पढ़ा, यह केवल ES42 के कारण नवीनतम फ़ायरफ़ॉक्स में काम करता है

— ऑप्टिमाइज़र

वाह ... हमारे पास 4 व्यावहारिक रूप से समान जेएस समाधान हैं, सभी 34 बाइट्स में हैं। मैंने ऐसा पहले कभी नहीं देखा।

— ETHproductions

6

पायथन 2.7.8 - 80, 54, 48, 46 45

A=lambda m,n:m and A(m-1,n<1or A(m,n-1))or-~n

(एक्सनोर का श्रेय!)

अधिक पठनीय, लेकिन 1 और चरित्र के साथ:

A=lambda m,n:n+(m<1or A(m-1,n<1or A(m,n-1))-n)

ऐसा नहीं है कि मुझे sys.setrecursionlimit(10000)एक परिणाम प्राप्त करने के लिए सेट करना पड़ा A(3,10)। तार्किक अनुक्रमण का उपयोग करते हुए आगे की गोल्फिंग नाटकीय रूप से बढ़ती हुई पुनरावृत्ति की गहराई के कारण काम नहीं करती थी।

— फ़ाल्को
स्रोत

मुझे इस पर एक सिंटैक्स त्रुटि मिलती है 1else। प्रारंभ पत्र eपार्सर के लिए परेशानी का कारण बनता है क्योंकि संख्याओं को लिखा जा सकता है 1e3।

— xnor

कुछ चरों को सहेजा गया and/or:A=lambda m,n:m and A(m-1,n<1or A(m,n-1))or-~n

— xnor

@ xnor: टिप के लिए धन्यवाद! पार्सिंग अंक के मुद्दे के लिए इस चर्चा को देखें । अजगर 2.7.8 स्वीकार करता है 1else, अधिकांश अन्य संस्करण नहीं हैं।

— फाल्को

सूचक के बारे में धन्यवाद 1else; यह मुझे यहाँ और शायद अन्य स्थानों पर एक चार को निचोड़ने देता है । लेकिन यह संस्करण विशिष्ट है! अजगर 2.7.4 इसकी अनुमति नहीं देता है। क्या आप 2.7.8 के साथ ऑनलाइन संस्करण का उपयोग कर रहे हैं या मुझे इसे डाउनलोड करना होगा?

— xnor

@xnor: यह एक ऑफ़लाइन स्थापना है। ideone.com , उदाहरण के लिए, के 1elseरूप में अच्छी तरह से पार्स करने में विफल रहता है ।

— फाल्को

6

जे - 26 चार

($:^:(<:@[`]`1:)^:(0<[)>:)

एकरमैन की एक वैकल्पिक, अधिक कार्यात्मक परिभाषा है:

Ack 0 n = n+1
Ack m n = Iter (Ack (m-1)) n
Iter f 0 = f 1
Iter f n = f (Iter f (n-1))

यह इतना है कि Iterजम्मू में लिखने के लिए बहुत आसान है, क्योंकि जम्मू में पास करने का एक तरीका है m-1करने के लिए Ackहै और यह भी का प्रारंभिक मूल्य को परिभाषित करने Iter1. विस्फोट से समझाया गया है:

(                      >:)  NB. increment n
                ^:(0<[)     NB. if m=0, do nothing to n+1; else:
   ^:                       NB. iterate...
($:                      )  NB.   self ($: is recursion)
     (<:@[     )            NB.   with left arg m-1
          `]                NB.   n+1 times
            `1:             NB.   starting on 1

यह इस बात पर निर्भर करता है कि J किस प्रकार के gerund रूप को कॉल करता है - जो कि ^:टैसिट (बिंदु-मुक्त) फैशन में सभी सीमाओं पर अधिक नियंत्रण रखता है।

REPL में:

   3 ($:^:(<:@[`]`1:)^:(0<[)>:) 3
61
   ack =: ($:^:(<:@[`]`1:)^:(0<[)>:)
   (i.4) ack"0 table (i.11)
+-----+------------------------------------------+
|ack"0|0  1  2  3   4   5   6    7    8    9   10|
+-----+------------------------------------------+
|0    |1  2  3  4   5   6   7    8    9   10   11|
|1    |2  3  4  5   6   7   8    9   10   11   12|
|2    |3  5  7  9  11  13  15   17   19   21   23|
|3    |5 13 29 61 125 253 509 1021 2045 4093 8189|
+-----+------------------------------------------+
   6!:2 '3 ($:^:(<:@[`]`1:)^:(0<[)>:) 10'  NB. snugly fits in a minute
58.5831

हमें ackएक तालिका में इसे रखने में सक्षम होने के लिए नाम से परिभाषित करने की आवश्यकता है , क्योंकि $:एक भयानक, बदसूरत जानवर है और जो भी इसे समझने का प्रयास करता है, उसे बाहर निकालता है। यह स्व-संदर्भ है, जहां स्वयं को सबसे बड़ी क्रिया वाक्यांश के रूप में परिभाषित किया गया है। tableक्रिया विशेषण है और इसलिए यदि आप इसे मौका देते हैं तो क्रिया वाक्यांश का हिस्सा बनना पसंद करेंगे, इसलिए आपको $:इसका उपयोग करने के लिए एक नामित परिभाषा में फंसना होगा।

संपादित करें: 24 चार?

वर्षों बाद, मुझे एक समाधान मिला जो दो अक्षरों से छोटा है।

(0&<~(<:@#~$:/@,1:^:)>:)

यह बहुत धीमा है, हालांकि: 3 ack 8मेरी मशीन पर एक मिनट लगता है। इसका कारण यह है (1) मैं गुना एक का उपयोग /यात्रा के बजाय, इसलिए जम्मू शायद सामान्य से अधिक चीजों को याद करने के लिए है, और (2), जबकि 0&<~प्रदर्शन के रूप में ही गणना (0<[), यह वास्तव में मार डाला जाता है n+1बार पुनरावर्ती कदम उठाने से पहले जब लागू m ack n- 0&<होता है उदासीन होना, इसलिए यह गणना को बर्बाद नहीं करता है, लेकिन nबड़ी तेजी से होता है और ackअत्यधिक पुनरावर्ती होता है।

मुझे संदेह है कि एक अधिक शक्तिशाली मशीन नए कोड को एक मिनट के अंदर धकेल सकती है, क्योंकि यह एक ऐसा कंप्यूटर है जहां पुराना कोड 3 ack 1015 सेकंड से भी कम समय में मिल सकता है ।

— algorithmshark
स्रोत

5

सी - 41 बाइट्स

इसके लिए कुछ भी नहीं - छोटी सीमा का मतलब है कि सभी आवश्यक मानों की गणना फ़ंक्शन की परिभाषा के अनुसार 1 सेकंड से भी कम समय में की जा सकती है।

A(m,n){return!m?n+1:A(m-1,n?A(m,n-1):1);}


int main()
{
    int m,n;
    for(m = 0; m <= 3; m++)
    for(n = 0; n <= 10; n++)
    printf("%d %d %d\n", m,n,A(m,n));
    return 0;
}

— feersum
स्रोत

5

जावास्क्रिप्ट ईएस 6 (34)

a=(m,n)=>m?a(m-1,n?a(m,n-1):1):n+1

कार्यान्वयन:

a=(m,n)=>m?a(m-1,n?a(m,n-1):1):n+1

td[colspan="2"] input{width: 100%;}

<table><tbody><tr><td>m=</td><td><input id="m" type="number" value="0" /></td></tr><tr><td>n=</td><td><input id="n" type="number" value="0" /></td></tr><tr><td colspan="2"><input type="button" value="Calculate!" onclick="document.getElementById('out').value=a(document.getElementById('m').value, document.getElementById('n').value)" /></td></tr><tr><td colspan="2"><input id="out" disabled="disabled" type="text" /></td></tr></tbody></table>

स्निपेट का विस्तार करें

— kitcar2000
स्रोत

4

जावास्क्रिप्ट (ईएस 6) - 34

A=(m,n)=>m?A(m-1,!n||A(m,n-1)):n+1

और एक परीक्षण:

> A=(m,n)=>m?A(m-1,!n||A(m,n-1)):n+1;s=new Date().getTime();console.log(A(3,10),(new Date().getTime() - s)/1000)
8189 16.441

— core1024
स्रोत

3

कोयल, ४०

nat_rec _ S(fun _ b n=>nat_iter(S n)b 1)

यह एक प्रकार का फंक्शन है nat -> nat -> nat। चूंकि Coq केवल कुल कार्यों के निर्माण की अनुमति देता है, यह एक औपचारिक प्रमाण के रूप में भी कार्य करता है कि एकरमैन पुनरावृत्ति अच्छी तरह से स्थापित है।

डेमो:

Welcome to Coq 8.4pl6 (November 2015)

Coq < Compute nat_rec _ S(fun _ b n=>nat_iter(S n)b 1) 3 10.
     = 8189
     : nat

नोट: Coq 8.5, इस चुनौती का नाम बदल के बाद जारी nat_iterकरने के लिए Nat.iter।

— एंडर्स कसीगोर
स्रोत

2

रैकेट 67

(define(a m n)(if(= m 0)(+ n 1)(a(- m 1)(if(= n 0)1(a m(- n 1))))))

— मैथ्यू बटरिक
स्रोत

2

मैथेमेटिका, 46 बाइट्स

0~a~n_:=n+1
m_~a~n_:=a[m-1,If[n<1,1,a[m,n-1]]]

एक मिनट के लिए बहुत अधिक लेता है a[3,10]। ध्यान दें कि Mathematica की डिफ़ॉल्ट पुनरावर्तन सीमा बहुत छोटी है a[3,8]और इससे परे (कम से कम मेरी मशीन पर) है, लेकिन इसे कॉन्फ़िगर करने के लिए ठीक किया जा सकता है

$RecursionLimit = Infinity

— मार्टिन एंडर
स्रोत

1

वाह, तो आप कह रहे हैं कि जेएस गणितज्ञ की तुलना में 25 गुना अधिक तेज है?

— अनुकूलक

@ ऑप्टिमाइज़र कम से कम जब यह पुनरावृत्ति की बात आती है ... मुझे लगता है कि अगर यह है कि इसे हर बार पता लगाना है कि कौन सी परिभाषा का उपयोग करना है, और Ifएक फ़ंक्शन होने के कारण यह धीमा भी है।

— मार्टिन एंडर

1

संस्मरण के साथ, यह 0.07 सेकंड लेता है। Ie m_~a~n_:=m~a~n=...

— मार्क एडलर

@MarkAdler यह एक बहुत अच्छा तरीका है मैथेमेटिका में स्मारक करने का!

— मार्टिन एंडर

2

लैम्ब्डा के साथ जावास्क्रिप्ट, 34

A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1

एक टिपिकल जवाब, कुछ भी कम नहीं कर सकता।

— Qwertiy
स्रोत

2

हास्केल, 48 44 वर्ण (सूची के लिए 36)

जबकि अन्य हास्केल समाधान के रूप में छोटा नहीं है, यह एक उल्लेखनीय है क्योंकि यह एकरमन फ़ंक्शन को एक अनंत सूची के रूप में व्यक्त करता है, जो मुझे लगता है कि थोड़े साफ है। परिणाम एक अनंत सूची (अनंत सूचियों में से) ऐसी है कि स्थिति [एम, एन] पर यह मान ए (एम, एन) रखती है ।

स्वयं अनंत सूची:

iterate(tail.(`iterate`1).(!!))[1..]

एक समारोह के रूप में (विनिर्देश का अनुपालन करने के लिए):

i=iterate;m%n=i(tail.(`i`1).(!!))[1..]!!m!!n

सूत्रीकरण यह देखते हुए किया गया था कि एकरमन फ़ंक्शन के लिए सामान्य / सामान्य मामला उपरोक्त पंक्ति में एक इंडेक्स के रूप में बाईं ओर के मूल्य का उपयोग करना है। इस पुनरावृत्ति के लिए आधार मामला (यानी एक पंक्ति का सबसे बाएँ स्तंभ, यानी A (m, 0) ) ऊपर की पंक्ति में दूसरे बाएँ-सबसे मान का उपयोग करना है। उस पुनरावृत्ति का आधार मामला ए (0, n) = n + 1 मामला है, अर्थात पहली पंक्ति है [1..]।

इस प्रकार, हम प्राप्त करते हैं

let a0 = [1..]
let a1 = tail $ iterate (a0 !!) 1  -- 'tail' because iterate starts by applying
let a2 = tail $ iterate (a1 !!) 1  -- the function 0 times
-- etc

फिर हम बस उस पैटर्न के आधार पर पुनरावृत्ति का एक और स्तर जोड़ते हैं, और कुछ व्यर्थ करतब करते हैं।

— जुगनू
स्रोत

आप iterateएक ही अक्षर के नाम पर उपनाम रख सकते हैंi=iterate;ack=i ...

— गर्वित हेकेलर

@proudhaskeller ओह, हाँ, इस बारे में नहीं सोचा था। धन्यवाद! आपके ऑपरेटर-नाम का उपयोग करने के लिए उधार लेना।

— फायरफली

2

टिनी लिस्प , 70 (प्रतियोगिता से बाहर)

यह प्रतिस्पर्धा से बाहर निकलता है, क्योंकि भाषा प्रश्न की तुलना में नई है, और यह (A 3 10)स्टैक अतिप्रवाह के कारण प्रश्न में आवश्यक रूप से चलाने में सफल नहीं होता है ।

(d A(q((m n)(i m(i n(A(s m 1)(A m(s n 1)))(A(s m 1)1))(s n(s 0 1))))))

यह एक फ़ंक्शन को परिभाषित करता है Aजो एकरमन फ़ंक्शन की गणना करता है। प्रारूपित:

हम यहां सभी बिलिन मैक्रोज़ ( dपरिभाषित करें) और q(उद्धरण) और i(यदि)) और एक बिल्टिन फ़ंक्शन ( s- घटाना) का उपयोग कर रहे हैं।

i जब स्थिति संख्या> 0 (और अन्यथा गलत भाग) हो, तो अपने वास्तविक हिस्से को निष्पादित करता है, इसलिए हमें यहां स्पष्ट तुलना नहीं करनी है।

sकेवल अंकगणितीय ऑपरेशन उपलब्ध है, हम इसका उपयोग n-1/ के लिए m-1, साथ ही साथ (s n (s 0 1))करते हैं n+1।

टिनी लिस्प पूंछ पुनरावृत्ति अनुकूलन का उपयोग कर रही है, लेकिन यह केवल Aपरिणाम में बाहरी कॉल के लिए मदद करता है , न कि उस A(m, n-1)कॉल के लिए जो मापदंडों के लिए उपयोग की जाती है।

जेवीएम पर सीलोन में मेरे छोटे लिस्प के कार्यान्वयन के साथ , यह काम करता है (A 3 5) = 253, लेकिन (A 2 125)सीधे गणना करने की कोशिश करते समय यह टूट जाता है (जो एक ही परिणाम देना चाहिए)। यदि गणना करने के बाद (A 3 4) = 125, जेवीएम को मेरे इंटरप्रेटर में कुछ मध्यवर्ती फ़ंक्शन कॉल को इनलाइन करने के लिए पर्याप्त रूप से फ़ंक्शन को ऑप्टिमाइज़ करने के लिए मिल रहा है, तो अधिक पुनरावृत्ति की अनुमति देता है। अजीब।

संदर्भ कार्यान्वयन पर निर्भर हो जाता है (A 3 5) = 253और यह भी (A 2 163) = 329, लेकिन सफल नहीं होता (A 2 164)और भी कम है, और इसलिए (A 3 6) = (A 2 253)।

— पाओलो एबरमन
स्रोत

यह व्हॉट्सएप और कोष्ठक के लिए प्रतिस्पर्धी बचत हो सकती है;)

— बिल्ली

2

गो, २६० २४३ २४० १२२ बाइट्स

मैंने यह नहीं देखा कि प्रश्न ने आनन फानन की अनुमति दी है।

प्रतिस्पर्धी से दूर लेकिन मैं इस भाषा को सीख रहा हूं और मैं इसका परीक्षण करना चाहता हूं।

func (m,n int)int{r:=0
switch{case m==0&&n!=0:r=n+1
case m!=0&&n==0:r=a(m-1,1)
case m!=0&&n!=0:r=a(m-1,a(m,n-1))}
return r}

इसका उपयोग करें go run ack.goऔर फिर दो नंबर की आपूर्ति करें, mऔर n। यदि m> 4 या n> 30, निष्पादन समय आधे मिनट से अधिक हो सकता है।

के लिए m=3 n=11:

$ time go run ack
16381
real    0m1.434s
user    0m1.432s
sys     0m0.004s

संपादित करें : switchओवर if/elseऔर डॉट-आयात पर स्विच करके कुल 17 बाइट्स बचाए गए

— बिल्ली
स्रोत

1

आप और भी बेहतर कर सकते हैं! switch 0 {case m:r=n+1 case n:r=a(m-1,1) default:r=a(m-1,a(m,n-1))}गो का switchकथन कितना सुंदर लचीला है!

— EMBLEM

@EMBLEM धन्यवाद, जब से मैंने गो की एक पंक्ति लिखी है तब से यह बहुत लंबा है, लेकिन मुझे यह देखकर खुशी हुई कि अन्य गो-गोल्फर भी हैं: D

— cat

1

हास्केल: 81 69 बाइट्स

a::Int->Int->Int
a 0 n=n+1
a m 0=a (m-1) 1
a m n=a (m-1) a m (n-1)

a 3 10 लगभग 45 सेकंड लगते हैं।

— SophR
स्रोत

1

यह कोड गोल्फ है, इसलिए आपको सबसे छोटा कोड संभव बनाने की कोशिश करनी चाहिए। उदाहरण के लिए, अनावश्यक स्थानों और स्पष्ट प्रकार को हटा दें

— गर्वित हैकेलर

आपको चौथी पंक्ति में

— अभिमान

1

(गैर-प्रतिस्पर्धात्मक) पायथ, 15 बाइट्स

M?GgtG?HgGtH1hH

इसे ऑनलाइन आज़माएं! ( g3Tजोड़ा गया फ़ंक्शन का नमूना उपयोग , जिसका अर्थ है g(3,10))

— लीक नन
स्रोत

1

(गैर-प्रतिस्पर्धात्मक) UGL , 31 30 बाइट्स

iiRuldr%l%lR$d%rd:u%d:%+uRu:ro

इनपुट को नई खबरों से अलग किया।

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

(यह दुभाषिया में एक मानक उदाहरण के रूप में लागू किया गया है।)

— लीक नन
स्रोत

1

जूलिया, 34 31 28 बाइट्स

m\n=m>0?~-m\(n<1||m\~-n):n+1

यह एक नामांकित फ़ंक्शन है। यह जूलिया को पुनर्परिभाषित करने की क्षमता का दुरुपयोग करते हुए, पुनरावर्ती परिभाषा का सीधा कार्यान्वयन है ।

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

— डेनिस
स्रोत

1

आर - ५४ ५२

मैंने इसे आर के आसपास पाने के लिए कोशिश करने के लिए एक बहाने के रूप में इस्तेमाल किया है, इसलिए यह संभवतः वास्तव में बुरी तरह से किया गया है :)

a=function(m,n)"if"(m,a(m-1,"if"(n,a(m,n-1),1)),n+1)

उदाहरण चलाते हैं

> a(3,8)
[1] 2045

मैं उस से परे कुछ के लिए एक ढेर अतिप्रवाह मिलता है

टी-एसक्यूएल- 222

मुझे लगा कि मैं इसे करने के लिए टी-एसक्यूएल प्राप्त करने की कोशिश करूंगा। एक अलग तरीके का इस्तेमाल किया क्योंकि रिकार्शन SQL में अच्छा नहीं है। 4,2 से अधिक कुछ भी यह बम।

DECLARE @m INT=4,@n INT=1;WITH R AS(SELECT 2 C, 1 X UNION ALL   SELECT POWER(2,C),X+1FROM R)SELECT IIF(@m=0,@n+1,IIF(@m=1,@n+2,IIF(@m=2,2*@n+3,IIF(@m=3,POWER(2,@n+3)-3,IIF(@m=4,(SELECT TOP(1)C FROM R WHERE x= @n+3)-3,-1)))))

— MickyT
स्रोत

आपके आर सबमिसन के लिए, ऐसा लगता है कि आपको ज़रूरत नहीं है, {}हालांकि स्टैक ओवरफ़्लो की सीमा में कोई मदद नहीं की गई है, क्योंकि आर में टीसीओ नहीं है ...

— Giuseppe

@Giuseppe धन्यवाद ... मेरे बचाव में, मैं तब इसके लिए नया था :)

— मिकी

1

ब्रेनफक , 90 बाइट्स

>>>>+>,>,<<[>[>[-[->>>+<<<]<[->+>>+<<<]>-[-<+>]>+>>>>>]<[->+>>]]<[>>+[-<<<+>>>]<<-]<<<]>>.

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

संख्या के रूप में IO के साथ, मनमाने ढंग से आकार सेल आकार के साथ एक कार्यान्वयन मानता है। -6 बाइट्स यदि आप नकारात्मक कोशिकाओं का उपयोग करने में कोई आपत्ति नहीं करते हैं।

लिंक्ड दुभाषिया में 3,8 के लिए लगभग 30 सेकंड में खत्म हो जाता है, बशर्ते आप सही सेटिंग्स पर टिक करें। टाइप इनपुट संख्याएँ \s के साथ पहले से लगी हुई है , जैसे 3,9है \3\9।

— मजाक कर रहा है
स्रोत

1

Tcl , 67 बाइट्स

proc tcl::mathfunc::A m\ n {expr {$m?A($m-1,$n?A($m,$n-1):1):$n+1}}

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

Tcl , 77 बाइट्स

proc A m\ n {expr {$m?[A [expr $m-1] [expr {$n?[A $m [expr $n-1]]:1}]]:$n+1}}

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

ऑनलाइन कंपाइलर में यह टाइम-आउट के कारण चलने में विफल रहता है, लेकिन एक स्थानीय टीईसी दुभाषिया में यह अच्छी तरह से चलता है। मैंने Aकार्य करने के लिए प्रत्येक रूट कॉल की रूपरेखा तैयार की , यह देखने के लिए कि प्रत्येक जोड़ी के {m,n}परीक्षण के लिए गणना में कितना समय लगा :

m=0, n=0, A=1, time=3.5e-5 seconds
m=0, n=1, A=2, time=2e-6 seconds
m=0, n=2, A=3, time=8e-6 seconds
m=0, n=3, A=4, time=1e-6 seconds
m=0, n=4, A=5, time=2e-6 seconds
m=0, n=5, A=6, time=1e-6 seconds
m=0, n=6, A=7, time=1e-6 seconds
m=0, n=7, A=8, time=1e-6 seconds
m=0, n=8, A=9, time=1e-6 seconds
m=0, n=9, A=10, time=0.0 seconds
m=0, n=10, A=11, time=1e-6 seconds
m=1, n=0, A=2, time=4e-6 seconds
m=1, n=1, A=3, time=6e-6 seconds
m=1, n=2, A=4, time=1e-5 seconds
m=1, n=3, A=5, time=1.2e-5 seconds
m=1, n=4, A=6, time=1.5e-5 seconds
m=1, n=5, A=7, time=2e-5 seconds
m=1, n=6, A=8, time=2e-5 seconds
m=1, n=7, A=9, time=2.6e-5 seconds
m=1, n=8, A=10, time=3e-5 seconds
m=1, n=9, A=11, time=3e-5 seconds
m=1, n=10, A=12, time=3.3e-5 seconds
m=2, n=0, A=3, time=8e-6 seconds
m=2, n=1, A=5, time=2.2e-5 seconds
m=2, n=2, A=7, time=3.9e-5 seconds
m=2, n=3, A=9, time=6.3e-5 seconds
m=2, n=4, A=11, time=9.1e-5 seconds
m=2, n=5, A=13, time=0.000124 seconds
m=2, n=6, A=15, time=0.000163 seconds
m=2, n=7, A=17, time=0.000213 seconds
m=2, n=8, A=19, time=0.000262 seconds
m=2, n=9, A=21, time=0.000316 seconds
m=2, n=10, A=23, time=0.000377 seconds
m=3, n=0, A=5, time=2.2e-5 seconds
m=3, n=1, A=13, time=0.000145 seconds
m=3, n=2, A=29, time=0.000745 seconds
m=3, n=3, A=61, time=0.003345 seconds
m=3, n=4, A=125, time=0.015048 seconds
m=3, n=5, A=253, time=0.059836 seconds
m=3, n=6, A=509, time=0.241431 seconds
m=3, n=7, A=1021, time=0.971836 seconds
m=3, n=8, A=2045, time=3.908884 seconds
m=3, n=9, A=4093, time=15.926341 seconds
m=3, n=10, A=8189, time=63.734713 seconds

यह अंतिम जोड़ी के लिए विफल रहता है {m,n}={3,10}, क्योंकि इसमें एक मिनट से बहुत कम समय लगता है।

के उच्च मूल्यों के लिए m, recursionlimitमूल्य बढ़ाने के लिए इसकी आवश्यकता होगी ।

मैं इसे 65 बाइट्स से छोटा कर देता हूं, लेकिन यह प्रश्न की आवश्यकता को पूरा नहीं करेगा "आपका फ़ंक्शन एक मिनट से कम समय में m ≤ 3 और n in 10 के लिए A (m, n) का मान खोजने में सक्षम होना चाहिए।" इसके बिना {}यह TIO पर टाइमआउट करेगा और अंतिम दो प्रविष्टियों का डेमो नहीं करेगा।

Tcl , 65 बाइट्स

proc tcl::mathfunc::A m\ n {expr $m?A($m-1,$n?A($m,$n-1):1):$n+1}

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

— sergiol
स्रोत

0

जे: 50

>:@]`(1$:~<:@[)`(<:@[$:[$:_1+])@.(0>.[:<:@#.,&*)M.

0 ... 3 बनाम 0 ... 10: के लिए एक दूसरे के एक अंश में रिटर्न

   A=:>:@]`(1$:~<:@[)`(<:@[$:[$:_1+])@.(0>.[:<:@#.,&*)M.
   timespacex 'res=:(i.4) A"0 table (i.11)'
0.0336829 3.54035e6
   res
┌───┬──────────────────────────────────────────┐
│A"0│0  1  2  3   4   5   6    7    8    9   10│
├───┼──────────────────────────────────────────┤
│0  │1  2  3  4   5   6   7    8    9   10   11│
│1  │2  3  4  5   6   7   8    9   10   11   12│
│2  │3  5  7  9  11  13  15   17   19   21   23│
│3  │5 13 29 61 125 253 509 1021 2045 4093 8189│
└───┴──────────────────────────────────────────┘

पुनश्च: "0 प्रत्येक एकल तत्व पर एक कार्य करने के लिए कार्य करता है, इसके बजाय बाएँ और दाएँ सरणी ऊपर gobbling, और लंबाई त्रुटियाँ पैदा कर रहा है। लेकिन यह उदाहरण के लिए आवश्यक नहीं है। 9 = 2 ए 3।

— jpjacobs
स्रोत

codegolf.stackexchange.com/a/40174/48934 आपको पीटा गया है!

— लीक नून

0

एपीएल, ३१

{⍺=0:⍵+1⋄⍵=0:1∇⍨⍺-1⋄(⍺-1)∇⍺∇⍵-1}

बहुत सीधा। तर्कों को उलट कर एक बाइट को बचाने के लिए एक बार ers चरित्र का उपयोग करता है। M को बाएं तर्क के रूप में और N को सही तर्क के रूप में लिया जाता है।

TryAPL.org

— Shujal
स्रोत

0

रूबी, ६५

h,a={},->m,n{h[[m,n]]||=m<1?(n+1):(n<1?a[m-1,1]:a[m-1,a[m,n-1]])}

व्याख्या

यह समस्या वर्णन में दिए गए एल्गोरिथम का एक बहुत ही सरल अनुवाद है।

इनपुट को लंबोदर के तर्क के रूप में लिया जाता है। दो Integerएस अपेक्षित हैं।
गति और स्टैक-ओवरफ़्लो त्रुटियों से बचने के लिए, उत्तर में याद किया जाता है Hash h। ||=ऑपरेटर एक मूल्य है कि पहले की गणना नहीं की गई थी गणना करने के लिए प्रयोग किया जाता है।

a[3,10] मेरी मशीन पर ~ 0.1 सेकंड में गणना की जाती है।

यहाँ एक अनगढ़ संस्करण है

h = {}
a = lambda do |m,n|
  h[[m,n]] ||= if m < 1 
    n + 1
  elsif n < 1
    a[m-1,1]
  else
    a[m-1,a[m,n-1]]
  end
end

— britishtea
स्रोत

a[3,10]मेरी मशीन पर एक SystemStackError फेंक ...

— TuxCrafting

गोल्फ nitpicks: आप को बदल सकता है m<1?(n+1):(n<1?a[m-1,1]:a[m-1,a[m,n-1]])के लिएm<1?n+1:a[m-1,n<1?1:a[m,n-1]]

— सीधे शब्दों में सुंदर कला

0

माउस- 2002 , 99 83 बाइट्स

$Y1%j:j.0=m:2%k:k.0=n:m.n.>[k.1+!|m.n.<[#Y,j.1-,1;|m.n.*0=[#Y,j.1-,#Y,j.,k.1+;;]]]@

— बिल्ली
स्रोत

0

जावा, 274 बाइट्स

import java.math.*;class a{BigInteger A(BigInteger b,BigInteger B){if(b.equals(BigInteger.ZERO))return B.add(BigInteger.ONE);if(B.equals(BigInteger.ZERO))return A(b.subtract(BigInteger.ONE),BigInteger.ONE);return A(b.subtract(BigInteger.ONE),A(b,B.subtract(BigInteger.ONE)));}}

यह A(3,10)कुछ सेकंड में गणना करता है, और अनंत स्मृति और स्टैक स्पेस को देखते हुए, यह किसी भी संयोजन की गणना कर सकता है bऔर Bजब तक परिणाम 2 ^2147483647 -1 से नीचे है ।

— dorukayhan मोनिका को वापस चाहता है
स्रोत

मुझे पता है कि यह एक समय हो गया है, लेकिन आप इसे 185 बाइट्स में

import java.math.*;BigInteger A(BigInteger b,BigInteger B){return b.equals(B.ZERO)?B.add(B.ONE):B.equals(B.ZERO)?A(b.subtract(B.ONE),B.ONE):A(b.subtract(B.ONE),A(b,B.subtract(B.ONE)));}

— गोल

0

सीलोन, 88 87 85

alias I=>Integer;I a(I m,I n)=>m<1then n+1else(n<1then a(m-1,1)else a(m-1,a(m,n-1)));

यह एक सीधा कार्यान्वयन है। प्रारूपित:

alias I => Integer;
I a(I m, I n) =>
        m < 1
        then n + 1
        else (n < 1
            then a(m - 1, 1)
            else a(m - 1, a(m, n - 1)));

उपनाम केवल एक बाइट बचाता है, इसके बिना (लिखने के Integerबजाय I) हम 86 बाइट्स प्राप्त करेंगे। एक और दो बाइट्स की जगह बचाया जा सकता है == 0द्वारा < 1दो बार।

की डिफ़ॉल्ट सेटिंग्स के साथ ceylon run, यह A(3,12) = 32765(और A(4,0) = 13) तक काम करेगा , लेकिन A(3,13)(और इसलिए भी A(4,1)) स्टैक ओवरफ्लो त्रुटि को फेंक देगा। ( मेरे कंप्यूटर पर 3 A(3,12)सेकंड के बारे में 5 सेकंड लगते हैं A(3,11)।)

उपयोग करना ceylon run-js(यानी नोड पर नोड को संकलित करने का परिणाम चलाना। js) एक बहुत धीमा है (1 मिनट के लिए 19 मिनट की आवश्यकता है A(3,10)), और A(3, 11)1 के लिए चलने के बाद «अधिकतम कॉल स्टैक आकार« (डिफ़ॉल्ट सेटिंग्स का उपयोग करके) के साथ पहले से ही टूट जाता है। मिनट 30 एस।

पुनरावृत्ति के बिना सीलोन, 228

एक बोनस के रूप में, यहां एक गैर-पुनरावर्ती संस्करण है (अब, निश्चित रूप से, लेकिन ओवरफ्लो को ढेर करने के लिए प्रतिरक्षा - कुछ बिंदु पर आउट-ऑफ-मेमोरी त्रुटि मिल सकती है)।

import ceylon.collection{A=ArrayList}Integer a(Integer[2]r){value s=A{*r};value p=s.addAll;while(true){if(exists m=s.pop()){if(exists n=s.pop()){if(n<1){p([m+1]);}else if(m<1){p([n-1,1]);}else{p([n-1,n,m-1]);}}else{return m;}}}}

प्रारूपित:

import ceylon.collection {
    A=ArrayList
}

Integer a(Integer[2] r) {
    value s = A { *r };
    value p = s.addAll;
    while (true) {
        if (exists m = s.pop()) {
            if (exists n = s.pop()) {
                if (n < 1) {
                    p([m + 1]);
                } else if (m < 1) {
                    p([n - 1, 1]);
                } else {
                    p([n - 1, n, m - 1]);
                }
            } else {
                // stack is empty
                return m;
            }
        }
    }
}

यह मेरे कंप्यूटर पर पुनरावर्ती संस्करण की तुलना में काफी धीमा है: A(3,11)9.5 सेकंड A(3,12)लगते हैं , 34 सेकंड A(3,13)लगते हैं, 2:08 मिनट लगते हैं, A(3,14)8:25 मिनट लगते हैं। (मेरे पास मूल रूप से अब मेरे पास मौजूद ट्यूपल्स के बजाय आलसी पुनरावृत्तियों का उपयोग करने वाला एक संस्करण था, जो एक ही आकार के साथ बहुत धीमा था)।

थोड़ा तेज (21 सेकंड के लिए A(3,12)) (बल्कि एक बाइट लंबा) एक संस्करण है जिसके s.pushबजाय का उपयोग किया जाता है s.addAll, लेकिन कई संख्याओं को जोड़ने के लिए कई बार कॉल करने की आवश्यकता होती है, क्योंकि यह प्रत्येक एकल इंटेगर लेता है। एक ArrayList के बजाय एक लिंक्डलिस्ट का उपयोग करना बहुत धीमा है।

— पाओलो एबरमन
स्रोत

एकरमन समारोह

अजगर , १ ९

परीक्षा:

स्पष्टीकरण:

हास्केल, 35

गोल्फस्क्रिप्ट (30)

विच्छेदन

बाइनरी लैम्ब्डा कैलकुलस , 54 बिट्स = 6.75 बाइट्स

जावास्क्रिप्ट, ईएस 6, 41 34 बाइट्स

पायथन 2.7.8 - 80, 54, 48, 46 45

जे - 26 चार

संपादित करें: 24 चार?

सी - 41 बाइट्स

जावास्क्रिप्ट ईएस 6 (34)

कार्यान्वयन:

जावास्क्रिप्ट (ईएस 6) - 34

कोयल, ४०

रैकेट 67

मैथेमेटिका, 46 बाइट्स

लैम्ब्डा के साथ जावास्क्रिप्ट, 34

हास्केल, 48 44 वर्ण (सूची के लिए 36)

टिनी लिस्प , 70 (प्रतियोगिता से बाहर)

गो, २६० २४३ २४० १२२ बाइट्स

हास्केल: 81 69 बाइट्स

(गैर-प्रतिस्पर्धात्मक) पायथ, 15 बाइट्स

(गैर-प्रतिस्पर्धात्मक) UGL , 31 30 बाइट्स

जूलिया, 34 31 28 बाइट्स

आर - ५४ ५२

टी-एसक्यूएल- 222

ब्रेनफक , 90 बाइट्स

Tcl , 67 बाइट्स

Tcl , 77 बाइट्स

Tcl , 65 बाइट्स

जे: 50

एपीएल, ३१

रूबी, ६५

व्याख्या

माउस- 2002 , 99 83 बाइट्स

जावा, 274 बाइट्स

सीलोन, 88 87 85

पुनरावृत्ति के बिना सीलोन, 228