Grahams Nummer Gwird folgendermaßen definiert:

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)

Sie erhalten das u(3,3,2)=7625597484987, um Ihren Code zu überprüfen.

Ihre Aufgabe ist es, ein Programm / eine Funktion zu schreiben, das / die den Wert von Gdeterministisch ausgibt , vorausgesetzt, dass genügend Integer-Größe und genügend Zeit vorhanden sind.

Verweise

• Grahams Nummer
• Knuths Pfeil nach oben
• Conway verkettete Pfeilnotation

Bestenliste

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>

Binäre Lambda-Rechnung , 114 Bits = 14,25 Bytes

Hexdump:

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

Binär:

010001000101011101000010101100000010110110001000000111111001110101110100000011100101111011010000001110011100111010

Erläuterung

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

Dies ist (λ 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, wobei alle Zahlen als Kirchenzahlen dargestellt werden. Kirchenzahlen sind die Standard-Lambda-Kalkül-Darstellung natürlicher Zahlen und eignen sich gut für dieses Problem, da eine Kirchenzahl durch Funktionsiteration definiert wird: n g ist die n- te Iteration der Funktion g .

Wenn zum Beispiel g die Funktion λ n ist . λ f . 3 ( n f ), die 3 mit einer Kirchenzahl multipliziert, dann λ n . n g 1 ist die Funktion, die 3 zur Potenz einer Kirchenzahl macht. Durch m- maliges Wiederholen dieser Operation erhält man

m (λ g . λ n . n g 1) (λ n . λ f . 3 ( n f )) n = U (3, n , m ).

(Wir verwenden die Multiplikation u (-, -, 0) anstelle der Potenzierung u (-, -, 1) als Basisfall, weil es unangenehm ist, 1 von einer Kirchenzahl zu subtrahieren .)

Ersatz n = 3:

m (& lgr; g . & lgr; n . n g 1) (& lgr; n . & lgr; f . 3 ( n f )) 3 = u (3, 3, m ).

64-maliges Iterieren dieser Operation, beginnend mit m = 4, ergibt

64 (λ m . M (λ g . Λ n . N g 1) (λ n . Λ f . 3 ( n f )) 3) 4 = G .

Um diesen Ausdruck zu optimieren, ersetzen Sie 64 = 4 ^ 3 = 3 4:

3 4 (λ m . M (λ g . Λ n . N g 1) (λ n . Λ f . 3 ( n f )) 3) 4 = G .

Denken Sie daran, 4 = succ 3 = λ f . λ z . f (3 f z ) als Lambda-Argument:

(λ y . 3 y (λ m . m (λ g . λ n . n g 1) (λ n . λ f . 3 ( n f )) 3) y ) (λ f . λ z . f (3 f z )) = G .

Erinnern Sie sich schließlich an 3 = λ f . λ z . f ( f ( f z )) als Lambda-Argument:

(λ 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 = G .

Haskell, 41 Bytes

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

Erläuterung:

(`i`1)f n= i f 1 nberechnet die nIteration der Funktion fab 1. Insbesondere ergibt (`i`1)(*3)n= 3 ^ n und m- maliges Iterieren dieser Konstruktion i(`i`1)(*3)m n= u (3, n , m ). Wir können neu zu schreiben , daß als (($n).i(`i`1)(*3))m= U (3, n , m ) und iterieren diese Konstruktion k mal zu erhalten i(($3).i(`i`1)(*3))4 k= g _ k .

Haskell, 43 Bytes

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

Es gibt einen besseren Weg, um gInline umzudrehen.

46 Bytes:

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

48 Bytes:

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

Schreiben Sie einfach die Definitionen auf.

Die Basisfälle sind ein bisschen sauberer bis 0 gesichert, obwohl es keine Bytes spart. Vielleicht wird es einfacher, eine alternative Definition zu schreiben.

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

Pyth, 25 Bytes

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

Der erste Teil M?H.UgbtH*G]3^3Gdefiniert eine Methode g(G,H) = u(3,G,H+1).

Um den ersten Teil zu testen, prüfen Sie, ob 7625597484987=u(3,3,2)=g(3,1): g3 1.

Der zweite Teil ug3tG64 4beginnt mit der 64-fachen r0 = 4Berechnung rn = u(3,3,r(n-1)) = g(3,r(n-1))und gibt den endgültigen Wert aus ( rwird gewählt g, um Verwechslungen zu vermeiden).

Um diesen Teil zu testen, starten aus r0=2und dann berechnen r1: ug3tG1 2.

Sesos , 30 Bytes

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

Zerlegt

set numout
add 4
rwd 2
add 64
jmp
    sub 1
    fwd 3
    add 3
    rwd 1
    add 1
    jmp
        sub 1
        jmp
            fwd 1
            jmp
                jmp
                    sub 1
                    fwd 1
                    add 1
                    rwd 1
                jnz
                rwd 1
                jmp
                    sub 1
                    fwd 3
                    add 1
                    rwd 3
                jnz
                fwd 3
                jmp
                    sub 1
                    rwd 2
                    add 1
                    rwd 1
                    add 1
                    fwd 3
                jnz
                rwd 1
                sub 1
            jnz
            rwd 1
            jmp
                sub 1
            jnz
            add 1
            rwd 1
            sub 1
        jnz
        fwd 1
        jmp
            sub 1
            rwd 1
            add 3
            fwd 1
        jnz
        rwd 2
    jnz
    rwd 1
jnz
fwd 2
put

Oder in Brainfuck-Notation:

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

Testen

Zu berechnen , u (3, n , U (3, n , ... u (3, n , m ) ...)) mit k verschachtelt Anrufen u , ersetzen die ersten drei addBefehle add 4, add 64, add 3mit add m, add k, add n, respectively. Da Sesos keine Zahlen schneller als in linearer Zeit erstellen kann, sind Sie praktisch auf kleine Werte wie u (3, 2, 2) = 27, u (3, 5, 1) = 243 und u (3, 1) beschränkt , u (3, 1, ... u (3, 1, m ) ...)) = 3.

JavaScript (ES7), 63 Byte

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)

Brachylog , 57 Bytes

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

Erwartet keine Eingabe oder Ausgabe und schreibt das Ergebnis in STDOUT. Dies führt an einer Stelle zu einem Stapelüberlauf.

Um zu überprüfen, ob dies für kleine Werte (z. B. u(3,3,2)) funktioniert , können Sie 4den Wert durch den Wert von mund 64durch ersetzen 1.

Erläuterung

Dies ist im Grunde eine einfache Implementierung der erläuterten Methode zur Berechnung der Zahl.

• Hauptprädikat:

  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
  

• Prädikat 1:

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

• Prädikat 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)
  

Karamell , 38 Bytes

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

Dies ist syntaktischer Zucker für den Lambda-Kalkül-Ausdruck 64 (λ m . M (λ f . Λ n . N f 1) (λ n . Λ f . 3 ( n f )) 3) 4, in denen alle Zahlen als dargestellt werden Church Ziffern .

Prolog (SWIPL), 129/137 Bytes

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

Um Grahams Nummer auszugeben, fragen Sie nach g(64,G).(wenn die 8 Bytes dieser Abfrage gezählt werden sollen, beträgt die Länge 137 Bytes):

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

Aber wie zu erwarten ist, geht dieser Stapel aus.

Prüfung

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

Backtracking führt dazu, dass der Stack ausgeht:

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

Ungolfed

Die ungolfed-Version fügt die allgemeine Aufwärtspfeilnotation hinzu, nicht nur für 3, und verwendet Schnitte und Überprüfungen, um ein Zurückverfolgen und undefinierte Situationen zu vermeiden.

% 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).

C 161 Bytes

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

BEARBEITEN: 11 Bytes durch Entfernen von Tabulatoren und Zeilenumbrüchen gespart. BEARBEITEN: thx auhmann hat ein weiteres byte gespeichert und mein programm repariert

Mathematica, 59 Bytes

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

Verwendet einen undefinierten Infix-Operator, ±der nur 1 Byte benötigt, wenn er in ISO 8859-1 codiert ist. Siehe @ Martins Beitrag für weitere Informationen. Mathematica-Funktionen unterstützen den Mustervergleich für ihre Argumente, sodass die beiden Basisfälle separat definiert werden können.

C, 114 109 Bytes

Basierend auf der Antwort von @thepiercingarrow ( Link ) habe ich die Antwort ein bisschen heruntergespielt. Die meisten Einsparungen ergeben sich aus dem Missbrauch der Standard-Typisierung von Argumenten beim Ausführen von K & R-Funktionen und dem Ersetzen von if-Anweisungen durch ternäre Operatoren. Optionale Zeilenumbrüche zwischen den Funktionen zur besseren Lesbarkeit hinzugefügt.

Dank @LeakyNun auf 109 verbessert.

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

Python, 85 Bytes

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)

Die vFunktion definiert die gleiche Funktion wie die in gefunden Dennis Antwort : v(n,m) = u(3,n+1,m+1). Die gFunktion ist eine Null-indizierte Version der traditionellen Iteration: g(0) = v(2,3), g(n) = v(2,g(n-1)). Somit g(63)ist Grahams Nummer. Durch Setzen des Standardwerts des nParameters der gFunktion auf 63kann die gewünschte Ausgabe durch Aufrufen erhalten werdeng() (ohne Parameter) erhalten werden, wodurch unsere Anforderungen für eine Funktionsübergabe erfüllt werden, für die keine Eingabe erforderlich ist.

Überprüfen Sie die v(2,1) = u(3,3,2)und v(4,0) = u(3,5,1)testen Sie die Fälle online: Python 2 , Python 3

Dyalog APL, 41 Bytes

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

Testfall:

      3u 2
7625597484987

Ruby, 64 Bytes

Ausleihen aus dem theoretischen Algorithmus zur Berechnung von Grahams Zahl .

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

Einfach ausgedrückt, f a = u(3,3,a)und es gilt dies 64 Mal.

J, 107 Bytes

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

Ich arbeite daran, uauf eine Agenda umzusteigen, aber im Moment reicht es.

F #, 111 108 Bytes

Bearbeiten

Dies benutzt die unten stehende Funktion, um Grahams Nummer zu berechnen

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

Hier ist meine vorherige Antwort, die es nicht tat:

Ziemlich einfach. Nur eine Definition der uFunktion.

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)

Verwendungszweck:

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

Wenn ich 3 als Wert für a annehmen würde, könnte ich es auf 60 reduzieren:

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

Verwendungszweck:

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

R, 154 142 128 126 118 Bytes

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)

Ich habe die Wikipedia-Definition für diese rekursive Funktion verwendet, weil aus irgendeinem Grund die vorgeschlagene Funktion nicht funktioniert hat ... oder ich habe nur Spaß am R-Golf.

UPD: Abgeschnitten von 12 + 14 = 26 Bytes dank eines Tipps von Leaky Nun . Die Vorgängerversion verwendete das sperrige und weniger leistungsfähige

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 weitere Bytes wurden abgeschnitten (erneut ein Lob an Leaky Nun ), da "if (x)" anstelle von "if (x == 0)" verwendet wurde, da x <0 nie eingegeben wird die Funktion ... richtig?

PHP, 114 Bytes

ignoriere die Zeilenumbrüche; Sie dienen nur der Lesbarkeit.

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

Es ist möglich, den zweiten Fall in den ersten zu integrieren: for n=1, 3^nequals 3.
Dies spart ein paar Bytes bei - soweit ich sehen kann - allen vorhandenen Antworten; sparte zwei Bytes auf meinem

vorherige Version, 62 + 43 + 11 = 116 Bytes

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

Die linke Assoziativität von PHP zum Ternären erfordert Klammern ... oder eine bestimmte Testreihenfolge.
Dies sparte zwei Bytes im Ausdruck in Klammern.

Es ist wahrscheinlich ein iterativer Ansatz, der kann weiter Golf spielen lassen ...
aber ich kann nicht jetzt es die Zeit nehmen.