Theoretisch Grahams Zahl ausgeben

44

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

Bestenliste

Code-Snippet anzeigen

code-golf number-theory Undichte Nonne
quelle
2
Verwandte .
Undichte Nonne
7
Ist Zufall erlaubt? Wenn ich nur zufällige Werte ausgebe, muss irgendwann Grahams Zahl erzeugt werden.
Meilen
15
@miles Warum um alles in der Welt ist es nicht schon eine Standardlücke? Geklärt.
Undichte Nonne
18
Warnung: u (3, 3, 2) = u (3, 2, 3) = 7625597484987, daher sollten Sie auch andere Werte wie u (3, 5, 1) = 243 testen, um sicherzustellen, dass Sie erhalten das Argument Reihenfolge richtig.
Anders Kaseorg
2
Grahams Nummer?
Beta Decay

Antworten:

48

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 .

Anders Kaseorg
quelle
Wo kann man einen Dolmetscher für diese Sprache finden?
Dennis
4
@ Tennis tromp.github.io/cl/cl.html hat ein paar von ihnen.
Anders Kaseorg
1
Das ist großartig . Dies verdient ein beträchtliches Kopfgeld
Katze
1
14.25 bytesscheint die Bestenliste durcheinander zu bringen. Es wird analysiert als 25 bytes, und Sie werden daher als zweiter platziert.
Dan
1
@Dan ich habe das Leaderboard-Snippet repariert, denke ich.
Anders Kaseorg
40

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 .

Anders Kaseorg
quelle
16

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
xnor
quelle
Können Sie eine andere Funktion mit niedrigerer Priorität verwenden +, um die Klammern dazwischen zu entfernen m-1?
Undichte Nonne
Ich zähle 44 Bytes und was ist mit 4 und 64 passiert?
Undichte Nonne
Hoppla, ich habe in meinem Test mit kleineren Parametern kopiert. Ich glaube nicht, dass ich die Operatorpriorität ändern kann, da ich eine neue Funktion definiere und diese eine Standardpriorität haben. Ich kann eine vorhandene Funktion nicht überschreiben.
Xnor
Ich meine, ich zähle 44 Bytes, nachdem Sie es wieder auf 64 geändert haben.
Undichte Nonne
Ich denke du meinst (`g`3), nicht (3`g`).
Anders Kaseorg
10

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.

Undichte Nonne
quelle
Wenn g (G, H) = u (3, G, H + 1) ist, sollte r (n) = u (3, 3, r (n - 1)) = g (3, r (n - 1) ) - 1), nicht g (3, r (n - 1)). Ich denke, Ihr Code ist richtig, aber Ihrer Erklärung fehlt der - 1.
Anders Kaseorg
Sie können ein Byte speichern, indem Sie nicht versetzte u-Argumente ( ^3↦ *3, tG↦ G) und ein anderes Byte mit .UgbtH*G]3↦ verwenden e.ugNtHG1.
Anders Kaseorg
Eine alternative Möglichkeit, dieses zweite Byte zu speichern, ist *G]3↦ ShG.
Anders Kaseorg
8

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.

Anders Kaseorg
quelle
Sie können ersetzen [-]mit ,seit EOF ist 0.
mbomb007
6

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)
Neil
quelle
@AndersKaseorg Ugh, in diesem Fall könnte ich diese Änderung genauso gut rückgängig machen.
Neil
Dies führt zu einem Stapelüberlauf. Möglicherweise muss Ihr Rekursionsmuster erneut überprüft werden.
NodeNodeNode
Dies ist nicht einfach ES7. Dies ist unbeschränktes ES7 (eine imaginäre Variante von ES7, aber mit Bignum, das unendlich viel Orakel kann und Dezimalzahlen mit / # xE ^ als Kürzel verwendet).
User75200
5

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)
Tödlich
quelle
5

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 .

Anders Kaseorg
quelle
(n f->3 (n f))sollte es nicht lesen n-1?
Undichte Nonne
@LeakyNun No. (n f->3 (n f))ist eine Funktion zur Multiplikation mit drei in den Ziffern der Kirche .
Anders Kaseorg
2
Diese Herausforderung scheint im Lambda-Kalkül übermäßig einfach zu sein. Warum?
Katze
3

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).
SQB
quelle
Wie haben Sie es geschafft, ohne die Nummer 64irgendwo in Ihrem Code zu haben?
Undichte Nonne
@LeakyNun habe ich bearbeitet, um zu klären; besser?
SQB
Nun, dann fügen Sie es Ihrem Code sowie Ihrer Byteanzahl hinzu.
Undichte Nonne
3

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

thepiercingarrow
quelle
1
Sie könnten es entfernen, g(int a){if(a==1)return u(3,4);return g(a-1);}da es überhaupt nicht verwendet wird ... Oder vergessen Sie etwas?
Auhmaan
@auhmaan Hoppla, ich habe diese Nummer zum Testen verwendet und vergessen, sie zurück zu ändern. Vielen Dank!!
Thepiercingarrow
Du return g(a-1)solltest sein return u(3,g(a-1)).
Anders Kaseorg
1
Ich weiß nicht, ob ich eine richtige Antwort geben oder dies nur kommentieren soll, aber Sie können diese Lösung ganz einfach auf 114 Bytes reduzieren, indem Sie Folgendes realisieren: Zeilenumbrüche zwischen Funktionen können weggelassen werden. Das Weglassen von Typen für alle Argumene setzt sie standardmäßig auf int (denken Sie an K & R). Wenn solche Anweisungen mit verschachtelten ternären Operationen geschrieben werden können. Code: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
@algmyr wow super! du solltest deine eigene Antwort posten XD.
Thepiercingarrow
2

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.

Meilen
quelle
1
Seit wann verwendet Mathematica ISO 8859-1?
Undichte Nonne
n_ ±m_:=Nest[#±(m-1)&,3,n]
Undichte Nonne
2

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));}
Algmyr
quelle
g(a){return u(3,a<2?4:g(a-1));}
Undichte Nonne
@LeakyNun Das ist wirklich gut. Vielen Dank.
Algmyr
1

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

Mego
quelle
1
Es ist ein bisschen schwer zu überprüfen, aber Ihre Funktion gscheint aus. Sollte nicht v(2,n-1)sein g(n-1)oder etwas ähnliches?
Dennis
@ Tennis Guter Fang. Ich werde das reparieren.
Mego
Tatsächlich bedeutet der Versatz zwischen uund, vdass es sein sollte g(n-1)-1.
Anders Kaseorg
@AndersKaseorg Ich sollte nicht im Schlaf programmieren. Das muss ich alle paar Tage neu lernen.
Mego
@AndersKaseorg In Zukunft sollten Sie die Beiträge anderer nicht mehr bearbeiten, auch wenn Sie einen Fehler in einer von Ihnen vorgeschlagenen Verbesserung / Fehlerbehebung beheben möchten.
Mego
1

Dyalog APL, 41 Bytes

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

Testfall:

      3u 2
7625597484987
lstefano
quelle
Sie sollten in der Lage sein, um 1=⍺:3⋄1=⍵:3*⍺nur 1=⍵:3*⍺( 3=3*1)
Zacharý
1

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.

Einfach schöne Kunst
quelle
Eine gute Erklärung, warum und wie dieser Code funktioniert, wäre schön.
Manish Kundu
Es ist eine einfache Anwendung der Definition von Grahams Zahl.
Einfach schön Kunst
0

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.

Conor O'Brien
quelle
So etwas wie u=:3^[`[:(3$:])/[#<:@]@.*@](nicht getestet)
Leaky Nun
0

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
Asibahi
quelle
Die Herausforderung besteht darin, Grahams Nummer zu schreiben, nicht u. Natürlich können Sie auch Zwischenfunktionen einfügen, z. B. umit oder ohne das erste Argument, das auf 3 festgelegt ist.
Anders Kaseorg,
@AndersKaseorg hat das in bearbeitet. Danke. Mein vorheriger Kommentar scheint verschwunden zu sein.
Asibahi
0

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?

Andreï Kostyrka
quelle
@LeakyNun Vielen Dank, die Antwort wurde mit Bestätigung aktualisiert.
Andreï Kostyrka
Nur eine Sekunde ... Heute ist mein erster Tag mit Code-Golfen. Es gibt viel zu lernen!
Andreï Kostyrka
Sie sind herzlich eingeladen, an unserem Chat teilzunehmen .
Undichte Nonne
Mehr Golf, bitte sehen Sie die Verbesserung.
Andreï Kostyrka
Ta-dam, fertig, hat die Funktion uin der gleichen Taste wie Ihre geändert gund 6 weitere Bytes gespeichert - großartig!
Andreï Kostyrka
0

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.

Titus
quelle
Ich wünschte, ich wüsste Sesos oder hätte die Zeit, es zu lernen und sofort zu übersetzen
Titus
@Leaky Nun: Ich habe es auf nur Schleifen und Addition heruntergebrochen. Gibt es in Sesos eine Möglichkeit, den Wert einer Zelle einer anderen hinzuzufügen?
Titus
@AndersKaseorg: Wahrscheinlich hast du recht ... Ich habe Blasen auf meinen Augäpfeln, als ich diesen Algorithmus angeschaut habe. Werde es mir bald nochmal ansehen.
Titus