ग्राहम की संख्या Gइस तरह से परिभाषित की गई है:

u(3,n,1) = 3^n
u(3,1,m) = 3
u(3,n,m) = u(3,u(3,n-1,m),m-1)
[Knuth's up-arrow notation]
[Conway chained arrow notation]

THEN

g1 = u(3,3,4)
g2 = u(3,3,g1)
g3 = u(3,3,g2)
...
G = u(3,3,g63)

आपको वह u(3,3,2)=7625597484987कोड दिया गया है जो आपके कोड की जांच करने के लिए है।

आपका कार्य एक प्रोग्राम / फ़ंक्शन लिखना है जो कि Gनिर्धारित पूर्णांक आकार और पर्याप्त समय को देखते हुए, नियतात्मक रूप से मूल्य का उत्पादन करेगा ।

संदर्भ

लीडरबोर्ड

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

var QUESTION_ID=83873,OVERRIDE_USER=48934;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+(?:\.\d+)?)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

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

code-golf number-theory

— लीक नन
स्रोत

2

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

Hexdump:

00000000: 4457 42b0 2d88 1f9d 740e 5ed0 39ce 80    DWB.-...t.^.9..

बाइनरी:

010001000101011101000010101100000010110110001000000111111001110101110100000011100101111011010000001110011100111010

व्याख्या

01 00                                           (λx.
│    01 00                                        (λy.
│    │    01 01 01 110                              x
│    │    │  │  └─ 10                               y
│    │    │  └─ 00                                  (λm.
│    │    │       01 01 01 10                         m
│    │    │       │  │  └─ 00                         (λg.
│    │    │       │  │       00                         λn.
│    │    │       │  │         01 01 10                  n
│    │    │       │  │         │  └─ 110                 g
│    │    │       │  │         └─ 00                     (λz.
│    │    │       │  │              10                     z))
│    │    │       │  └─ 00                            (λn.
│    │    │       │       00                            λf.
│    │    │       │         01 111110                    x
│    │    │       │         └─ 01 110                    (n
│    │    │       │            └─ 10                      f))
│    │    │       └─ 1110                             x)
│    │    └─ 10                                     y)
│    └─ 00                                        (λf.
│         00                                        λz.
│           01 110                                   f
│           └─ 01 01 1110                            (x
│              │  └─ 110                              f
│              └─ 10                                  z)))
└─ 00                                           (λf.
     00                                           λz.
       01 110                                      f
       └─ 01 110                                   (f
          └─ 01 110                                 (f
             └─ 10                                   z)))

यह है (λ x । (Λ y । X y (λ m । M) (λ g । Λ n । N g 1) (λ n । Λ f । X ( n f )) x ) y ) (λ f । Λ z । f ( x f z )) 3, जहां सभी संख्याओं को चर्च अंकों के रूप में दर्शाया गया है। चर्च अंकों के प्राकृतिक संख्या के मानक लैम्ब्डा पथरी प्रतिनिधित्व कर रहे हैं, और क्योंकि एक चर्च संख्या समारोह यात्रा से परिभाषित किया गया है वे अच्छी तरह से इस समस्या के अनुकूल हैं: n छ है n वें समारोह के पुनरावृति जी ।

उदाहरण के लिए, यदि g फ़ंक्शन λ n है । λ च । 3 ( n f ) जो एक चर्च अंक द्वारा 3 गुणा करता है, फिर λ n । n g 1 एक ऐसा कार्य है जो एक चर्च अंक की शक्ति को 3 लेता है। इस आपरेशन पुनरावृत्ति मीटर बार देता है

m (λ g । λ n । n g 1) (λ n । λ f । 3 ( n f )) n = u (3, n , m )।

(हम बेस केस के रूप में घातांक u (-, -, 1) के बजाय गुणा यू (-, - 0) का उपयोग करते हैं , क्योंकि चर्च के अंक से 1 को घटाना अप्रिय है ।)

स्थानापन्न n = 3:

m (λ g । λ n । n g 1) (λ n । λ f । 3 ( n f )) 3 = u (3, 3, m )।

उस ऑपरेशन को 64 बार करना, m = 4 से शुरू होकर देता है

64 (λ मीटर । मीटर (λ छ । Λ n । एन जी 1) (λ n । Λ च । 3 ( एन एफ )) 3) 4 = जी ।

इस अभिव्यक्ति को अनुकूलित करने के लिए, 64 = 4 ^ 3 = 3 4 को प्रतिस्थापित करें:

3 4 (λ मीटर । मीटर (λ छ । Λ n । एन जी 1) (λ n । Λ च । 3 ( एन एफ )) 3) 4 = जी ।

याद रखें 4 = succ 3 = λ f । λ जेड । f (3 f z ) एक लंबो तर्क के रूप में:

(λ y । 3 y (λ m । m (λ g । λ n । n g 1)) (λ n । λ f । 3 ( n f )) 3) y ) (λ f । λ z । f (3 f) z )) = जी ।

अंत में, 3 = λ f याद रखें । λ जेड । f ( f ( f z )) एक लंबो तर्क के रूप में:

(λ एक्स । (λ y । एक्स वाई (λ मीटर । मीटर (λ छ । λ n । एन जी 1) (λ n । λ च । एक्स ( एन एफ )) x ) y ) (λ च । λ जेड । f ( x f z )) 3 = जी ।

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

इस भाषा के लिए दुभाषिया कहां मिल सकता है?

— डेनिस

4

@ डेनिस tromp.github.io/cl/cl.html का एक जोड़ा है।

— एंडर्स कासोर्ग

1

यह कमाल है । यह एक बड़ा इनाम है

— बिल्ली

1

14.25 bytesलीडरबोर्ड को गड़बड़ाने लगता है। यह के रूप में parsed है 25 bytes, और आप इसलिए दूसरे के रूप में रखा जाता है।

— Dan

1

@ मैं नेता बोर्ड स्निपेट तय करता हूं, मुझे लगता है।

— एंडर्स कासोर्ग

40

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

i=((!!).).iterate
i(($3).i(`i`1)(*3))4 64

स्पष्टीकरण:

(`i`1)f n= शुरू होने वाले फ़ंक्शन i f 1 nके nवें पुनरावृति की गणना करता है । विशेष रूप से, = 3 ^ n , और पुनरावृत्ति इस निर्माण मीटर बार देता है = यू (3, n , मी )। हम जानते हैं कि के रूप में फिर से लिखने कर सकते हैं = यू (3, n , मी ), और दोहराएं इस निर्माण कश्मीर पाने के लिए बार = जी _ कश्मीर ।f1(`i`1)(*3)ni(`i`1)(*3)m n(($n).i(`i`1)(*3))mi(($3).i(`i`1)(*3))4 k

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

16

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

q=((!!).).iterate
g=q(`q`1)(3*)
q(`g`3)4$64

gइनलाइन फ्लिप करने का एक बेहतर तरीका है ।

46 बाइट्स:

i=iterate
n%0=3*n
n%m=i(%(m-1))1!!n
i(3%)4!!64

48 बाइट्स:

n%1=3^n
1%m=3
n%m=(n-1)%m%(m-1)
iterate(3%)4!!64

बस परिभाषाएँ लिख रहा हूँ।

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

n%0=3*n
0%m=1
n%m=(n-1)%m%(m-1)
z=iterate(3%)2!!1

— XNOR
स्रोत

क्या आप एक और फ़ंक्शन का उपयोग कर सकते हैं, जिसमें +बीच की कोष्ठक को हटाने के लिए पूर्ववर्ती स्थिति कम है m-1?

— लीक नून

मैं 44 बाइट्स गिनता हूं, और 4 और 64 का क्या हुआ?

— लीक नून

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

— xnor

मेरा मतलब है, मैं 44 बाइट्स गिनने के बाद आपको इसे 64 में बदल देता हूं।

— लीक नून

मुझे लगता है कि आपका मतलब है (`g`3), नहीं (3`g`)।

— एंडर्स कासोर्ग

10

पायथ, 25 बाइट्स

M?H.UgbtH*G]3^3Gug3tG64 4

पहला भाग M?H.UgbtH*G]3^3Gएक विधि को परिभाषित करता है g(G,H) = u(3,G,H+1)।

पहले भाग की जांच के लिए जांच करें कि 7625597484987=u(3,3,2)=g(3,1): g3 1।

दूसरे भाग से ug3tG64 4शुरू होता है r0 = 4और फिर rn = u(3,3,r(n-1)) = g(3,r(n-1))64 बार गणना करता है, अंतिम मूल्य के आउटपुट ( भ्रम से बचने के rबजाय चुना जाता है g)।

इस भाग का परीक्षण करने के लिए, से शुरू करें r0=2और फिर गणना r1करें ug3tG1 2:।

— लीक नन
स्रोत

यदि जी (जी, एच) = यू (3, जी, एच + 1), आपके पास आर (एन) = यू (3, 3, आर (एन - 1)) = जी (3, आर (एन - 1) होना चाहिए। ) - 1), जी नहीं (3, आर (एन - 1))। मुझे लगता है कि आपका कोड सही है, लेकिन आपका स्पष्टीकरण याद आ रहा है - 1.

— एंडर्स कासोर्ग

आप अनफिट यू तर्क ( ^3↦ *3, tGand G), और .UgbtH*G]3te के साथ एक अन्य बाइट का उपयोग करके एक बाइट बचा सकते हैं e.ugNtHG1।

— एंडर्स कासोर्ग

उस दूसरी बाइट को बचाने का एक वैकल्पिक तरीका *G]3save है ShG।

— एंडर्स कासोर्ग

8

सेसोस , 30 बाइट्स

0000000: 286997 2449f0 6f5d10 07f83a 06fffa f941bb ee1f33  (i.$I.o]...:....A...3
0000015: 065333 07dd3e 769c7b                              .S3..>v.{

disassembled

या ब्रेनफक नोटेशन में:

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

परिक्षण

गणना करने के लिए यू (3, एन , यू (3, n , ... यू (3, एन , एम ) ...)) के साथ कश्मीर नेस्ट के लिए कॉल यू , पहले तीन की जगह addनिर्देश add 4, add 64, add 3साथ add m, add k, add n, क्रमशः। क्योंकि सीसो रैखिक समय की तुलना में तेज़ी से संख्याओं का निर्माण नहीं कर सकता है, आप व्यावहारिक रूप से यू (3, 2, 2) = 27, यू (3, 5, 1) = 243 और यू (3, 1 ) जैसे छोटे मूल्यों तक सीमित हैं , u (3, 1,… u (3, 1, m )…) = 3

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

आप बदल सकते हैं [-]के साथ ,के बाद से EOF है 0।

— mbomb007

6

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

u=(n,m)=>n>1&m>1?u(u(n-1,m),m-1):3**n
g=n=>n?u(3,g(n-1)):4
g(64)

— नील
स्रोत

@AndersKaseorg उघ, उस मामले में मैं उस बदलाव को वापस कर सकता हूं।

— नील

यह एक स्टैक अतिप्रवाह का कारण बनता है, आपके पुनरावर्तन पैटर्न को फिर से जाँचने की आवश्यकता हो सकती है।

— NodeNodeNode 15

यह सरल ES7 नहीं है। यह अनबाउंड ईएस 7 (ईएस 7 का एक काल्पनिक संस्करण है लेकिन बिग्नम के साथ, असीम रूप से ओरेकल करने में सक्षम है, और शॉर्टहैंड के रूप में / # xE ^ के साथ दशमलव का उपयोग कर रहा है)।

— 1875 पर user75200

5

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

4:64:1iw
:3{[1:N],3:N^.|t1,3.|hM:1-X,?t:1-:Mr:2&:Xr:2&.}.

कोई इनपुट और न ही आउटपुट की अपेक्षा करता है और परिणाम को लिखता है STDOUT। यह एक बिंदु पर एक ढेर अतिप्रवाह का उत्पादन करेगा।

इसकी जांच करने के छोटे मान (जैसे के लिए यह काम करता है u(3,3,2)) आप बदल सकते हैं 4के मूल्य के साथ mऔर 64साथ 1।

व्याख्या

यह मूल रूप से संख्या की गणना के स्पष्ट तरीके का सीधा कार्यान्वयन है।

मुख्य विधेय:

4:64:1i                    Call Predicate 1 64 times with 4 as initial input (the second
                           call takes the output of the first as input, etc. 64 times).
       w                   Write the final output to STDOUT

1 समर्पित करें:

:3{...}.                   Call predicate 2 with input [Input, 3]. Its output is the 
                           output of predicate 1.

2 समर्पित करें:

[1:N],                     M = 1
      3:N^.                Output = 3^N
|                          Or
t1,                        N = 1
   3.                      Output = 3
|                          Or
hM:1-X,                    X is M - 1
       ?t:1-:Mr:2&         Unify an implicit variable with u(3,N-1,M)
                  :Xr:2&.  Unify Output with u(3,u(3,N-1,M),X)

— Fatalize
स्रोत

5

कारमेल , 38 बाइट्स

(64 ((f->(f,1)),(n f->(3 (n f))),3) 4)

यह लैम्ब्डा कैलकुलस एक्सप्रेशन 64 (λ m । M (λ f । Λ n । N f 1)) (λ n । Λ f । 3 ( n f )) 3) 4 है, जहाँ सभी संख्याओं को चर्च से दर्शाया गया है। अंक ।

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

(n f->3 (n f))क्या इसे नहीं पढ़ना चाहिए n-1?

— लीक नन

@ LeakyNun नंबर चर्च के अंकों(n f->3 (n f)) में तीन से गुणा करने के लिए एक फ़ंक्शन है ।

— एंडर्स कासोर्ग

2

यह चुनौती लैम्ब्डा कैलकुलस में अत्यधिक सरल लगती है। क्यों?

— बिल्ली

3

प्रोलॉग (SWIPL), 129/137 बाइट्स

g(1,R):-u(3,4,R).
g(L,R):-M is L-1,g(M,P),u(3,P,R).
u(N,1,R):-R is 3**N.
u(1,_,3).
u(N,M,R):-K is N-1,L is M-1,u(K,M,Y),u(Y,L,R).

ग्राहम की संख्या का उत्पादन करने के लिए, g(64,G).यदि इस क्वेरी के 8 बाइट्स गिने जाने हैं, तो लंबाई 137 बाइट्स है:

?- g(64, G).
ERROR: Out of local stack

लेकिन जैसा कि उम्मीद की जा सकती है, यह स्टैक से बाहर निकलता है।

परीक्षा

?- u(3, 2, X).
X = 7625597484987

Backtracking यह स्टैक से बाहर निकलने का कारण बनता है:

?- u(3, 2, X).
X = 7625597484987 ;
ERROR: Out of local stack

Ungolfed

अनगोल्डेड संस्करण सामान्य अप-एरो नोटेशन जोड़ता है, न कि केवल 3 के लिए, और बैकट्रैकिंग और अपरिभाषित स्थितियों से बचने के लिए कटौती और जांच का उपयोग करता है।

% up-arrow notation
u(X, 1, _M, X) :- !.
u(X, N, 1, R) :-
    R is X**N, !.
u(X, N, M, R) :-
    N > 1,
    M > 1,
    N1 is N - 1,
    M1 is M - 1,
    u(X, N1, M, R1),
    u(X, R1, M1, R).

% graham's number
g(1,R) :- u(3, 3, 4, R), !.
g(L,R) :-
    L > 1,
    L1 is L - 1,
    g(L1,G1),
    u(3, G1, R).

— SQB
स्रोत

आपने 64अपने कोड में कहीं भी बिना नंबर के इसे कैसे प्रबंधित किया ?

— लीक नून

@LeakyNun मैंने स्पष्ट करने के लिए संपादन किया; बेहतर है?

— SQB

ठीक है, तो इसे अपने कोड में और साथ ही अपनी बाइट-गिनती में जोड़ें।

— लीक नून

3

सी, 161 बाइट्स

u(int a, int b){if(a==1)return 3;if(b==1)return pow(3,a);return u(u(a-1,b),b-1);}
g(int a){if(a==1)return u(3,4);return u(3,g(a-1));}
main(){printf("%d",g(64));}

EDIT: टैब्स और न्यूलाइन को हटाकर 11 बाइट्स बचाए। संपादित करें: thx ahhmann ने एक और बाइट को बचाया और मेरा कार्यक्रम तय किया

— thepiercingarrow
स्रोत

1

आप g(int a){if(a==1)return u(3,4);return g(a-1);}इसे हटा सकते हैं क्योंकि इसका उपयोग बिल्कुल नहीं किया जा रहा है ... या आप कुछ भूल रहे हैं?

— auhmaan

@ गौमांस को खेद है, मैंने परीक्षण के लिए उस नंबर का उपयोग किया और इसे वापस बदलना भूल गया। धन्यवाद!!

— thepiercingarrow

आपका return g(a-1)होना चाहिए return u(3,g(a-1))।

— एंडर्स कासोर्ग

1

मुझे नहीं पता कि मुझे उचित उत्तर देना चाहिए या केवल इस पर टिप्पणी करनी चाहिए, लेकिन आप इस समाधान को 114 बाइट्स तक आसानी से प्राप्त कर सकते हैं: यह पता चलता है कि कार्यों के बीच की नई सीमा को छोड़ा जा सकता है। सभी argumens के लिए टाइपिंग प्रकार उन्हें int (K & R लगता है) के लिए डिफ़ॉल्ट है। अगर इस तरह के बयानों को नेस्टेड टर्नरी ऑप्स के साथ लिखा जा सकता है। कोड:u(a,b){return a<2?3:b<2?pow(3,a):u(u(a-1,b),b-1);}g(a){return a<2?u(3,4):u(3,g(a-1));}main(){printf("%d",g(64));}

— अल्जाइमर

@algmyr वाह कमाल! आपको अपना उत्तर XD पोस्ट करना चाहिए।

— thepiercingarrow

2

गणितज्ञ, 59 बाइट्स

n_ ±1:=3^n
1 ±m_:=3
n_ ±m_:=((n-1)±m)±(m-1)
Nest[3±#&,4,64]

एक अपरिभाषित इन्फिक्स ऑपरेटर का उपयोग करता है ±जिसे आईएसओ 8859-1 में इनकोड करने पर केवल 1 बाइट की आवश्यकता होती है। अधिक जानकारी के लिए @ मार्टिन की पोस्ट देखें । गणितज्ञ अपने तर्कों के लिए मेल खाने वाले पैटर्न का समर्थन करते हैं, जैसे कि दो आधार मामलों को अलग-अलग परिभाषित किया जा सकता है।

— मील की दूरी पर
स्रोत

1

मैथेमेटिका ने आईएसओ 8859-1 का उपयोग कब से किया?

— लीक नून

n_ ±m_:=Nest[#±(m-1)&,3,n]

— लीक नून

2

सी, 114 109 बाइट्स

@Thepiercingarrow ( लिंक ) के उत्तर के आधार पर मैंने उत्तर को थोड़ा नीचे कर दिया। अधिकांश बचत K & R स्टाइल फ़ंक्शंस को करते समय तर्कों की डिफ़ॉल्ट टाइपिंग के दुरुपयोग के कारण होती है और यदि टर्नरी ऑपरेटरों के साथ स्टेटमेंट को बदलना होता है। पठनीयता के लिए कार्यों के बीच वैकल्पिक newlines जोड़ा गया।

109 बेहतर @LeakyNun के लिए धन्यवाद।

u(a,b){return a<2?3:b<2?pow(3,a):u(u(a-1,b),b-1);}
g(a){return u(3,a<2?4:g(a-1));}
main(){printf("%d",g(64));}

— algmyr
स्रोत

g(a){return u(3,a<2?4:g(a-1));}

— लीक नून

@LeakyNun यह वास्तव में अच्छा है। धन्यवाद।

— algmyr

1

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

v=lambda n,m:n*m and v(v(n-1,m)-1,m-1)or 3**-~n
g=lambda n=63:v(2,n and g(n-1)-1or 3)

vसमारोह में पाया एक के रूप में एक ही समारोह को परिभाषित करता है डेनिस का जवाब : v(n,m) = u(3,n+1,m+1)। gसमारोह पारंपरिक यात्रा की एक शून्य अनुक्रमित संस्करण है: g(0) = v(2,3), g(n) = v(2,g(n-1))। इस प्रकार, g(63)ग्राहम का नंबर है। फ़ंक्शन के nपैरामीटर का डिफ़ॉल्ट मान सेट करके , आवश्यक आउटपुट कॉल करके प्राप्त किया जा सकता हैg63g() (कोई मापदंडों के साथ नहीं), इस प्रकार एक फ़ंक्शन सबमिशन के लिए हमारी आवश्यकताओं को पूरा करना जो कोई इनपुट नहीं लेता है।

सत्यापित करें v(2,1) = u(3,3,2)और v(4,0) = u(3,5,1)परीक्षण मामलों ऑनलाइन: अजगर 2 , अजगर 3

— मेगो
स्रोत

1

यह सत्यापित करना कठिन है, लेकिन आपका कार्य gबंद लगता है। नहीं v(2,n-1)होना चाहिए g(n-1)या कुछ इसी तरह?

— डेनिस

@ डेनिस का अच्छा कैच। मैं ठीक कर दूँगा।

— मेगो

वास्तव में बीच में ऑफसेट uऔर vइसका मतलब यह होना चाहिए g(n-1)-1।

— एंडर्स केसरग

@AndersKaseorg मुझे नींद के समय प्रोग्रामिंग नहीं करनी चाहिए। मुझे इसे हर कुछ दिनों में फिर से सीखना होगा।

— मेगो

@AndersKaseorg भविष्य में, कृपया अन्य लोगों की प्रस्तुतियाँ संपादित न करें, भले ही यह आपके द्वारा सुझाए गए सुधार / बगफिक्स में गलती को ठीक करने के लिए हो।

— मेगो

1

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

u←{1=⍺:3⋄1=⍵:3*⍺⋄(⍵∇⍨⍺-1)∇⍵-1}
3u 3u⍣64⊣4

परीक्षण का मामला:

      3u 2
7625597484987

— lstefano
स्रोत

आपको 1=⍺:3⋄1=⍵:3*⍺सिर्फ 1=⍵:3*⍺( 3=3*1)

— ज़ाचारि जूल

1

रूबी, 64 बाइट्स

ग्राहम की संख्या की गणना करने के लिए सैद्धांतिक एल्गोरिथ्म से उधार लेना ।

def f(a,b=3)b<2?3:a<1?3*b:f(a-1,f(a,b-1))end;a=4;64.times{a=f a};p a

सीधे शब्दों में कहें, f a = u(3,3,a)और यह 64 बार लागू होता है।

— सिंपल ब्यूटीफुल आर्ट
स्रोत

क्यों और कैसे इस कोड काम करता है पर एक अच्छा विवरण अच्छा होगा।

— मनीष कुंडू

यह ग्राहम की संख्या की परिभाषा का एक सीधा अनुप्रयोग है।

— बस

0

जे, 107 बाइट्स

u=:4 :0
if.y=1 do.3^x
elseif.x=1 do.3
elseif.1 do.x:(y u~<:x)u<:y
end.
)
(g=:(3 u 4[[)`(3 u$:@<:)@.(1&<))64

मैं uएक एजेंडा में परिवर्तित करने पर काम कर रहा हूँ , लेकिन अभी के लिए यह करूँगा।

— कोनोर ओ ब्रायन
स्रोत

कुछ इस तरह u=:3^[`[:(3$:])/[#<:@]@.*@](परीक्षण नहीं किया गया)

— लीक नून

0

एफ #, 111 108 बाइट्स

संपादित करें

यह नीचे ग्राहम की संख्या को कम करने के लिए फ़ंक्शन का उपयोग कर रहा है

let rec u=function|b,1->int<|3I**b|1,c->3|b,c->u(u(b-1,c),c-1)
and g=function|1->u(3.,4.)|a->u(3.,g (a-1))
g 63

यहाँ मेरा पिछला जवाब है, जो अच्छी तरह से नहीं किया:

बहुत सीधा। uफ़ंक्शन की सिर्फ एक परिभाषा ।

let rec u=function|a,b,1->a**b|a,1.,c->a|a,b,c->u(a,u(a,b-1.,c),c-1)

उपयोग:

u(3.,3.,2)
val it : float = 7.625597485e+12

यदि मैंने मान के लिए 3 मान लिया है, तो मैं इसे 60 तक काट सकता हूं:

let rec u=function|b,1->3.**b|1.,c->3.|b,c->u(u(b-1.,c),c-1)

उपयोग:

u(3.,2)
val it : float = 7.625597485e+12

— asibahi
स्रोत

चुनौती ग्राहम का नंबर लिखना है, नहीं u। आप निश्चित रूप से किसी भी मध्यवर्ती कार्यों को शामिल कर सकते हैं, uजिनकी आपको आवश्यकता है, जैसे कि इसके पहले या इसके बिना तय किए गए 3. पर

— एंडर्स केसेर्ग

@AndersKaseorg ने संपादित किया है कि धन्यवाद। मेरी पिछली टिप्पणी गायब हो गई लगती है।

— अशीबाही

0

आर, 154 142 128 126 118 बाइट्स

u=function(n,b)return(if(n&!b)1 else if(n)u(n-1,u(n,b-1))else 3*b)
g=function(x)return(u(if(x-1)g(x-1)else 4,3))
g(64)

मैंने इस पुनरावर्ती फ़ंक्शन की विकिपीडिया परिभाषा का उपयोग किया क्योंकि किसी अजीब कारण से सुझाव दिया गया काम नहीं किया ... या मैं सिर्फ आर गोल्फिंग में चूसता हूं।

UPD: लीकेज नन के एक टिप की बदौलत 12 + 14 = 26 बाइट का मुंडन । पूर्व संस्करण ने भारी और कम कुशल का उपयोग किया

u=function(n,b)if(n==0)return(3*b)else if(n>0&b==0)return(1)else return(u(n-1,u(n,b-1)))
g=function(x)if(x==1)return(u(4,3))else return(u(g(x-1),3))

UPD: 2 + 6 + 2 और बाइट्स (फिर से, कुदोस से लीकी नून ) का मुंडन , "अगर (x = 0)" के बजाय "if (x)" के साथ एक सरल प्रतिस्थापन के कारण होता है, क्योंकि x <0 कभी नहीं खिलाया जाता है समारोह ... सही है?

— आंद्रे कोस्टीर्का
स्रोत

@LeakyNun धन्यवाद, पावती के साथ उत्तर को अपडेट किया।

— आंद्रे

बस एक सेकंड ... आज कोड गोल्फिंग का मेरा पहला दिन है, सीखने के लिए बहुत कुछ है!

— आंद्रे

आपको हमारी चैट में शामिल होने के लिए आमंत्रित किया गया है ।

— लीक नून

अधिक गोल्फिंग, कृपया सुधार देखें।

— आंद्रे

टा-डैम, किया गया, uआपके जैसे ही कुंजी में फ़ंक्शन को बदल दिया gऔर 6 और बाइट्स को बचाया - भयानक!

— आंद्रे

0

PHP, 114 बाइट्स

लाइन टूटने पर ध्यान न दें; वे केवल पठनीयता के लिए हैं।

function u($n,$m){return$m>1&$n>1?u(u($n-1,$m),$m-1):3**$n;}
function g($x){return u(3,$x>1?g($x-1):4);}
echo g(63);

दूसरे मामले को पहले एक में एकीकृत करना संभव है: के लिए n=1, 3^nबराबर 3।
यह कुछ बाइट्स को बचाएगा - जहां तक मैं देख सकता हूं - सभी मौजूदा उत्तर; मेरे पर दो बाइट्स बचाए

पिछला संस्करण, 62 + 43 + 11 = 116 बाइट्स

function u($n,$m){return$m>1?$n>1?u(u($n-1,$m),$m-1):3:3**$n;}

टर्नरी की PHP सहसंबंधीता को कोष्ठक की आवश्यकता होती है ... या परीक्षणों का एक विशिष्ट क्रम।
इससे कोष्ठक की अभिव्यक्ति पर दो बाइट बच गए।

शायद एक पुनरावृत्त दृष्टिकोण है, जो आगे गोल्फिंग की अनुमति दे सकता है ...
लेकिन मैं अब इसके लिए समय नहीं निकाल सकता।

— टाइटस
स्रोत

काश मैं सेसोस को जानता था या इसे सीखने और अभी अनुवाद करने का समय था

— टाइटस

@ लीक नन: मैंने इसे केवल छोरों और जोड़ को तोड़ दिया। क्या एक सेल में एक सेल का मूल्य दूसरे में जोड़ने का एक तरीका है?

— टाइटस

@AndersKaseorg: आप शायद सही हैं ... मुझे उस एल्गोरिथ्म को देखने से मेरी आंखों पर छाले पड़ गए। जल्द ही फिर से देखेंगे।

— तीतुस

सैद्धांतिक रूप से ग्राहम का नंबर आउटपुट

संदर्भ

लीडरबोर्ड

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

व्याख्या

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

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

पायथ, 25 बाइट्स

सेसोस , 30 बाइट्स

disassembled

परिक्षण

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

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

व्याख्या

कारमेल , 38 बाइट्स

प्रोलॉग (SWIPL), 129/137 बाइट्स

परीक्षा

Ungolfed

सी, 161 बाइट्स

गणितज्ञ, 59 बाइट्स

सी, 114 109 बाइट्स

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

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

रूबी, 64 बाइट्स

जे, 107 बाइट्स

एफ #, 111 108 बाइट्स

संपादित करें

आर, 154 142 128 126 118 बाइट्स

PHP, 114 बाइट्स