Su objetivo es escribir un programa que imprima un número. Cuanto mayor sea el número, más puntos obtendrás. ¡Pero ten cuidado! La longitud del código es limitada y muy ponderada en la función de puntuación. Su número impreso se dividirá por el cubo de la cantidad de bytes que utilizó para su solución .

Entonces, digamos que imprimiste 10000000y tu código tiene una 100longitud de bytes. Tu puntaje final será 10000000 / 100^3 = 10.

Hay otras reglas a seguir, para hacer este desafío un poco más difícil.

• No puede usar dígitos en su código (0123456789);
• Usted puede utilizar matemática / física / etc. constantes, pero solo si son inferiores a 10. (por ejemplo, puede usar Pi ~ = 3.14 pero no puede usar la constante de Avogadro = 6e23)
• La recursión está permitida pero el número generado debe ser finito (por lo que infinito no se acepta como solución. Su programa debe terminar correctamente, suponiendo tiempo y memoria ilimitados, y generar la salida solicitada);
• No puede usar las operaciones *(multiplicar), /(dividir), ^(potencia) ni ninguna otra forma de indicarlas (por ejemplo, 2 div 2no está permitido);
• Su programa puede generar más de un número, si lo necesita para hacerlo . Solo el más alto contará para anotar;
• Sin embargo, puede concatenar cadenas: esto significa que cualquier secuencia de dígitos adyacentes se considerará como un solo número;
• Su código se ejecutará tal cual. Esto significa que el usuario final no puede editar ninguna línea de código, ni puede ingresar un número o cualquier otra cosa;
• La longitud máxima del código es de 100 bytes.

Tabla de clasificación

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Arte simplemente hermoso , rubí ≈ f _{φ 121 (ω)} (126) ^[1]
3. Peter Taylor , GolfScript ≈ f _{ε 0 + ω + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))) ^[1]
5. Arte simplemente hermoso , Ruby ≈ f _{ω ^ω2 +1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom , Haskell, ≈ a ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , cc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Magenta , Python, ≈ ack (126,126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Kendall Frey , ECMAScript 6, ≈ 10 ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Ilmari Karonen , GolfScript, ≈ 10 ↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 ³
14. recursivo , Python, ≈ 2 ↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2 ↑↑ 7/100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. David guiñada , C, ≈ 10 ^{10 4 × 10 22} /83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. primo , Perl, ≈ 10 ^{(12750684.161 mil!) 5 × 2 27} /100 ³ ≈ 10 ↑↑ 4.11369
18. Arte , C, ≈ 10 ^{10 2 × 10 6} /98 ³ ≈ 10 ↑↑ 3.80587
19. Robert Sørlie , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ ≈ 10 ↑↑ 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3.40616
21. Darren Stone , C, ≈ 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3.29749
23. Adam Speight , vb.net, ≈ 10 ^{5,000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3.28039
24. Joshua , golpe, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3.07282

_{Notas al pie}

1. ^{Si todos los electrones en el universo fueran un qubit, y cada superposición de los mismos se pudiera usar de manera lucrativa para almacenar información (lo cual, siempre y cuando no necesite saber qué se está almacenando es teóricamente posible), este programa requiere más memoria de la que podría posiblemente exista, y por lo tanto no se puede ejecutar, ahora, o en cualquier punto concebible en el futuro. Si el autor pretendía imprimir un valor mayor que ≈3 ↑↑ 3.28 de una vez, se aplica esta condición.}
2. ^{Este programa requiere más memoria de la que existe actualmente, pero no tanto que, en teoría, no podría almacenarse en un número escaso de qubits, y por lo tanto, algún día puede existir una computadora que pueda ejecutar este programa.}
3. ^{Todos los intérpretes disponibles actualmente emiten un error de tiempo de ejecución, o el programa no puede ejecutarse como el autor pretendía.}
4. ^{Ejecutar este programa causará daños irreparables a su sistema.}

Editar @primo : he actualizado una parte del marcador utilizando una notación que es más fácil de comparar, con decimales para denotar la distancia logarítmica a la siguiente potencia más alta. Por ejemplo 10 ↑↑ 2.5 = 10 ^{10 √10} . También he cambiado algunos puntajes si creía que el análisis del usuario era defectuoso, no dude en disputar cualquiera de estos.

Explicación de esta notación:

Si 0 ≤ b < 1, entonces .a↑↑b = ab

Si b ≥ 1, entonces .a↑↑b = aa↑↑(b-1)

Si b < 0, entonces .a↑↑b = loga(a↑↑(b+1))

GolfScript; puntuar al menos f _{ε_0 + ω + 1} (17) / 1000

Siguiendo la sugerencia de res de usar la respuesta Lifetime of a worm para esta pregunta, presento dos programas que mejoran enormemente su derivación de la solución de Howard.

Comparten un prefijo común, módulo el nombre de la función:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

calcula g(g(1)) = g(5)dónde g(x) = worm_lifetime(x, [x])crece más o menos como f _{ε 0} (lo que señala es "la función en la jerarquía de rápido crecimiento que crece aproximadamente a la misma velocidad que la función de Goodstein").

El un poco más fácil (!) Para analizar es

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*mapas xa foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

así da g^(g(5)) ( g(5) ); Los otros 8 niveles de iteración son similares al encadenamiento de flechas. Para expresar en términos simples: si h_0 = gy h_{i+1} (x) = h_i^x (x)luego calculamos h_10 (g(5)).

Creo que este segundo programa casi seguramente tiene mejores resultados. Esta vez, la etiqueta asignada a la función ges una nueva línea (sic).

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

Esta vez aprovecho mejor ^como una función diferente.

.['.{
}*'n/]*zip n*~

toma xla pila y sale xseguido de una cadena que contiene xcopias de .{seguido de gseguido de xcopias de }*; luego evalúa la cadena. Como tenía un lugar mejor para quemar caracteres sobrantes, comenzamos con j_0 = g; si j_{i+1} (x) = j_i^x (x)entonces la primera evaluación de las ^computadoras j_{g(5)} (g(5))(que estoy bastante seguro ya supera el programa anterior). Luego ejecuto ^16 veces más; entonces si k_0 = g(5)y k_{i+1} = j_{k_i} (k_i)luego se calcula k_17. Estoy agradecido (nuevamente) a res por estimar que k_i>> f _{ε_0 + ω + 1} (i).

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

NOTA: ¡NO CORRE ESTO!

Guarde lo siguiente en un archivo por lotes y ejecútelo como Administrador.

CD|Format D:/FS:FAT/V/Q

Salida cuando se ejecuta en una unidad de 4 TB con el primer número impreso en negrita.

Inserte un nuevo disco para la unidad D:
y presione ENTER cuando esté listo ... El tipo de sistema de archivos es NTFS.
El nuevo sistema de archivos es FAT.
QuickFormatting 3907172M
El volumen es demasiado grande para FAT16 / 12.

GolfScript, puntuación: forma demasiado

OK, ¿qué número podemos imprimir en algunos caracteres de GolfScript?

Comencemos con el siguiente código (¡ gracias, Ben! ), Que imprime 126:

'~'(

Luego, repitámoslo 126 veces, dándonos un número igual a aproximadamente 1.26126 × 10 ³⁷⁷ :

'~'(.`*

(Eso es repetición de cuerda, no multiplicación, por lo que debería estar bien según las reglas).

Ahora, repitamos ese número de 378 dígitos un poco más de 10 ³⁷⁷ veces:

'~'(.`*.~*

En realidad, nunca verás terminar este programa, ya que trata de calcular un número con aproximadamente 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ dígitos. Ninguna computadora jamás construida podría almacenar un número tan grande, ni una computadora así podría construirse utilizando física conocida; el número de átomos en el universo observable se estima en alrededor de 10 ⁸⁰ , por lo que incluso si de alguna manera podría utilizar toda la materia en el universo para almacenar este número enorme, que había todavía de alguna manera tienen que meter unos 10 ³⁸⁰ /10 ⁸⁰ = ¡10 ³⁰⁰ dígitos en cada átomo!

Pero supongamos que tenemos el propio intérprete de GolfScript de Dios, capaz de ejecutar dicho cálculo, y que todavía no estamos satisfechos. OK, ¡ hagámoslo de nuevo!

'~'(.`*.~*.~*

La salida de este programa, si pudiera completarse, tendría aproximadamente 10 ^{10 383} dígitos, por lo que sería aproximadamente 10 ^{10 10 383} .

¡Pero espera! Ese programa se está volviendo repetitivo ... ¿por qué no lo convertimos en un bucle?

'~'(.`*.{.~*}*

Aquí, el cuerpo del bucle se ejecuta aproximadamente 10 ³⁷⁷ veces, lo que nos da una salida teórica que consta de aproximadamente 10 ^{10⋰ 10 377} dígitos más o menos, donde la torre de potencias iteradas de 10 tiene aproximadamente 10 ³⁷⁷ pasos de largo. (En realidad, eso es una gran subestimación, ya que estoy descuidando el hecho de que el número que se repite también se alarga cada vez, pero en términos relativos es un problema menor).

Pero aún no hemos terminado. ¡Agreguemos otro bucle!

'~'(.`*.{.{.~*}*}*

Incluso escribir correctamente una aproximación de tales números requiere notación matemática esotérica. Por ejemplo, en la notación de flecha hacia arriba de Knuth , el número (teóricamente) generado por el programa anterior debe ser de aproximadamente 10 ↑ ³ 10 ³⁷⁷ , dar o tomar algunas (o 10 ³⁷⁷ ) potencias de diez, suponiendo que hice los cálculos matemáticos correctamente.

Números como este van mucho más allá de lo "increíblemente enorme" y llegan al reino de lo "inconcebible". Como en, no solo es imposible contar o escribir tales números (ya hemos cruzado más allá de ese punto en el tercer ejemplo anterior), sino que literalmente no tienen un uso concebible o existencia fuera de las matemáticas abstractas. Podemos probar, a partir de los axiomas de las matemáticas , que tales números existen, al igual que podemos probar a partir de la especificación GolfScript que el programa anterior los calcularía, si los límites de la realidad y el espacio de almacenamiento disponible no intervinieran), pero literalmente no hay nada en el universo físico que podríamos usar para contar o medir en cualquier sentido.

Aún así, los matemáticos a veces hacen uso de números aún mayores . (Teóricamente) calcular números tan grandes requiere un poco más de trabajo: en lugar de anidar más bucles uno por uno, necesitamos usar la recursividad para telescopiar la profundidad de los bucles anidados. Aún así, en principio, debería ser posible escribir un programa corto de GolfScript (bastante menos de 100 bytes, esperaría) para calcular (en teoría) cualquier número expresable en, por ejemplo, notación de flecha encadenada de Conway ; Los detalles se dejan como ejercicio. ;-)

JavaScript 44 caracteres

Esto puede parecer un poco engañoso:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Puntuación = 31415926535897932718281828459045/44 ^ 3 ≈ 3.688007904758867e + 26 ≈ 10 ↑↑ 2.1536134004

C, puntaje = 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

Agradezco la ayuda en la puntuación. Cualquier apreciación o corrección es apreciada. Aquí está mi método:

n = la concatenación de cada número de 1 a 2 ⁶⁴ -1, repetido (2 ⁶⁴ -1) ⁴ veces . Primero, así es como estoy estimando (bajo) el número acumulado de dígitos de 1 a 2 ⁶⁴ -1 (la "subsecuencia"): El número final en la secuencia de subsecuencia es 2 ⁶⁴ -1 = 18446744073709551615con 20 dígitos. Por lo tanto, más del 90% de los números en la subsecuencia (aquellos que comienzan con 1... 9) tienen 19 dígitos. Supongamos que el 10% restante promedio de 10 dígitos. Será mucho más que eso, pero esta es una estimación baja para matemáticas fáciles y sin trampas. Esa subsecuencia se repite (2 ⁶⁴ -1) ⁴ veces, por lo que la longitudde n será al menos (0.9 × (2 ⁶⁴ -1) × 19 + 0.1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3.86613 × 10 ⁹⁷ dígitos. En los comentarios a continuación, @primo confirma que la longitud de n es 4.1433x10 ⁹⁷ . Entonces n en sí será 10 a esa potencia, o 10 ^{10 97.61735} .

l = 98 caracteres de código

puntaje = n / l ³ = 10 ^{10 97.61735} / 98 ³

Requisito: debe ejecutarse en una computadora de 64 bits donde sizeof(long) == 8. Mac y Linux lo harán.

Python 3 - 99 caracteres - (muy probablemente) significativamente más grande que el número de Graham

Se me ocurrió una función cada vez más rápida basada en una extensión de la función Ackermann.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 me inspiró, pero no necesita mirar allí para comprender mi número.

Aquí está la versión modificada de la función ackermann que usaré en mi análisis:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

Mi función Aen el código anterior técnicamente no es la misma, pero en realidad es más fuerte, con la siguiente instrucción para reemplazar la tercera línea de la definición anterior:

A(a,0,...)=A(a-1,a,...)

(a tiene que ser al menos 1, por lo que tiene que ser más fuerte)

Pero para mis propósitos, supondré que es lo mismo que el más simple, porque el análisis ya está parcialmente realizado para la función de Ackermann y, por lo tanto, para esta función cuando tiene dos argumentos.

Se garantiza que mi función eventualmente dejará de recurrir porque siempre: elimina un argumento, disminuye el primer argumento o mantiene el mismo primer argumento y disminuye el segundo argumento.

Análisis de talla

El número de Graham, AFAIK, se puede representar G(64)usando:

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Donde a ↑^(n)b es la notación de flecha hacia arriba de knuth.

También:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

El número expresado en el programa anterior es A(0,1,2,3,4,...,123,124,125).

Dado que g^64(4)es el número de Graham, y suponiendo que mis cálculos sean correctos, entonces es menor que A(1,64,100), mi número es significativamente mayor que el número de Graham.

Señale cualquier error en mis matemáticas, aunque si no hay ninguno, este debería ser el mayor número calculado hasta ahora para responder a esta pregunta.

Perl - puntuación ≈ 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Una vez más, abusar del motor de expresiones regulares de Perl para procesar una cantidad inimaginable de combinaciones, esta vez utilizando un descenso recursivo.

En la parte más interna de la expresión, tenemos un desnudo .para evitar la recursión infinita y, por lo tanto, limitar los niveles de recursión a la longitud de la cadena.

Lo que terminaremos es esto:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... repetido 671088640 veces, para un total de 12750684161 anidamientos, lo que pone en evidencia mi intento anterior de 23 anidamientos. Sorprendentemente, Perl ni siquiera se ahoga con esto (una vez más, el uso de la memoria se mantiene estable en aproximadamente 1.3 GB), aunque pasará bastante tiempo antes de que se emita la primera declaración impresa.

De mi análisis anterior a continuación, se puede concluir que el número de dígitos de salida será del orden de (! 12750684161) ^671088640 , donde ! K es el Factorial Izquierdo de k (ver A003422 ). ¡Podemos aproximar esto como (k-1)! , que es estrictamente más pequeño, pero del mismo orden de magnitud.

Y si le preguntamos a wolframalpha :

... que apenas cambia mi puntaje en absoluto. Pensé con seguridad que sería al menos 10 ↑↑ 5 . Supongo que la diferencia entre 10 ↑↑ 4 y 10 ↑↑ 4.1 es mucho más grande de lo que piensas.

Perl - puntuación ≈ 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Abusar del motor perl regex para hacer algunos combinatorios por nosotros. El bloque de código incrustado
(??{print})insertará su resultado directamente en la expresión regular. Como $_está compuesto completamente por 2s (y el resultado printes siempre 1), esto nunca puede coincidir y envía a Perl girando a través de todas las combinaciones posibles, de las cuales hay bastantes.

Constantes utilizadas

• $^F- el identificador de archivo de sistema máximo, normalmente 2.
• $]- el número de versión perl, similar a 5.016002.

$_es entonces una cadena que contiene el dígito 2repetido 671088640 veces. El uso de la memoria es constante en aproximadamente 1.3 GB, la salida comienza de inmediato.

Análisis

Definamos P _k (n) como el número de veces que se ejecuta la declaración de impresión, donde k es el número de anidamientos yn es la longitud de la cadena más uno (solo porque no tengo ganas de escribir n + 1 en todos lados).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

etc. En general, la fórmula se puede generalizar de la siguiente manera:

dónde

Es decir, el factorial izquierdo de k , es decir, la suma de todos los factoriales menores que k (véase A003422 ).

No he podido determinar formas cerradas para D _k y E _k , pero esto no importa demasiado, si observamos que

y

Con 23 anidamientos, esto nos da una puntuación aproximada de:

Esto debería ser casi exacto, en realidad.

Pero para poner esto en una notación que es un poco más fácil de visualizar, podemos aproximar la base del exponente interno:

y luego el exponente mismo:

y luego pregunta a wolframalpha :

que también puedes llamar al 10 ↑↑ 4 y listo.

Javascript, 10 ↑↑↑↑ 210

100 caracteres:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Basado en la observación de que iterar al máximo fes la forma óptima de hacerlo, reemplacé las 13 llamadas fcon 3 niveles de llamadas de bucles anidados f, zveces cada una (mientras fsigue aumentando z).

Calculé el puntaje analíticamente en una hoja de papel: lo escribiré si alguien está interesado en verlo.

Puntuación mejorada: 10 ↑↑ 13

Javascript, en exactamente 100 caracteres, nuevamente:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

Esto mejora mi respuesta original de tres maneras:

1. Definir zel alcance global nos evita tener que escribir o.zcada vez.

2. Es posible definir un captador en el ámbito global (ventana) y escribir en flugar de o.f.

3. Tener más iteraciones fvale más que comenzar con un número mayor, por lo que en lugar de (Math.E+'').replace('.','')(= 2718281828459045, 27 caracteres), es mejor usar ~~Math.E+''(= 2, 11 caracteres), y usar los caracteres recuperados para llamar fmuchas veces más.

Dado que, como se analiza más adelante, cada iteración produce, a partir de un número en el orden de magnitud M , un número mayor en el orden de magnitud 10 ^M , este código produce después de cada iteración

1. 210 ∼ O (10 ² )
2. O (10 ^{10 2} ) ∼ O (10 ↑↑ 2)
3. O (10 ^{10 ↑↑ 2} ) = O (10 ↑↑ 3)
4. O (10 ^{10 ↑↑ 3} ) = O (10 ↑↑ 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 ↑↑ 5} ) = O (10 ↑↑ 6)
7. O (10 ^{10 ↑↑ 6} ) = O (10 ↑↑ 7)
8. O (10 ^{10 ↑↑ 7} ) = O (10 ↑↑ 8)
9. O (10 ^{10 ↑↑ 8} ) = O (10 ↑↑ 9)
10. O (10 ^{10 ↑↑ 9} ) = O (10 ↑↑ 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 ↑↑ 11} ) = O (10 ↑↑ 12)
13. O (10 ^{10 ↑↑ 12} ) = O (10 ↑↑ 13)

Puntuación: ∼10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

Javascript, en exactamente 100 caracteres:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Cada uno o.finvoca el bucle while, para un total de 5 bucles. Después de solo la primera iteración, el puntaje ya está por encima de 10 ^{42381398144233621} . En la segunda iteración, Mathematica no pudo calcular ni siquiera el número de dígitos en el resultado.

Aquí hay un tutorial del código:

En eso

Comience con 2718281828459045 eliminando el punto decimal de Math.E.

Iteración 1

Concatenar la secuencia decreciente de números,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0 0

para formar un nuevo número (gigantesco),

• 271828182845904527182818284590442718281828459043 ... 9876543210.

¿Cuántos dígitos hay en este número? Bueno, es la concatenación de

• 1718281828459046 Números de 16 dígitos
• 900000000000000 números de 15 dígitos
• 90000000000000 números de 14 dígitos,
• 9000000000000 números de 13 dígitos
• ...
• 900 números de 3 dígitos
• 90 números de 2 dígitos
• 10 números de 1 dígito

En Mathematica

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

En otras palabras, es 2.72⋅10 ^{42381398144233625} .

Haciendo mi puntaje, después de solo la primera iteración, 2.72⋅10 ^{42381398144233619} .

Iteración 2

Pero eso es solo el comienzo. ¡Ahora, repita los pasos, comenzando con el número gigantesco ! Es decir, concatenar la secuencia decreciente de números,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3
• 2
• 1
• 0 0

Entonces, ¿cuál es mi nuevo puntaje, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Iteración 3

Repetir.

Iteración 4

Repetir.

Iteración 5

Repetir.

Puntuación analítica

En la primera iteración, calculamos el número de dígitos en la concatenación de la secuencia decreciente a partir de 2718281828459045, contando el número de dígitos en

• 1718281828459046 Números de 16 dígitos
• 900000000000000 números de 15 dígitos
• 90000000000000 números de 14 dígitos,
• 9000000000000 números de 13 dígitos
• ...
• 900 números de 3 dígitos
• 90 números de 2 dígitos
• 10 números de 1 dígito

Esta suma puede ser representada por la fórmula,

donde Z denota el número inicial ( por ejemplo, 2718281828459045) y O _Z denota su orden de magnitud ( por ejemplo , 15, ya que Z since 10 ¹⁵ ). Usando equivalencias para sumas finitas , lo anterior se puede expresar explícitamente como

que, si tomamos 9 ≈ 10, se reduce aún más a

y, finalmente, expandiendo los términos y ordenándolos disminuyendo el orden de magnitud, obtenemos

Ahora, dado que solo estamos interesados ​​en el orden de magnitud del resultado, sustituyamos Z con "un número en el orden de magnitud de O _Z ", es decir, 10 ^{O _Z} -

Finalmente, los términos segundo y tercero se cancelan, y los dos últimos términos se pueden descartar (su tamaño es trivial), dejándonos con

del cual gana el primer término.

Reexpresado, ftoma un número en el orden de magnitud de M y produce un número aproximadamente en el orden de magnitud de M (10 ^M ).

La primera iteración se puede verificar fácilmente a mano. 2718281828459045 es un número del orden de magnitud de 15, por flo tanto, debe producir un número del orden de magnitud de 15 (10 ¹⁵ ) ∼ 10 ¹⁶ . De hecho, el número producido es, desde antes, 2.72⋅10 ^{42381398144233625} , es decir, 10 ^{42381398144233625} ∼ 10 ^{10 16} .

Al observar que M no es un factor significativo en M (10 ^M ), el orden de magnitud del resultado de cada iteración, entonces, sigue un patrón simple de tetración:

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

Fuentes LaTeX

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

Aquí está mi intento revisado:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

Programa de 100 caracteres / byte *, que se ejecuta en el hardware actual (utiliza una cantidad insignificante de memoria y variables int de 32 bits normales), aunque tardará mucho tiempo en completarse.

En realidad, puede ejecutarlo en un intérprete APL y comenzará a imprimir dígitos. Si se le permite completar, habrá impreso un número con 10 × 123456789 ⁴⁴ dígitos.

Por tanto, la puntuación es de 10 ^{10 × 123 456 789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3.406161

Explicación

• ⎕D es una cadena constante predefinida igual a '0123456789'
• n←⍎⎕Ddefine n como el número representado por esa cadena: 123456789 (que es <2 ³¹ y, por lo tanto, puede usarse como una variable de control de bucle)
• {⍞←⎕D} imprimirá los 10 dígitos a la salida estándar, sin una nueva línea
• {⍞←⎕D}⍣nlo hará n veces ( ⍣es el "operador de energía": no es ni *, / ni ^, porque no es una operación matemática, es una especie de bucle)
• {⍞←n}⍣n⍣nrepetirá la operación anterior n veces, por lo tanto imprimirá los 10 dígitos n ² veces
• {⍞←n}⍣n⍣n⍣nlo haré n ³ veces
• Podría caber 44 ⍣nallí, por lo que imprime n ⁴⁴ veces la cadena '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ ^{*: APL puede escribirse en su propio} juego de
^{caracteres de un solo byte (heredado) que asigna símbolos APL a los valores superiores de 128 bytes. Por lo tanto, para fines de puntuación, un programa de N caracteres que solo usa caracteres ASCII y símbolos APL puede considerarse que tiene una longitud de N bytes.}

Haskell, puntaje: (2 ^{2 2 65536-3} ) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

Este programa tiene exactamente 100 bytes de código puro de Haskell. Imprimirá el cuarto número de Ackermann, y eventualmente consumirá toda la energía, materia y tiempo disponibles del Universo y más allá en el proceso ( superando así ligeramente el límite suave de 5 segundos).

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (notación de flecha hacia arriba de Knuth)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

Probablemente ninguna computadora tenga suficiente memoria para ejecutar esto con éxito, pero eso no es realmente culpa del programa. Con los requisitos mínimos del sistema satisfechos, funciona.

Sí, esto está cambiando un poco los valores booleanos. Truese ve obligado 1en este contexto. Python tiene enteros de longitud arbitraria.

GolfScript 3.673e + 374

'~'(.`*

Creo que *está permitido ya que indica la repetición de la cuerda, no la multiplicación.

Explicación: '~'(dejará 126 (el valor ASCII de "~") en la pila. Luego copie el número, conviértalo en una cadena y repita la cadena 126 veces. Esto da 126126126126...cuál es aproximadamente 1.26 e+377. La solución es de 7 caracteres, así que divídalos entre 7^3, para obtener una puntuación de aproximadamente3.673e+374

Rubí, probabilísticamente infinito, 54 caracteres.

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x se inicializa a 97. Luego iteramos el siguiente procedimiento: Genere x números aleatorios entre 0 y 1. Si son todos iguales, luego termine e imprima x. De lo contrario, doble x y repita. Dado que los números aleatorios de Ruby tienen 17 dígitos de precisión, las probabilidades de terminar en cualquier paso son 1 en (10e17) ^ x. La probabilidad de terminar dentro de n pasos es, por lo tanto, la suma de x = 1 a n de (1 / 10e17) ^ (2 ^ n), que converge a 1 / 10e34. Esto significa que para cualquier número, no importa cuán grande sea, es abrumadoramente improbable que este programa genere un número menor.

Ahora, por supuesto, la pregunta filosófica es si se puede decir que un programa que tiene menos de 1 en 10 ^ 34 de terminar en el paso n para cualquier n puede terminar alguna vez. Si suponemos no solo tiempo y potencia infinitos, sino que el programa tiene la capacidad de correr a una velocidad creciente a una velocidad que excede la velocidad a la que disminuye la probabilidad de finalización, podemos, creo, de hecho hacer la probabilidad de terminando por tiempo t arbitrariamente cerca de 1.

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))))))

Esto está descaradamente adaptado de otra respuesta de @Howard e incorpora sugerencias de @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

Mi comprensión de GolfScript es limitada, pero creo que los operadores *y ^anteriores no son los operadores aritméticos prohibidos por el OP.

(Estaré encantado de eliminar esto si @Howard quiere enviar su propia versión, que sin duda sería superior a esta de todos modos).

Este programa calcula un número que es aproximadamente f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))) ))) - una iteración nueve veces mayor de f _{ε 0} - donde f _{ε 0} es la función en la jerarquía de rápido crecimiento que crece aproximadamente a la misma velocidad que la función de Goodstein. (f _{ε 0}crece tan rápido que las tasas de crecimiento de la función n (k) de Friedman y de las flechas encadenadas de Conway de k-pliegues son prácticamente insignificantes incluso en comparación con un solo f _{ε 0} no iterado) .

dc, 100 caracteres

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Dado suficiente tiempo y memoria, esto calculará un número alrededor de 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. Originalmente había implementado la función de hiperoperación , pero requería demasiados caracteres para este desafío, por lo que eliminé las condiciones n = 2, b = 0y n >= 3, b = 0, convirtiendo la n = 1, b = 0condición en n >= 1, b = 0.

Los únicos operadores aritméticos utilizados aquí son la suma y la resta.

EDITAR: como se prometió en los comentarios, aquí hay un desglose de lo que hace este código:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

Como se señaló, esto se desvía de la función de hiperoperación en que los casos base para la multiplicación y superiores se reemplazan con el caso base para la suma. Este código se comporta como si a*0 = a^0 = a↑0 = a↑↑0 ... = a, en lugar de matemáticamente correcto a*0 = 0y a^0 = a↑0 = a↑↑0 ... = 1. Como resultado, calcula valores que son un poco más altos de lo que deberían ser, pero eso no es gran cosa ya que apuntamos a números más grandes. :)

EDITAR: Acabo de notar que un dígito se deslizó en el código por accidente, en la macro que realiza incrementos para n=0. Lo eliminé reemplazándolo con 'F' (15), que tiene el efecto secundario de escalar cada operación de incremento en 15. No estoy seguro de cuánto afecta esto al resultado final, pero probablemente ahora sea mucho más grande.

¿No hay más límite en tiempo de ejecución? OK entonces.

¿El programa necesita ser ejecutable en computadoras modernas?

Ambas soluciones utilizan una compilación de 64 bits, por lo que longes un número entero de 64 bits.

C: mayor que 10 ^{(2 64 -1) 2 64} , que en sí es mayor que 10 ^{10 355393490465494856447} ≈ 10 ↑↑ 4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 caracteres.

Para facilitar estas fórmulas, las usaré t = 2^64-1 = 18446744073709551615.

mainllamará fcon un parámetro de t, que recorrerá los ttiempos, cada vez que imprima el valor ty llame fcon un parámetro de t-1.

Cifras totales impresas 20 * t.

Cada una de esas llamadas a fcon un parámetro de t-1iterará tveces, imprimirá el valor ty llamará a f con un parámetro de t-2.

Total de dígitos impresos: 20 * (t + t*t)

Probé este programa usando el equivalente de enteros de 3 bits (configuré i = 8y tuve una llamada principal f(7)). Llegó a la declaración de impresión 6725600 veces. Eso funciona. 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7Por lo tanto, creo que este es el conteo final para el programa completo:

Total de dígitos impresos: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

No estoy seguro de cómo calcular (2 ⁶⁴ -1) ^{2 64} . Esa suma es menor que (2 ⁶⁴ ) ^{2 64} , y necesito una potencia de dos para hacer este cálculo. Por lo tanto, calcularé (2 ⁶⁴ ) ^{2 64 -1} . Es más pequeño que el resultado real, pero como es una potencia de dos, puedo convertirlo a una potencia de 10 para compararlo con otros resultados.

¿Alguien sabe cómo realizar esa suma o cómo convertir (2 ⁶⁴ -1) ^{2 64} a 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
divida ese exponente entre la base logarítmica 2 de 10 para cambiar la base del exponente a potencias de 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Pero recuerde, esa es la cantidad de dígitos impresos. El valor del entero es 10 elevado a esa potencia, entonces 10 ^ 10 ^ 355393490465494856447

Este programa tendrá una profundidad de pila de 2 ^ 64. Eso es 2 ^ 72 bytes de memoria solo para almacenar los contadores de bucle. Son 4 mil millones de terabytes de contadores de bucles. Sin mencionar las otras cosas que irían a la pila por 2 ^ 64 niveles de recursión.

Editar: corrigió un par de errores tipográficos y usó un valor más preciso para log2 (10).

Edición 2: Espera un segundo, tengo un bucle del que el printf está fuera. Vamos a arreglar eso. Se agregó inicialización i.

Edición 3: Maldita sea, arruiné las matemáticas en la edición anterior. Fijo.

Este se ejecutará en computadoras modernas, aunque no terminará pronto.

C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 personajes.

Esto imprimirá el inverso bit a bit de cero, 2 ^ 64-1, una vez para cada iteración. 2 ^ 64-1 es un número de 20 dígitos.

Número de dígitos = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Redondeando la longitud del programa a 100 caracteres, Puntuación = número impreso / 1,000,000

Puntuación = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R - 49 41 caracteres de código, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

imprimirá [reproduciendo aquí solo el comienzo]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 es G (1) donde G (64) es el número de Graham)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Salida: 10 ^ 3 ↑↑↑↑ 3

Consejos:

Ges la función donde G (64) es el número de Graham. La entrada es un entero. La salida es una cadena unaria escrita con 0. Eliminada por brevedad.

Kes la función de flecha hacia arriba de Knuth a ↑ ⁿ b donde a es implícitamente 3. La entrada es n, una cadena unaria yb, una cadena unaria. La salida es una cadena unaria.

u es "1".

v es "0000" o G (0)

e es "000".

C

(Con disculpas a Darren Stone)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ número de 64 dígitos (9 ...)

l = 100 caracteres de código

puntaje ≈ 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

[Puntuación = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6]

Tenga en cuenta que merezco ser azotado sin piedad por esta respuesta, pero no pude resistirme. No recomiendo actuar como yo en stackexchange, por razones obvias. :-PAGS

EDITAR: Sería aún más difícil resistir la tentación de ir con algo como

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... pero supongo que una regla intencionada pero no especificada era que se debe imprimir toda la serie de dígitos que componen el número.

Nuevo Ruby: puntaje ~ f _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

donde f _α (n) es la jerarquía de rápido crecimiento.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

Pruébalo en línea!

El *nson sólo cuerdas y la matriz de multiplicación, por lo que debe estar bien.

Código sin golf:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

donde b.-b<=>0devuelve un entero 1más cercano a 0que b.

Explicación:

Se imprime nal comienzo de cada llamada de H.

H[[]]dobles n( nveces), es decir n = n<<n.

H[[0,a,b,c,...,z]]llamadas H[[a,b,c,...,z]]( nveces).

H[[k+1,a,b,c,...,z]]llamadas H[[k]*n+[a,b,c,...,z]]( nveces), donde [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]llamadas H[[n]*n+[a,b,c,...,z]]( nveces).

H[[-(k+1),a,b,c,...,z]]llamadas H[[-k]*n+[a,b,c,...,z]]( nveces).

H[k] = H[[k]].

Mi programa se inicializa n = 126, luego llama H[-n-1]126 ² 2 ¹²⁶ veces.

Ejemplos:

H[[0]]llamará lo H[[]]que corresponda n = n<<n(n veces).

H[[0,0]]llamará H[[0]]( nveces).

H[[1]]llamará H[[0]*n]( nveces).

H[[-1]]llamará H[[n]*n]( nveces).

H[[-1,-1]]llamará H[[n]*n+[-1]]( nveces).

H[[-3]]llamará H[[-2]*n]( nveces).

Pruébalo en línea!

Ver revisiones para otras cosas interesantes.

Haskell - Función de Ackermann aplicada a su resultado 20 veces - 99 caracteres

Esta es la mejor solución de Haskell que se me ocurre basada en la función de Ackermann: puede observar algunas similitudes con la solución de nm, el i = round $ log pi se inspiró a partir de ahí y el resto es una coincidencia: D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

Ejecuta la función ackermann sobre sí misma 20 veces, comenzando en una, la secuencia es

• 1,
• 3,
• 61,
• a (61,61),
• a (a (61,61), a (61,61)) --- llamaremos a esto un ₂ (61), o un ₄ (1) ---
• a ₃ (61)
• ...
• un ₁₈ (61) o un ₂₀ (1). Creo que esto es aproximadamente g ₁₈ (ver más abajo).

En cuanto a la estimación, wikipedia dice:

a (m, n) = 2 ↑ ^m-2 (n + 3) - 3

De esto podemos ver a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3, que es claramente mayor que g1 = 3 ↑ ⁴ 3, a menos que el 3 al inicio sea mucho más importante de lo que creo. Después de eso, cada nivel hace lo siguiente (descartando las constantes insignificantes en un _n ):

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Si estos son aproximadamente equivalentes, entonces un ₂₀ (1) ~ = g ₁₈ . El término final en a _n , (a _n-1 ) es mucho mayor que 3, por lo que es potencialmente mayor que g ₁₈ . Veré si puedo averiguar si eso lo impulsaría incluso una sola iteración e informaré.

Código de máquina x86: 100 bytes (ensamblado como archivo MSDOS .com)

Nota: puede doblar un poco las reglas

Este programa generará 2 ^{(65536 * 8 + 32)} nueves que pondrían el puntaje en (10 ^{2 524320} -1) / 1000000

Como contador, este programa usa la pila completa (64 KB) más dos registros de 16 bits

Código ensamblado:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Montaje:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

C

El tamaño del archivo es de 45 bytes.

El programa es:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

Y el número producido es mayor que 10 ^ (10 ^ (10 ^ 1.305451600608433)).

El archivo al que redireccioné std actualmente tiene más de 16 Gb y sigue creciendo.

El programa finalizaría en un período de tiempo razonable si tuviera una computadora mejor.

Mi puntaje es indiscutible con doble punto flotante de precisión.

GNU Bash, 10 ^ 40964096² / 80 ^ 3 ≈ 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 4096 en cualquier sistema razonable. SHLVL es un número entero positivo pequeño (generalmente 1 o 2 dependiendo de si / bin / sh es bash o no).

Solo UNIX de 64 bits:

Puntuación: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

Creamos una matriz de 258048 enteros sin signo. No podría ser largos sin firmar porque eso hizo que el programa fuera demasiado largo. No están firmados porque no quiero usar un comportamiento indefinido, este código es C adecuado (aparte de la falta de retorno de main ()) y se compilará y ejecutará en cualquier máquina normal, aunque seguirá funcionando durante mucho tiempo . Este tamaño es el más grande que podemos expresar legalmente sin usar caracteres que no sean ascii.

Recorremos la matriz a partir del último elemento. Imprimimos los dígitos de 2^32-1, incrementamos el elemento y soltamos el ciclo si el elemento no se ha ajustado a 0. De esta manera, recorreremos los (2^32 - 1)^254048 = 2^8257536tiempos, imprimiendo 10 dígitos cada vez.

Aquí hay un código de ejemplo que muestra el principio en un rango de datos más limitado:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

El resultado es aproximadamente 10 ^ 10 ^ 2485766 dividido por un millón, que sigue siendo aproximadamente 10 ^ 10 ^ 2485766.

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

Esto tarda mucho más de 5 segundos en ejecutarse.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Recupera y concatena la longitud de bytes de cada archivo en su unidad actual. Regex elimina todos los caracteres que no sean dígitos.

Python 3, puntaje = ack (126,126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

La función f es la función ackermann, que tengo suficiente espacio para invocar.

Editar: anteriormente "else n + 1", que violaba las reglas de desafío: felicitaciones a Simply Beautiful Art.

JavaScript 98 caracteres

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

genera 2.718e + 239622337 ≈ 10 ↑↑ 2.9232195202

Para puntajes de poco más de 2.718e + 239622331 ≈ 10 ↑↑ 2.9232195197

que es lo más grande que puedo hacer sin que se caiga el navegador.

(console.log (a) le mostrará la salida completa)

No ejecutes estos:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

generaría 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (también conocido como 2.718 * 10 ^ (1.213 * 10 ^ 12) para comparar con la respuesta más larga:

versión más extrema, si no bloqueó su navegador: (80 caracteres)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

que crearía un número aproximadamente del mismo tamaño que e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

Editar: la solución original del código actualizado solo generó 2.718e + 464

Python 3: 98 caracteres, ≈ 10 ↑↑ 256

Usando una función de argumento variable:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

Efectivamente, E disminuye el primer argumento mientras aumenta el resto de los argumentos, excepto que en lugar de poner -1 en los argumentos, deja caer el argumento. Como cada ciclo disminuye el primer argumento o disminuye el número de argumentos, se garantiza que terminará. La función creciente utilizada es int ("% d% d"% (k, k)), que da un resultado entre k ** 2 + 2 * k y 10 * k ** 2 + k. Mi código usa el símbolo *, pero no como multiplicación. Se utiliza para trabajar con números variables de argumentos, que creo que deberían seguir las reglas, ya que el objetivo claro de las reglas era restringir operaciones específicas, no los símbolos en sí.

Algunos ejemplos de cuán grande es E rápidamente:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

Solo los dos primeros son ejecutables en mi computadora en un tiempo razonable.

Entonces, E es invocado por E(*range(ord('~')))- lo que significa:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

No estoy completamente seguro de cuán grande es (he estado tratando de aproximarlo en vano), pero es obvio que es ~ realmente ~ grande.

Como ejemplo, alrededor de doce ciclos, el resultado es: (técnicamente un poco más que)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

Estimación de resultados:

Si nos aproximamos al paso creciente lambda k: 10 * k**2, la función se puede describir como

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

Lo relevante que estamos haciendo aquí es construir una torre de poderes de diez, por lo que el puntaje eventual se puede aproximar a 10 ↑↑ 256.

Mejor (aunque parcial) estimación de resultados:

Esto usa lo mismo 10 * k**2que la otra estimación.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

Según la estimación anterior, sería:

E(a, b) = 10**(a**2/a) * b**(2*a)

Que es significativamente más pequeño que el valor real ya que usa en a**2lugar de 2**apara el 10 y usa en a*2lugar de 2**apara el b.

C (puntaje ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3.005558275)

• ~ 20 GB de salida
• 41 caracteres (41 ^ 3 no significa nada)

main(){for(;rand();printf("%d",rand()));}

A pesar de que rand()la salida es determinista porque no hay una función semilla.