Certains d'entre vous connaissent peut-être le BigNum Bakeoff , qui s'est avéré assez intéressant. L'objectif peut être plus ou moins résumé comme l'écriture d'un programme C dont la sortie serait la plus importante, sous certaines contraintes et conditions théoriques, par exemple un ordinateur qui pourrait exécuter le programme.

Dans le même esprit, je pose un défi similaire ouvert à toutes les langues. Les conditions sont les suivantes:

• 512 octets maximum .

• Le résultat final doit être imprimé sur STDOUT. Ceci est votre score. Si plusieurs entiers sont imprimés, ils seront concaténés.

• La sortie doit être un entier. (Remarque: Infinity n'est pas un entier .)

• Aucune constante intégrée supérieure à 10, mais les chiffres / chiffres sont corrects (par exemple, la constante d'Avogadro (en tant que constante intégrée) n'est pas valide, mais 10000 ne l'est pas.)

• Le programme doit se terminer lorsqu'il dispose de ressources suffisantes pour être exécuté.

• La sortie imprimée doit être déterministe lorsqu'elle dispose de ressources suffisantes pour être exécutée.

• On vous fournit des nombres entiers ou bigints suffisamment grands pour que votre programme s'exécute. Par exemple, si votre programme nécessite l'application d'opérations de base à des nombres inférieurs à 10 ^{1 000 000} , vous pouvez supposer que l'ordinateur exécutant ce système peut gérer des nombres d'au moins 10 ^{1 000 000} . (Remarque: votre programme peut également être exécuté sur un ordinateur qui gère des nombres allant jusqu'à 10 ^{2 000 000} , donc le simple fait d'appeler l'entier maximum que l'ordinateur peut gérer n'entraînera pas de résultats déterministes.)

• Vous disposez d'une puissance de calcul suffisante pour que votre programme puisse terminer son exécution en moins de 5 secondes. (Ne vous inquiétez donc pas si votre programme fonctionne depuis une heure sur votre ordinateur et ne se terminera pas de si tôt.)

• Pas de ressources externes, alors ne pensez pas à importer cette fonction Ackermann à moins qu'elle ne soit intégrée.

Tous les objets magiques sont temporairement empruntés à une généreuse divinité.

Extrêmement grand avec une limite inconnue

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

où B³F est l'ordinal de Church-Kleene avec la séquence fondamentale de

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

Classement:

1. Simply Beautiful Art , 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. L'art tout simplement magnifique , Ruby f _{ω + 35} (9 ^{9 99} )

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

Quelques notes annexes:

Si nous ne pouvons pas vérifier votre score, nous ne pouvons pas le mettre dans le classement. Vous pouvez donc vous attendre à expliquer un peu votre programme.

De même, si vous ne comprenez pas la taille de votre numéro, expliquez votre programme et nous essaierons de le résoudre.

Si vous utilisez un type de programme de type Loader , je vais vous placer dans une catégorie distincte appelée "Extrêmement grand avec une limite inconnue" , car le numéro de Loader n'a pas de limite supérieure non triviale en termes de hiérarchie à croissance rapide pour ' séquences fondamentales standard.

Les nombres seront classés via la hiérarchie à croissance rapide .

Pour ceux qui voudraient apprendre à utiliser la hiérarchie à croissance rapide pour approximer de très grands nombres, j'héberge un serveur Discord juste pour cela. Il y a aussi une salle de chat: Ordinality .

Défis similaires:

Le plus grand nombre imprimable

Golf un nombre plus grand que TREE (3)

Programme de terminaison le plus court dont la taille de sortie dépasse le nombre de Graham

Pour ceux qui veulent voir des programmes simples qui produisent la hiérarchie à croissance rapide pour les petites valeurs, les voici:

Ruby: une hiérarchie en croissance rapide

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

Pour passer de f_xà f_(x+1), nous ajoutons une boucle du n.times{...}.

Sinon, nous diagonalisons par rapport à tous les précédents, par exemple

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.

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

où M est le premier «ordinal» de Mahlo, X est la fonction chi (fonction d'effondrement de Mahlo) et ψ est la fonction d'effondrement 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}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

Essayez-le en ligne!

Répartition du code:

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

Répartition des mathématiques:

fréduit en afonction n,b,q.

L'idée de base est d'avoir un élément extrêmement imbriqué aet de le réduire à plusieurs reprises jusqu'à ce qu'il soit réduit à a=0. Pour plus de simplicité, laissez

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

Pour l'instant, ne nous inquiétons que de n.

Pour tout entier k, nous obtenons f[k,n]=k-1, donc nous pouvons voir que

g[k,n]=n+k

Nous avons alors, pour tout d, pour f[[0,d],n]=nque nous puissions voir que

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

Nous avons, pour tout c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Par exemple,

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

Nous avons alors, pour tout c,d,ece qu'il ne tombe pas dans le cas précédent, f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]. C'est là que ça commence à se compliquer. Quelques exemples:

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

Il monte rapidement à partir de là. Quelques points d'intérêt:

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.

Finalement, l'introduction de plus d'arguments de la ffonction ainsi que de plus de cas pour le tableau nous permet de dépasser la plupart des notations calculables nommées. Certains particulièrement connus:

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)

Nécessite une entrée non vide, mais sa valeur n'est pas utilisée.

Explication (pour la nouvelle version avec un score réellement raisonnable ):

=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

Il est très difficile pour moi de calculer la taille de cela, principalement parce qu'il est tard dans la journée et que je ne suis pas très familier avec les hiérarchies à croissance rapide ou comment j'essaierais même de comprendre combien de fois Q passe par le y()essoreuse. Bien que j'en sache maintenant plus sur les ordinaux, je ne sais toujours pas comment calculer la valeur de l'ordinal représenté par la définition récursive dans mon programme. Je rejoindrais le serveur Discord, mais sous un pseudonyme, je préfère ne pas être lié à mon vrai nom.

Malheureusement, parce que je sais relativement peu de choses sur ces hiérarchies à croissance rapide, je suis probablement déjà tombé sur la réponse Ruby. C'est difficile à dire pour moi. J'ai peut-être battu la réponse Ruby, mais je ne suis pas sûr à 100%. ¯ \ _ (ツ) _ / ¯

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

Où σ _m [n] est la fonction occupée Beaver Σ de l' ordre mappelé n: σ _m [n] = Σ _m (n). L'ordre -1consiste à indiquer que le Castor occupé ici n'est pas appelé sur une véritable machine de Turing, mais plutôt une approximation avec une bande d' Qéléments finis . Cela permet au problème d'arrêt d'être résolu pour ces programmes.

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

Le TL; DR est que cela crée tous les programmes BrainF ** k possibles de longueur Q, les exécute dans un environnement où la valeur maximale d'un entier est Q et la longueur de bande est Q, et compile tous les états de ces opérations ensemble pour ajouter (c'est le 3+) à Q, en répétant ce qui précède sur une échelle de f _{ω ²} .

J'ai encore ~ ​​la moitié des personnages avec qui travailler si je voulais faire quelque chose de plus, mais jusqu'à ce que nous trouvions où cela se trouve, je le laisse tel quel.

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

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

Ce n'est pas vraiment une réponse valable, mais je voulais quand même la publier. Un bref aperçu:

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

Quoi qu'il en soit, je ne sais pas si cette réponse est techniquement légale, mais c'était amusant à écrire. N'hésitez pas à modifier les erreurs que vous trouvez dans le code.

Rubis, probablement ~ 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

Essayez-le en ligne!

Explication mathématique approximative:

Ce qui suit est à peu près égal au programme ci-dessus, mais simplifié afin qu'il soit plus facile à comprendre.

G(0,k) = k est notre fonction de base.

Pour évaluer G(n,k), nous le prenons ket l'écrivons comme G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Ensuite, changez tous les G(x,1)«en G(x,2)» et soustrayez 1du résultat entier.

Réécrivez-le dans le formulaire ci-dessus en utilisant G(x,2), où x<net laissez le reste à la fin. Répéter, passer G(x,2)à G(x,3), etc.

Lorsque le résultat atteint -1, retournez la base (celle bqui serait dedans G(x,b).)

Exemples:

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

En faisant des calculs, j'ai trouvé que

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

Et au-delà, cela a tendance à devenir un peu poilu.

En général, nous avons

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

Je vais bientôt avoir une explication.

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)

Essayez-le en ligne!

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

Essayez-le en ligne!

Explication

Python 3 est un langage vraiment récursif, cela signifie que non seulement une fonction peut s'appeler elle-même, mais une fonction peut également prendre d'autres fonctions comme fonctions d'entrée ou de sortie. Utiliser les fonctions pour s'améliorer est la base de mon programme.

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

Définition

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)

Explication de la définition

a(x)=9^x a est la fonction de base, j'ai choisi cette fonction car x> 0 => a (x)> x` ce qui évite les points fixes.

b(x,f)=a(x), f^xb est la fonction d'amélioration générale, elle prend n'importe quelle fonction et en produit une meilleure version. b peut même s'appliquer à lui-même:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

mais pour utiliser pleinement la puissance de bpour améliorer que bvous devez prendre la sortie b et l' utiliser comme nouveau b, voici ce c0 fait:

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

la fonction plus générale c (n) prend le n dernier argument (à partir de 0) ainsi c(1)(…,f,a)=f(…,f,a)et c(2)(…,f,a,b)=f(…,f,a,b). *lsignifie que l est un tableau et l[~n]prend le n dernier argument

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld utilise c0 pour mettre à niveau b et b pour mettre à niveau toutes les autres fonctions d'entrée (dont il peut y avoir n'importe quel montant en raison de la liste)
d(x,b,c,d)>9^x,b^x,c^x,d^xetd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

mais d devient encore meilleur si vous le combinez avec 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)=…

plus vous ajoutez c (x) à la fin, plus il devient puissant. Le premier c0 reste toujours 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)=…
mais le second laisse les versions itérées derrière:

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

Quand d^xest finalement calculé c4prendra une version beaucoup plus itérée de dla prochaine fois. Quand c4^xest finalement calculé c3prendra une version beaucoup plus itérée de c4,…
Cela crée une version d'itération vraiment puissante car d:

1. Améliore l' butilisationc0
2. Améliore l' c0utilisationb
3. Améliore toutes les couches d'imbrication en utilisant b Les améliorations elles-mêmes s'améliorent, cela signifie que d devient plus puissant lorsqu'il est itéré davantage.

La création de cette longue chaîne de c est ce qui 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]fait.
Il utilise c0^xpour contourner cela c0donnerait juste d.
Les [1]signifie qu'il finira par revenir la deuxième sortie d^…. Alors b^….

À ce stade, je ne pouvais penser à rien à voir avec e (x) pour augmenter considérablement sa sortie, sauf augmenter l'entrée.

f(x,a)=a(x),e(a(x))(x,a)[1](x)Utilise donc le b^…généré par e(x)pour produire une meilleure fonction de base et utilise cette fonction de base pour appeler e(x)avec une entrée plus grande.

g(x)=e(x)(x,f)[1](x,a)[1](x)utilise une finale e(x)pour imbriquer fet produit une fonction vraiment puissante.

Approximation Fgh

J'aurai besoin d'aide pour approximer ce nombre avec n'importe quelle sorte de fgh.

Ancienne version : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), essayez-le en ligne! Historique de révision de l'explication

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

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]

Essayez-le en ligne!

Ceci est basé sur la carte m (n) .

Explication:

m[0][f0][k] = f0[f0[...f0[k]...]]avec des kitérations de f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]avec des kitérations de f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]avec des kitérations de f0.

En général, m[n]prend en n+2arguments, itère le premier argument, f0, kfois sur le second argument, puis applique la fonction résultante sur le troisième argument (si elle existe), puis applique la fonction résultante sur le quatrième argument (si elle existe), etc.

Exemples

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

En général 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

En général 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

En général, m[1][m[0]][n↦n+1] = f_ωdans la hiérarchie à croissance rapide.

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

et la sortie finale étant

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