O número de Graham Gé definido desta maneira:

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)

Você tem que u(3,3,2)=7625597484987verificar seu código.

Sua tarefa é escrever um programa / função que produzirá o valor de Gdeterministicamente, considerando tamanho inteiro suficiente e tempo suficiente.

Referências

• Número de Graham
• Notação de seta para cima de Knuth
• Notação de seta acorrentada Conway

Entre os melhores

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>

Cálculo lambda binário , 114 bits = 14,25 bytes

Hexdump:

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

Binário:

010001000101011101000010101100000010110110001000000111111001110101110100000011100101111011010000001110011100111010

Explicação

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

Isto é (λ 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, onde todos os números são representados como números da Igreja. Os números da igreja são a representação padrão do cálculo lambda dos números naturais e são adequados para esse problema porque um número da igreja é definido pela iteração da função: n g é a n- ésima iteração da função g .

Por exemplo, se g é a função λ n . λ f . 3 ( n f ) que multiplica 3 por um número da Igreja, então λ n . n g 1 é a função que leva 3 ao poder de um numeral da Igreja. Iterar esta operação m vezes fornece

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

(Usamos a multiplicação u (-, -, 0) em vez da exponenciação u (-, -, 1) como o caso base, porque subtrair 1 de um numeral da Igreja é desagradável .)

Substituto n = 3:

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

Iterando essa operação 64 vezes, iniciando em m = 4, fornece

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

Para otimizar essa expressão, substitua 64 = 4 ^ 3 = 3 4:

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

Lembre-se de 4 = succ 3 = λ f . λ z . f (3 f z ) como argumento lambda:

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

Finalmente, lembre-se de 3 = λ f . λ z . f ( f ( f z )) como argumento lambda:

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

Haskell, 41 bytes

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

Explicação:

(`i`1)f n= i f 1 ncalcula a niteração da função finiciando em 1. Em particular, (`i`1)(*3)n= 3 ^ n , e a iteração dessa construção m vezes fornece i(`i`1)(*3)m n= u (3, n , m ). Podemos reescrever que quanto (($n).i(`i`1)(*3))m= u (3, n , m ), e repita essa construção k vezes para obter 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

Existe uma maneira melhor de ginline.

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

Apenas anotando as definições.

Os casos base são um pouco mais limpos, com backup de 0, embora não salvem bytes. Talvez seja mais fácil escrever uma definição alternativa.

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

Pitão, 25 bytes

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

A primeira parte M?H.UgbtH*G]3^3Gdefine um método g(G,H) = u(3,G,H+1).

Para testar a primeira parte, verifique se 7625597484987=u(3,3,2)=g(3,1): g3 1.

A segunda parte ug3tG64 4começa r0 = 4e depois calcula rn = u(3,3,r(n-1)) = g(3,r(n-1))64 vezes, produzindo o valor final ( ré escolhido em vez de gevitar confusão).

Para testar esta parte, comece a partir r0=2e depois calcular 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.{

Desmontado

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

Ou na notação Brainfuck:

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

Testando

Para calcular u (3, n , L (3, n , ... u (3, n , m ) ...)) com k aninhados chamadas para u , substituir as três primeiras addinstruções add 4, add 64, add 3com add m, add k, add n, respectivamente. Como o Sesos não pode construir números mais rapidamente do que no tempo linear, você está praticamente limitado a pequenos valores como u (3, 2, 2) = 27, u (3, 5, 1) = 243 e u (3, 1 , u (3, 1,… u (3, 1, m )…)) = 3.

JavaScript (ES7), 63 bytes

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)

Braquilog , 57 bytes

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

Não espera entrada nem saída e grava o resultado em STDOUT. Isso produzirá um estouro de pilha em um ponto.

Para verificar se isso funciona com valores pequenos (por exemplo u(3,3,2)), você pode substituir o 4com o valor de me 64com 1.

Explicação

Essa é basicamente uma implementação direta da maneira explicada de calcular o número.

• Predicado principal:

  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
  

• Predicado 1:

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

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

Caramelo , 38 bytes

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

Este é um açúcar sintático para a expressão de cálculo lambda 64 (λ m . M (λ f . Λ n . N f 1) (λ n . Λ f . 3 ( n f )) 3) 4, onde todos os números são representados como Igreja numerais .

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

Para gerar o número de Graham, consulte g(64,G).(se os 8 bytes dessa consulta devem ser contados, o comprimento é de 137 bytes):

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

Mas, como é de se esperar, isso fica sem pilha.

Teste

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

Voltar atrás faz com que fique sem pilha:

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

Ungolfed

A versão ungolfed adiciona a notação geral da seta para cima, não apenas para 3, e usa cortes e verificações para evitar retroceder e situações indefinidas.

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

EDIT: salvou 11 bytes removendo guias e novas linhas. EDIT: thx auhmann salvou outro byte e corrigiu meu programa

Mathematica, 59 bytes

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

Usa um operador infixo indefinido ±que requer apenas 1 byte quando codificado na ISO 8859-1. Veja a publicação de @ Martin para mais informações. As funções do Mathematica suportam a correspondência de padrões para seus argumentos, de modo que os dois casos base possam ser definidos separadamente.

C, 114 109 bytes

Com base na resposta de @thepiercingarrow ( link ), reduzi bastante a resposta. A maioria das economias se deve ao abuso da digitação padrão de argumentos ao executar funções no estilo K&R e à substituição de instruções if por operadores ternários. Adicionadas novas linhas opcionais entre funções para facilitar a leitura.

Aprimorado para 109 graças a @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));}

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)

A vfunção define a mesma função que o encontrado na resposta de Dennis : v(n,m) = u(3,n+1,m+1). A gfunção é uma versão zero indexada da iteração tradicional: g(0) = v(2,3), g(n) = v(2,g(n-1)). Assim, g(63)é o número de Graham. Ao definir o valor padrão do nparâmetro da gfunção como 63, a saída necessária pode ser obtida chamando g()(sem parâmetros), atendendo assim aos nossos requisitos para o envio de uma função que não requer entrada.

Verifique os casos de teste v(2,1) = u(3,3,2)e v(4,0) = u(3,5,1)online: Python 2 , Python 3

Dyalog APL, 41 bytes

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

Caso de teste:

      3u 2
7625597484987

Ruby, 64 bytes

Empréstimo do algoritmo teórico para calcular o número de Graham .

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

Simplificando, f a = u(3,3,a)e isso se aplica 64 vezes.

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

Estou trabalhando na conversão upara uma agenda, mas por enquanto isso serve.

F #, 111 108 bytes

Editar

Isso está usando a função abaixo para calcular o número de Graham

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

Aqui está a minha resposta anterior que, bem, não:

Bem direto. Apenas uma definição da ufunção.

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)

Uso:

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

Se eu assumisse 3 como o valor de a, poderia reduzi-lo para 60:

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

Uso:

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)

Eu usei a definição da Wikipedia dessa função recursiva porque, por alguma razão estranha, a sugerida não funcionou ... ou simplesmente sou péssima no golfe R.

UPD: raspou 12 + 14 = 26 bytes graças a uma dica da Leaky Nun . A versão anterior usava o volumoso e menos eficiente

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: raspou mais 2 + 6 + 2 bytes (novamente, parabéns a Leaky Nun ) devido a uma substituição engenhosa de “if (x)” em vez de “if (x == 0)” porque x <0 nunca é alimentado a função ... certo?

PHP, 114 bytes

ignore as quebras de linha; eles são apenas para legibilidade.

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

É possível integrar o segundo caso no primeiro: for n=1, 3^nigual 3.
Isso economizará alguns bytes em - até onde eu posso ver - todas as respostas existentes; salvou dois bytes no meu

versão anterior, 62 + 43 + 11 = 116 bytes

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

A associatividade esquerda do ternário do PHP requer parênteses ... ou uma ordem específica de testes.
Isso salvou dois bytes na expressão entre parênteses.

Provavelmente existe uma abordagem iterativa, que pode permitir mais golfe ...
mas não posso reservar um tempo para isso agora.