Alguns de vocês podem estar familiarizados com o BigNum Bakeoff , que acabou sendo bastante interessante. O objetivo pode ser resumido mais ou menos como escrever um programa em C cuja saída seria a maior, sob algumas restrições e condições teóricas, por exemplo, um computador que poderia executar o programa.

No mesmo espírito, estou apresentando um desafio semelhante aberto a todas as línguas. As condições são:

• 512 bytes no máximo .

• O resultado final deve ser impresso em STDOUT. Esta é a sua pontuação. Se vários números inteiros forem impressos, eles serão concatenados.

• A saída deve ser um número inteiro. (Nota: O infinito não é um número inteiro .)

• Nenhuma constante interna maior que 10, mas números / dígitos são bons (por exemplo, a constante de Avogadro (como uma constante interna) é inválida, mas 10000 não é.)

• O programa deve terminar quando houver recursos suficientes para ser executado.

• A saída impressa deve ser determinística quando houver recursos suficientes para ser executada.

• Você recebe números inteiros ou bigints suficientes para o seu programa executar. Por exemplo, se o seu programa exigir a aplicação de operações básicas a números menores que ^10.000.000 , você pode assumir que o computador executando isso pode lidar com números de pelo menos ^10.000.000 . (Observação: seu programa também pode ser executado em um computador que lida com números de até ^10.000.000 , portanto, simplesmente chamar o número inteiro máximo que o computador pode manipular não resultará em resultados determinísticos.)

• Você recebe energia computacional suficiente para o seu programa concluir a execução em menos de 5 segundos. (Portanto, não se preocupe se o seu programa estiver em execução há uma hora no seu computador e não for concluído tão cedo.)

• Como não há recursos externos, não pense em importar a função Ackermann, a menos que seja interna.

Todos os itens mágicos estão sendo emprestados temporariamente de uma divindade generosa.

Extremamente grande com limite desconhecido

• Steven H , Pyth f _{3 + B³F + ω²} (256 ²⁶ )

onde B³F é o ordinal Church-Kleene com a sequência fundamental de

B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F

Entre os melhores:

1. Arte Simplesmente Bela , Ruby f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

2. Steven H , Pyth f _{ψ (Ω ^Ω ) + ω² + 183} (256 ^27! )

3. Freira com vazamento , Python 3 f _{ε 0} (9 ^{9 9} )

4. fejfo , Python 3 f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999))

5. Steven H , Python 3 f _{ω ^ω + ω²} (9 ^{9 9 99} )

6. Arte Simplesmente Bela , Ruby f _{ω + 35} (9 ^{9 99} )

7. i .. , Python 2 , f ₃ (f ₃ (141))

Algumas notas laterais:

Se não podemos verificar sua pontuação, não podemos colocá-la na tabela de classificação. Então, você pode querer explicar um pouco o seu programa.

Da mesma forma, se você não entender o tamanho do seu número, explique seu programa e tentaremos resolvê-lo.

Se você usar um tipo de programa do Loader , colocarei você em uma categoria separada chamada "Extremamente grande com limite desconhecido" , pois o número do Loader não possui um limite superior não trivial em termos da hierarquia de rápido crescimento para ' seqüências fundamentais do padrão.

Os números serão classificados pela hierarquia de rápido crescimento .

Para aqueles que gostariam de aprender a usar a hierarquia de rápido crescimento para aproximar números realmente grandes, estou hospedando um servidor Discord apenas para isso. Há também uma sala de bate-papo: Ordinality .

Desafios semelhantes:

Maior número imprimível

Golf um número maior que a TREE (3)

Programa de terminação mais curto, cujo tamanho de saída excede o número de Graham

Para aqueles que querem ver alguns programas simples que geram uma hierarquia de rápido crescimento para valores pequenos, aqui estão eles:

Ruby: hierarquia em rápido crescimento

#f_0:
f=->n{n+=1}

#f_1:
f=->n{n.times{n+=1};n}

#f_2:
f=->n{n.times{n.times{n+=1}};n}

#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}

#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}

#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}

#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}

#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}

#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}

etc.

Para passar de f_xpara f_(x+1), adicionamos um loop do n.times{...}.

Caso contrário, estamos diagonalizando contra todos os anteriores, por exemplo

f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)

f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)

etc.

Ruby, f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

onde M é o primeiro Mahinal 'ordinal', X é a função chi (função de colapso do Mahlo) e ψ é a função de colapso do ordinal.

f=->a,n,b=a,q=n{c,d,e=a;!c ?[q]:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]};(x=9**9**9).times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{h=[];x.times{h=[h,h,h]};h=[[-1,1,[h]]];h=f[h,p x*=x]until h!=0}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

Experimente online!

Repartição do código:

f=->a,n,b=a,q=n{          # Declare function
                c,d,e=a;          # If a is an integer, c=a and d,e=nil. If a is an array, a=[c,d,e].compact, and c,d,e will become nil if there aren't enough elements in a (e.g. a=[1] #=> c=1,d=e=nil).
                        !c ?[q]:          # If c is nil, return [q], else
                                a==c ?a-1:          # If a==c, return a-1, else
                                          e==0||e&&d==0?c:          # If e==0 or e is not nil and d==0, return c, else
                                                          e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:          # If e is not nil, return an array inside an array, else
                                                                                             n<1?9:          # If n<1, return 9, else
                                                                                                   !d ?[f[b,n-1],c]:          # If d is nil, return [f[b,n-1],c], else
                                                                                                                    c==0?n:          # If c==0, return n, else
                                                                                                                           [t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]          # t=[f[c,n],d]. If c==-1, return [t,n,[]], else if d==0, return [t,n,n], else return [t,n,[f[d,n,b,t]]].
                                                                                                                                                                        };          # End of function
                                                                                                                                                                          (x=9**9**9)          # Declare x
                                                                                                                                                                                     x.times{...}          # Looped within 33 x.times{...} loops
                                                                                                                                                                                                 h=[];          # Declare h
                                                                                                                                                                                                      x.times{h=[h,h,h]};          # Nest h=[h,h,h] x times
                                                                                                                                                                                                                         h=f[h,p x*=x]          # Apply x*=x, print x, then h=f[h,x]
                                                                                                                                                                                                                                      until h==0          # Repeat previous line until h==0

Divisão Matemática:

freduz com abase em n,b,q.

A idéia básica é ter um extremamente aninhado ae reduzi-lo repetidamente até reduzir para baixo a=0. Para simplificar, deixe

g[0,n]=n
g[a,n]=g[f[a,n],n+1]

Por enquanto, vamos nos preocupar apenas n.

Para qualquer número inteiro k, obtemos f[k,n]=k-1, para que possamos ver que

g[k,n]=n+k

Temos, então, para qualquer d, f[[0,d],n]=npara que possamos ver que

g[[0,d],n]
= g[f[[0,d],n],n+1]
= g[n,n+1]
= n+n+1

Temos, então, para qualquer c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Por exemplo,

g[[[0,d],0,e],n]
= g[f[[[0,d],0,e]],n+1]
= g[[0,d],n+1]
= (n+1)+(n+1)+1
= 2n+3

Temos, então, para c,d,eque tal não se enquadre no caso anterior f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e],. É aqui que começa a ficar complicado. Alguns exemplos:

g[[[0,d],1,1],n]
= g[f[[[0,d],1,1],n],n+1]
= g[[[0,d],1,0],0,[0,d]],n+1]
= g[f[[[0,d],1,0],0,[0,d]],n+1],n+2]
= g[[[0,d],1,0],n+2]
= g[f[[[0,d],1,0],n+2],n+3]
= g[[0,d],n+3]
= (n+3)+(n+3)+1
= 2n+7

#=> Generally g[[[0,d],1,k],n] = 2n+4k+3

g[[[0,d],2,1],n]
= g[f[[[0,d],2,1],n],n+1]
= g[[[[0,d],2,0],1,[0,d]],n+1]
= g[f[[[[0,d],2,0],1,[0,d]],n+1],n+2]
= g[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2]
= g[f[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2],n+3]
= g[[[[0,d],2,0],1,n+1],n+3]
= ...
= g[[[0,d],2,0],3n+6]
= g[f[[[0,d],2,0],2n+6],3n+7]
= g[[0,d],3n+7]
= (3n+7)+(3n+7)+1
= 6n+15

Ele rapidamente sobe a partir daí. Alguns pontos de interesse:

g[[[0,d],3,[0,d]],n] ≈ Ack(n,n), the Ackermann function
g[[[0,d],3,[[0,d],0,0]],63] ≈ Graham's number
g[[[0,d],5,[0,d]],n] ≈ G(2^^n), where 2^^n = n applications of 2^x, and G(x) is the length of the Goodstein sequence starting at x.

Eventualmente, a introdução de mais argumentos da ffunção e de mais casos para a matriz nos permite superar a maioria das notações computáveis ​​nomeadas. Alguns particularmente conhecidos:

g[[[0],3,[0,d]],n] ≈ tree(n), the weak tree function
g[[[[0],3,[0,d]],2,[0,d]],n] ≈ TREE(n), the more well-known TREE function
g[[[[0,d]],5,[0,d]],n] >≈ SCG(n), sub-cubic graph numbers
g[[[0]],n] ≈ S(n), Chris Bird's S function

Pyth, f _{ψ (Ω ^Ω ) + ω ² +183} (~ 256 ^27! )

=QC`.pGL&=^QQ?+Ibt]0?htb?eb[Xb2yeby@b1hb)hbXb2yeb@,tb&bQ<b1=Y_1VQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQ.v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Qs["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q\YuyFYHpQ)

Requer qualquer entrada não vazia, mas seu valor não é usado.

Explicação (para a versão nova e com pontuação realmente razoável ):

=QC`.pG                   Sets the value of the autofill variable to app. 256^27!  
                                  27! ~= the number of characters in the string
                                  containing all permutations of the alphabet. 
                                  We interpret that string as a base-256 number.
       L                  Define a function y(b,global Q):
        &=^QQ             Set Q to Q^Q and:
        ?+Ibt]0           If (?) the variable (b) is (I)nvariant on (+)adding itself
                             to the empty array (i.e. if it's an array itself):
               ?htb        If the second element of b is not 0:
                   ?eb         If the last element is not 0
                       [Xb2yeby@b1hG)   return [b with its last element replaced with y(b[-1]), y(b[1]), b[0]]
                     hb                 else return b[0]
                 Xb2yeb     else return b with its last element replaced with y(b[-1])
           @,tb&bQ<b1      If b isn't an array,return:
                               either b-1 if it's a standard ordinal (1 or more)
                               or Q if b is ω
                               or 0 if b is 0
 =Y_1                          Set the global variable Y to -1 (representing ω)
 VQ                        Q times, do (the rest of the explanation):
  VQVQ....VQ               Iterate from 0 to Q-1 183 times, each subiteration
                              reading the most recent value of Q when it starts:
  .v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Q
                            Iterate from 0 to Q-1 Q times, each subiteration 
                               reading the most recent value of Q when it starts:                        
 s["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q
                             Y = [Y,Y,Y] Q times, stacking with previous iterations.
 uyFYHpQ)                    Run y_x(Y) for x incrementing until y_(x-1)(Y)=0

É muito difícil calcular o tamanho disso, principalmente porque é tarde e não estou muito familiarizado com hierarquias de rápido crescimento ou como eu tentaria descobrir quantas vezes Q passa pelo y()espremedor. Embora agora eu saiba mais sobre ordinais, ainda não tenho idéia de como calcular o valor do ordinal representado pela definição recursiva no meu programa. Eu ingressaria no servidor Discord, mas com um pseudônimo, prefiro não estar vinculado ao meu nome real.

Infelizmente, como sei relativamente pouco sobre as hierarquias de rápido crescimento, provavelmente já perdi para a resposta do Ruby. É difícil para mim dizer. Posso ter vencido a resposta Ruby, mas não tenho 100% de certeza. ¯ \ _ (ツ) _ / ¯

Pyth, f _{3 + σ -1 + ω ²} (256 ²⁶ )

Onde σ _m [n] é a função Busy Beaver Σ da ordem mchamada n: σ _m [n] = Σ _m (n). A ordem -1é denotar que o Busy Beaver aqui não está sendo chamado em uma verdadeira máquina de Turing, mas sim uma aproximação com uma fita finita de Qelementos. Isso permite que o problema de parada seja solucionável para esses programas.

=QCGM.x-Hlhf!-/T4/T5.__<GH0M.x+Hlhf!-/T4/T5._>GHlGL=.<QC`m.uX@[XN2%h@N2l@N1XN2%t@N2l@N1XN1X@N1@N2%h@@N1@N2l@N1XN1X@N1@N2%t@@N1@N2l@N1XW!@@N1@N2N2nFKtPNXW@@N1@N2N2gFK)@hNeN3%heNlhNd)bLym*F[]d^UQQUQUld)^U6QJ"s*].v*\mQ"
.v+PPPP*JQ"+*\mQ\'

O TL; DR é que isso cria todos os programas possíveis BrainF ** k de comprimento Q, executa-os em um ambiente em que o valor máximo de um número inteiro é Q e o comprimento da fita é Q e compila todos os estados dessas operações juntos para acrescente (que é 3+) a Q, repetindo o acima em uma escala de f _{ω ²} .

Eu ainda tenho ~ metade dos personagens para trabalhar, se eu quiser fazer algo mais, mas até descobrirmos onde é que eu vou deixar como está.

python, f ₃ (f ₃ (141)), 512 bytes

import math
def f(x):
    return math.factorial(x)  
x=9
for j in range(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))):
    x=f(x)
print x

Esta não é realmente uma resposta válida, mas eu queria publicá-la de qualquer maneira. Um rápido resumo:

import math # imports the factorial function
def f(x):
    return math.factorial(x) # shortens the factorial operation
x=9 # sets x to highest available number
for j in range(f(...f(x)...)): # repeats * A LOT *
    x=f(x) # does the factorial of x
print x # outputs the result

Enfim, não sei se essa resposta é tecnicamente legal, mas foi divertido escrever. Sinta-se à vontade para editar os erros encontrados no código.

Ruby, provavelmente ~ f _{ω + 35} (9 ^{9 99} )

G=->n,k{n<1?k:(f=->b,c,d{x=[]
c<G[b,d]?b-=1:(x<<=b;c-=G[b,d])while c>=d
x<<[c]}
x=f[n-1,k,b=1]
(b+=1;*u,v=x;x=v==[0]?u:v==[*v]?u<<[v[0]-1]:u+f[n-1,G[v,b]-1,b])while x[0]
b)};(n=9**9**99).times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n=G[n,n]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}};p n

Experimente online!

Explicação matemática aproximada:

O abaixo é aproximadamente igual ao programa acima, mas simplificado para facilitar a compreensão.

G(0,k) = k é a nossa função básica.

Para avaliar G(n,k), pegamos ke escrevemos como G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Em seguida, altere todos os G(x,1)'s para G(x,2)' e subtraia 1de todo o resultado.

Reescreva-o na forma acima usando G(x,2), where x<ne deixe o restante no final. Repita, alterando G(x,2)para G(x,3)etc.

Quando o resultado chegar -1, retorne a base (a bque estaria G(x,b).)

Exemplos:

G (1,1):

1: 1 = G(0,1)
2: G(0,2) - 1 = 1
3: 1 - 1 = 0
4: 0 - 1 = -1      <----- G(1,1) = 4

G (1,2):

1: 2 = G(0,1) + G(0,1)
2: G(0,2) + G(0,2) - 1 = G(0,2) + 1
3: G(0,3) + 1 - 1 = G(0,3)
4: G(0,4) - 1 = 3
5: 3 - 1 = 2
6: 2 - 1 = 1
7: 1 - 1 = 0
8: 0 - 1 = -1      <----- G(1,2) = 8

G (1,3):

1: 3 = G(0,1) + G(0,1) + G(0,1)
2: G(0,2) + G(0,2) + G(0,2) - 1 = G(0,2) + G(0,2) + 1
3: G(0,3) + G(0,3)
4: G(0,4) + 3
5: G(0,5) + 2
6: G(0,6) + 1
7: G(0,7)
8: 7
9: 6
10:5
11:4
12:3
13:2
14:1
15:0
16:-1      <----- G(1,3) = 16

G (2,5):

1: 5 = G(1,1) + G(0,1)
2: G(1,2) + 1
3: G(1,3)
4: G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + 3
5: G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + 2
6: G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + 1
...
1024: -1      <----- G(2,5) = 1024

Fazendo algumas contas, descobri que

G(1,n-1) = 2ⁿ
G(2,n+6) ~ 2^G(2,n),  large enough n.

E além disso, tende a ficar um pouco peludo.

Em geral, temos

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.

Python 3, f _{ω ^ω + ω * ω} (9 ^{9 9 99} )

from functools import*
h=lambda a,x,b:h(h(a,x,b-1),x-1,a)if x*b else a+b
def f(*x):
    if(any(x[:2]):return reduce(lambda y,z:h(z,y,f(x[0],x[1]-1,*x[2:])),x[::-1])if x[0]*x[1]else(f(x[0]-1,f(x[0]-1,x[0],*x[2:]))if x[0]>x[1]else(f(x[1]-1,f(*([x[1]-1]*2+x[2:])),*x[2:])))
    for a,k in enumerate(x):if k:return f(*[f(*[k]*a,k-1,*x[a+1:])]*a,k-1,*x[a+1:])
    return 0
x,s,g,e,r,z=9**9**9**99,"f(*[%s]*%s)",lambda a,b:a%((b,)*a.count("%")),"x*=eval(\"%s\");","x","x=g(e,g(reduce(g,[s]*x,s),r));"
print(exec(z*x)or eval(r))

Vou receber uma explicação em breve.

Python 3 , ~ f _{ε 0} (9 ^{9 9} )

N=9**9**9
def f(a,n):
 if a[0]==[]:return a[1:]
 if a[0][0]==[]:return[a[0][1:]]*n+a[1:]
 return [f(a[0],n)]+a[1:]
a=eval("["*N+"]"*N)
n=2
while a:a=f(a,n);n+=1
print(n)

Experimente online!

Python 3, 323 bytes, g ^9e9 (9)

exec("""a=`x:9**x
n=`a,f:`x:a and n(a-1,f)(f(x))or x
c=`n:`l:l[~n](l)
e=`x:n(x,c(0))([x,`l:[a(l[0]),n(*l)],c(0),`l:[a(l[0]),l[2](l[:2])[1]]+map(`i:l[1]((l[0],i))[1],l[2:])]+list(map(c,range(a(x),1,-1))))[1]
f=`l:[l[1](l[0]),e(l[1](l[0]))(l)[1]]
g=`x:e(x)((x,f))[1]((x,a))[1](x)
print(n(9e9,g)(9))""".replace('`','lambda '))

Experimente online!

Explicação

Python 3 é uma linguagem verdadeiramente recursiva, isso significa que não apenas uma função pode chamar a si mesma, mas também pode ter outras funções como funções de entrada ou saída. O uso de funções para melhorar a si é o que meu programa se baseia.

f = lambda x, a: [a (x), e (x) ((x, a)) [1]]

Definição

a(x)=9^x
b(x,f)=a(x), f^x
c(n)(*l)=l[~n](l)
c(0)=c0 <=> c0(…,f)=f(…,f)
d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l
e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1] 
f(x,a)=a(x),e(a(x))(x,a)[1](x)
g(x)=e(x)(x,f)[1](x,a)[1](x)
myNumber=g^9e9(9)

Definição explicada

a(x)=9^x a é a função base, eu escolhi essa função porque x> 0 => a (x)> x`, o que evita pontos fixos.

b(x,f)=a(x), f^xb é a função geral de aprimoramento, aceita qualquer função e gera uma versão melhor dela. b pode até ser aplicado a si mesmo:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

mas para usar totalmente o poder de bmelhorar, bvocê precisa pegar a saída de b e usá-la como o novo b, é isso que c0 faz:

c0(…,f)=f(…,f)
c0(x,b^x)=b^x(x,b^x)[1]>b^(9↑↑x)

a função c (n) mais geral recebe o último argumento n (começando em 0) so c(1)(…,f,a)=f(…,f,a)e c(2)(…,f,a,b)=f(…,f,a,b). *lsignifica que l é uma matriz e l[~n]aceita o último argumento

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld usa c0 para atualizar b e b para atualizar todas as outras funções de entrada (das quais pode haver qualquer valor devido à lista)
d(x,b,c,d)>9^x,b^x,c^x,d^xed²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

mas d fica ainda melhor se você combiná-lo com c:
c0²(x,b,c0,d)=d^x(9^x,b^x,c0^x,d^x)=… c0(x,b,c0,d,c1)=c1(x,b,c0,d,c1)=d(x,b,c0,d,c1)=9^x,b^x,c0^x,d^x,c1^x c0²(x,b,c0,d,c1)=c0(9^x,b^x,c0^x,d^x,c1^x)=c1^x(9^x,b^x,c0^x,d^x,c1^x)=…

quanto mais c (x) você adicionar no final, mais poderoso ele se tornará. O primeiro c0 sempre permanece d: c0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
mas o segundo deixa versões iteradas para trás:

c0²(x+1,b,c0,d,c4,c3,c2,c1)
=c0(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)
=c1^x(c2^x(c3^x(c4^x(d^x(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)))))

Quando d^xfinalmente for calculado, c4será necessária uma versão muito mais iterada da dpróxima vez. Quando c4^xfinalmente for calculado, c3será necessária uma versão muito mais iterada de c4,…
Isso cria uma versão realmente poderosa da iteração porque d:

1. Melhora o busoc0
2. Melhora o c0usob
3. Melhora todas as camadas de aninhamento usando b As melhorias melhoram, isso significa que d se torna mais poderoso quando é iterado mais.

Criar essa longa cadeia de c é o que e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1]faz.
Ele usa c0^xpara ignorar o que c0apenas daria d.
O [1]meio que retornará a segunda saída de d^…. entãob^… .

Neste ponto, eu não conseguia pensar em nada com e (x) para aumentar significativamente sua saída, exceto aumentar a entrada.

Portanto, f(x,a)=a(x),e(a(x))(x,a)[1](x)usa o b^…gerado por e(x)para gerar uma função base melhor e usa essa função base para chamar e(x)com uma entrada maior.

g(x)=e(x)(x,f)[1](x,a)[1](x)usa uma final e(x)para aninhar fe produz uma função realmente poderosa.

Aproximação Fgh

Vou precisar de ajuda para aproximar esse número com qualquer tipo de fgh.

Versão antiga : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), Experimente online! Histórico de revisões de explicação

Ruby, f _{ε 0 2} (5), 271 bytes

m=->n{x="";(0..n).map{|k|x+="->f#{k}{"};x+="->k{"+"y=#{n<1??k:"f1"};k.times{y=f0[y]};y";(2..n).map{|l|x+="[f#{l}]"};eval x+(n<1?"":"[k]")+"}"*(n+2)}
g=->z{t="m[#{z}]";(0...z).map{|j|t+="[m[#{z-j-1}]]"};eval t+"[->n{n+n}][#{z}]"}
p m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

Experimente online!

Isso é baseado no mapa m (n) .

Explicação:

m[0][f0][k] = f0[f0[...f0[k]...]]com kiterações def0 .

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]com kiterações def0 .

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]com kiterações def0 .

Em geral, m[n]recebe n+2argumentos, itera o primeiro argumento f0,k vezes para o segundo argumento, e, em seguida, aplica-se a função resultante sobre o terceiro argumento (se existir), em seguida, aplica-se a função resultante para o quarto argumento (se existir), etc.

Exemplos

m[0][n↦n+1][3] = (((3+1)+1)+1 = 6

Em geral m[0][n↦n+1] = n↦2n,.

m[0][m[0][n↦n+1]][3] = m[0][n↦2n][3] = 2(2(2(3))) = 24

Em geral m[0][m[0][n↦n+1]] = n↦n*2^n,.

m[1][m[0]][3]
= m[0][m[0][m[0][n↦n+1]]][3]
= m[0][m[0][n↦2n]][3]
= m[0][n↦n*2^n][3]
= (n↦n*2^n)[(n↦n*2^n)[n↦n*2^n(3)]]
= (n↦n*2^n)[(n↦n*2^n)[24]]
= (n↦n*2^n)[402653184]
= 402653184*2^402653184

Em geral, m[1][m[0]][n↦n+1] = f_ωna hierarquia de rápido crescimento.

g[z] = m[z][m[z-1]][m[z-2]]...[m[1]][m[0]][n↦2n][z]

e a saída final sendo

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]