Alcuni di voi potrebbero avere familiarità con BigNum Bakeoff , che è finito in modo abbastanza interessante. L'obiettivo può essere più o meno sintetizzato come la scrittura di un programma C il cui output sarebbe il più grande, con alcuni vincoli e condizioni teoriche, ad esempio un computer in grado di eseguire il programma.

Nello stesso spirito, sto proponendo una sfida simile aperta a tutte le lingue. Le condizioni sono:

• Massimo 512 byte .

• Il risultato finale deve essere stampato su STDOUT. Questo è il tuo punteggio. Se vengono stampati più numeri interi, verranno concatenati.

• L'output deve essere un numero intero. (Nota: l' infinito non è un numero intero .)

• Nessuna costante incorporata maggiore di 10, ma i numeri / le cifre vanno bene (ad es. La costante di Avogadro (come costante incorporata) non è valida, ma 10000 non lo è).

• Il programma deve terminare quando vengono fornite risorse sufficienti per l'esecuzione.

• L'output stampato deve essere deterministico se fornito di risorse sufficienti per essere eseguito.

• Vengono forniti numeri interi o origini sufficientemente grandi per l'esecuzione del programma. Ad esempio, se il tuo programma richiede l'applicazione di operazioni di base a numeri inferiori a 10 ^1.000.000 , puoi supporre che il computer che esegue questo può gestire numeri almeno fino a 10 ^1.000.000 . (Nota: il tuo programma può anche essere eseguito su un computer che gestisce numeri fino a 10 ^2.000.000 , quindi semplicemente chiamando il numero intero massimo che il computer può gestire non porterà a risultati deterministici.)

• Viene fornita una potenza di elaborazione sufficiente per consentire al programma di terminare l'esecuzione in meno di 5 secondi. (Quindi non preoccuparti se il tuo programma è in esecuzione da un'ora sul tuo computer e non finirà presto.)

• Nessuna risorsa esterna, quindi non pensare di importare quella funzione Ackermann a meno che non sia integrata.

Tutti gli oggetti magici vengono temporaneamente presi in prestito da una divinità generosa.

Estremamente grande con limite sconosciuto

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

dove B³F è l'ordinale Church-Kleene con la sequenza fondamentale di

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

Classifica:

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

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

3. Leaky Nun , 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 semplicemente meravigliosa , Ruby f _{ω + 35} (9 ^{9 99} )

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

Alcune note a margine:

Se non possiamo verificare il tuo punteggio, non possiamo metterlo in classifica. Quindi potresti aspettarti di spiegare un po 'il tuo programma.

Allo stesso modo, se non capisci quanto è grande il tuo numero, spiega il tuo programma e proveremo a risolverlo.

Se utilizzi un tipo di programma di Loader , ti inserirò in una categoria separata chiamata "Estremamente grande con limite sconosciuto" , poiché il numero di Loader non ha un limite superiore non banale in termini di gerarchia in rapida crescita per " sequenze fondamentali standard.

I numeri verranno classificati tramite la gerarchia in rapida crescita .

Per coloro che desiderano imparare a utilizzare la gerarchia in rapida crescita per approssimare numeri molto grandi, sto ospitando un server Discord proprio per questo. C'è anche una chat room: l' ordinalità .

Sfide simili:

Numero più grande stampabile

Golf un numero più grande di TREE (3)

Programma di chiusura più breve la cui dimensione di output supera il numero di Graham

Per coloro che vogliono vedere alcuni semplici programmi che producono la gerarchia in rapida crescita per piccoli valori, eccoli qui:

Rubino: gerarchia in rapida crescita

#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}

eccetera.

Per passare da f_xa f_(x+1), aggiungiamo un loop di n.times{...}.

Altrimenti, stiamo diagonalizzando contro tutti i precedenti, ad es

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)

eccetera.

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

dove M è il primo Mahlo 'ordinale', X è la funzione chi (funzione di collasso Mahlo) e ψ è la funzione di collasso ordinale.

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

Provalo online!

Analisi del codice:

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

Analisi matematica:

friduce in abase a n,b,q.

L'idea di base è quella di avere un nidificato estremamente ae ridurlo ripetutamente fino a quando non si riduce a a=0. Per semplicità, lascia

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

Per ora, preoccupiamoci solo di noi n.

Per ogni numero intero k, otteniamo f[k,n]=k-1, quindi possiamo vederlo

g[k,n]=n+k

Abbiamo poi abbiamo, per qualsiasi d, f[[0,d],n]=n, in modo che possiamo vedere che

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

Abbiamo poi abbiamo, per qualsiasi c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Per esempio,

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

Abbiamo poi abbiamo, per qualsiasi c,d,ein modo tale che non cada nel caso precedente, f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]. È qui che inizia a complicarsi. Alcuni esempi:

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

Da lì sale rapidamente. Alcuni punti di 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.

L'introduzione di più argomenti della ffunzione e di più casi per l'array ci consente di superare la maggior parte delle notazioni calcolabili con nome. Alcuni particolarmente noti:

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)

Richiede un input non vuoto, ma il suo valore non viene utilizzato.

Spiegazione (per la versione nuova e effettivamente ragionevole del punteggio ):

=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

È molto difficile per me calcolare le dimensioni di questo, soprattutto perché è tardi e non ho molta familiarità con le gerarchie in rapida crescita o come farei persino cercando di capire quante volte Q passa attraverso y()strizzatore. Mentre ora so di più sugli ordinali, non ho ancora idea di come calcolare il valore dell'ordinale rappresentato dalla definizione ricorsiva nel mio programma. Mi unirei al server Discord, ma con uno pseudonimo preferirei non essere collegato al mio vero nome.

Sfortunatamente, poiché so relativamente poco delle gerarchie in rapida crescita, probabilmente ho già perso la risposta di Ruby. È difficile per me dirlo. Potrei aver battuto la risposta di Ruby, ma non sono sicuro al 100%. ¯ \ _ (ツ) _ / ¯

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

Dove σ _m [n] è la funzione Busver Beaver Σ dell'ordine mchiamato n: σ _m [n] = Σ _m (n). L'ordine -1è quello di indicare che qui il Busver Beaver non viene chiamato su una vera macchina di Turing, ma piuttosto un'approssimazione con un nastro di Qelementi finito . Ciò consente di risolvere il problema di arresto per questi programmi.

=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\'

TL; DR è che questo crea tutti i possibili programmi BrainF ** k di lunghezza Q, li esegue in un ambiente in cui il valore massimo di un numero intero è Q e la lunghezza del nastro è Q e compila tutti gli stati da queste operazioni insieme a aggiungi (questo è 3+) a Q, ripetendo quanto sopra su una scala di f _{ω ²} .

Ho ancora ~ metà dei personaggi con cui lavorare se volessi fare qualcosa di più, ma fino a quando non capiremo dove sia, lo lascerò così com'è.

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

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

Questa non è davvero una risposta valida, ma volevo comunque pubblicarla. Una rapida carrellata:

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

Ad ogni modo, non so se questa risposta sia tecnicamente legale, ma è stato divertente scrivere. Sentiti libero di modificare gli errori che trovi nel codice.

Rubino, probabilmente ~ 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

Provalo online!

Spiegazione matematica approssimativa:

Quanto segue è approssimativamente uguale al programma sopra, ma semplificato in modo che sia più facile da capire.

G(0,k) = k è la nostra funzione di base.

Per valutare G(n,k), lo prendiamo ke lo scriviamo come G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Quindi cambia tutti gli G(x,1)"in G(x,2)" e sottrai 1dall'intero risultato.

Riscriverlo nel modulo sopra usando G(x,2), dove x<n, e lasciare il resto alla fine. Ripeti, modifica G(x,2)in G(x,3), ecc.

Quando il risultato raggiunge -1, restituisci la base (quella bche sarebbe in G(x,b).)

Esempi:

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

Facendo un po 'di matematica, l'ho scoperto

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

E oltre a ciò tende a diventare un po 'peloso.

In generale, abbiamo

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

Presto riceverò una spiegazione.

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)

Provalo online!

Python 3, 323 byte, 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 '))

Provalo online!

Spiegazione

Python 3 è un linguaggio veramente ricorsivo, ciò significa che non solo una funzione può chiamare se stessa, ma una funzione può anche assumere altre funzioni come funzioni di input o output. Usare le funzioni per migliorarsi è ciò su cui si basa il mio programma.

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

Definizione

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)

Definizione spiegata

a(x)=9^x a è la funzione base, ho scelto questa funzione perché x> 0 => a (x)> x` che evita i punti fissi.

b(x,f)=a(x), f^xb è la funzione di miglioramento generale, accetta qualsiasi funzione e ne fornisce una versione migliore. b può anche essere applicato a se stesso:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

ma per sfruttare appieno la potenza di bper migliorare bdevi prendere l'output di b e usarlo come nuovo b, questo è ciò che c0 fa:

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

la funzione c (n) più generale accetta l'ultimo argomento n (a partire da 0) c(1)(…,f,a)=f(…,f,a)e quindi c(2)(…,f,a,b)=f(…,f,a,b). *lsignifica che l è un array e l[~n]accetta l'ultimo argomento

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld usa c0 per aggiornare bec per aggiornare tutte le altre funzioni di input (di cui può esserci una quantità qualsiasi a causa dell'elenco)
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)

ma d migliora ancora se lo combini con 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)=…

più c (x) aggiungi alla fine, più diventa potente. Il primo c0 rimane sempre 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)=…
Ma il secondo lascia dietro di sé versioni iterate:

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^xsarà finalmente calcolato c4prenderà una versione molto più iterata della dprossima volta. Quando c4^xverrà finalmente calcolato c3prenderà una versione molto più iterata di c4, ...
Questo crea una versione davvero potente dell'iterazione perché d:

1. Migliora l' butilizzoc0
2. Migliora l' c0utilizzob
3. Migliora tutti gli strati di annidamento usando b I miglioramenti stessi migliorano, questo significa che diventa più potente quando viene ripetuto di più.

Creare questa lunga catena di c è ciò che 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]fa.
Usa c0^xper bypassare ciò c0che darebbe d.
Ciò [1]significa che alla fine restituirà il secondo output di d^…. Cosìb^… .

A questo punto non riuscivo a pensare a nulla a che fare con e (x) per aumentare significativamente l'output tranne aumentare l'input.

Quindi f(x,a)=a(x),e(a(x))(x,a)[1](x)usa il b^…generato da e(x)per produrre una migliore funzione base e usa quella funzione base per chiamare e(x)con un input più grande.

g(x)=e(x)(x,f)[1](x,a)[1](x)usa un finale e(x)per nidificaref e produce una funzione davvero potente.

Approssimazione fgh

Avrò bisogno di aiuto per approssimare questo numero con qualsiasi tipo di fgh.

Vecchia versione : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), Provalo online! Cronologia delle revisioni della spiegazione

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

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]

Provalo online!

Questo si basa sulla mappa m (n) .

Spiegazione:

m[0][f0][k] = f0[f0[...f0[k]...]]con kiterazioni di f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]con kiterazioni di f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]con kiterazioni di f0.

In generale, m[n]prende in n+2argomenti, itera il primo argomento, f0,k volte sul secondo argomento, e poi applica la funzione risultante sul terzo argomento (se esiste), quindi si applica la funzione risultante sul quarto argomento (se esiste), eccetera.

Esempi

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

In generale, 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

In generale, 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

In generale, m[1][m[0]][n↦n+1] = f_ωnella gerarchia in rapida crescita.

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

e l'output finale è

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