Número más grande imprimible

113

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 26 ) / 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 20 (1) / 99 3 [1]
  9. Fraxtil , cc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 3 [3]
  10. Magenta , Python, ≈ ack (126,126) / 100 3 ≈ 10 ↑ 124 129
  11. Kendall Frey , ECMAScript 6, ≈ 10 3 ↑ 4 3 /100 3 [1]
  12. Ilmari Karonen , GolfScript, ≈ 10 ↑ 3 10 377 /18 3 [1]
  13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 3
  14. recursivo , Python, ≈ 2 ↑↑ 11/95 3 ≈ 10 ↑↑ 8.63297 [1] [3]
  15. nm , Haskell, ≈ 2 ↑↑ 7/100 3 ≈ 10 ↑↑ 4.63297 [1]
  16. David guiñada , C, ≈ 10 10 4 × 10 22 /83 3 ≈ 10 ↑↑ 4,11821 [2]
  17. primo , Perl, ≈ 10 (12750684.161 mil!) 5 × 2 27 /100 3 ≈ 10 ↑↑ 4.11369
  18. Arte , C, ≈ 10 10 2 × 10 6 /98 3 ≈ 10 ↑↑ 3.80587
  19. Robert Sørlie , x86, ≈ 10 2 2 19 +32 / 100 3 ≈ 10 ↑↑ 3.71585
  20. Tobia , APL, ≈ 10 10 353 /100 3 ≈ 10 ↑↑ 3.40616
  21. Darren Stone , C, ≈ 10 10 97.61735 / 98 3 ≈ 10 ↑↑ 3.29875
  22. ecksemmess , C, ≈ 10 2 320 /100 3 ≈ 10 ↑↑ 3.29749
  23. Adam Speight , vb.net, ≈ 10 5,000 × (2 64 ) 4 /100 3 ≈ 10 ↑↑ 3.28039
  24. Joshua , golpe, ≈ 10 10 15 /86 3 ≈ 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))

Vereos
fuente
16
¿Alguien ha dicho explícitamente "base 10" todavía?
keshlam
1
¿Cuenta el número grande si es decir 12e10(12 * 10 ^ 10) como 12*10^10?
hichris123
44
Creo que una mejor restricción en lugar de prohibir *, / y ^, habría sido permitir solo operaciones lineales , por ejemplo , +, -, ++, -, + =, - =, etc. De lo contrario, los codificadores pueden aprovechar de las funciones de biblioteca de flecha hacia arriba / Ackermann de Knuth si están disponibles en su idioma de elección, lo que parece una trampa.
Andrew Cheong
14
Todavía estoy esperando ver a alguien ganar una nota al pie [4].
Brian Minton
1
Diga, si mi programa se imprime 500b, ¿es esto inválido? Es decir, ¿podemos ignorar todas las cosas no numéricas que imprime un programa? Y si es así, ¿algo como 50r7contar como 507?
Simply Beautiful Art

Respuestas:

20

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

Peter Taylor
fuente
Si no me equivoco, el número que calcula su programa (llámelo n) se puede escribir n = f ^ 9 (g (3)), donde f (x) = g ^ (4x) (x), y g ( x) es la vida útil del gusano [x]. Si tratamos a g como aproximadamente lo mismo que f_eps_0 en la jerarquía de rápido crecimiento, entonces mis cálculos de "respaldo" muestran que f_ (eps_0 + 2) (9) <n <f_ (eps_0 + 2) (10 ) Por supuesto, es el ganador actual, con diferencia.
res
@res, creo que eso lo está subestimando bastante. .{foo}*mapas xa foo^x (x). Si tomamos h_0 (x) = g^4 (x)y h_{i+1} (x) = h_i^x (x)luego el valor calculado es h_9 (g(3)). Su f(x) = g^(4x) (x) = h_0^x (x) = h_1 (x).
Peter Taylor
(Esto se refiere a su programa original, acabo de ver que ha realizado algunas modificaciones). Ohhh ... no entendí cómo *funciona. Es seguro decir que h_0 (x) = g ^ 4 (x) >> f_eps_0 (x); en consecuencia, la relación h_ {i + 1} (x) = h_i ^ x (x) define efectivamente una jerarquía de crecimiento rápido "acelerado" tal que h_i (x) >> f_ (eps_0 + i) (x). Es decir, el número calculado h_9 (g (3)) es ciertamente mucho mayor que f_ (eps_0 + 9) (g (3)). En cuanto a g (3), creo que puedo demostrar que es mayor que g_4, el cuarto número en la secuencia de g_i utilizado para definir el número de Graham (que es g_64).
res
@res, entonces j_i ~ f_{eps_0 + i}; hace eso k_i ~ f_{eps_0 + i omega + i^2}?
Peter Taylor
Dado lo que escribiste, entiendo k_i ~ f_{ε_0 + ω}^i (k_0). Aquí está el razonamiento: k_ {i + 1} = j_ {k_i} (k_i) = j_ω (k_i) ~ f_ {ε_0 + ω} (k_i) ~ f_ {ε_0 + ω} ^ 2 (k_ {i-1}) ... ~ f_ {ε_0 + ω} ^ {i + 1} (k_0), entonces k_i ~ f_ {ε_0 + ω} ^ i (k_0). Entonces es un límite inferior muy conservador en k_i, enteramente en términos de la jerarquía de rápido crecimiento k_i >> f_{ε_0 + ω}^i (i) = f_{ε_0 + ω + 1} (i).
res
91

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.

Hand-E-Food
fuente
19
¡Genio puro y sin adulterar!
WallyWest
77
Creo que se supone que debes dividir en cubos la longitud de la solución en la que obtengo aproximadamente 321 como puntajeYour printed number will be divided for the number of bytes you used for your solution^3.
Cruncher
1
77 votos a favor, y sin embargo ... noto que el puntaje es 321 ...
Simply Beautiful Art
3
@SimplyBeautifulArt, no es el puntaje, sino el viaje. :-D
Hand-E-Food
44
Aparentemente, uno que rió a muchos. Ahora, si pudiéramos llevar esto a la clasificación ... alguien necesita ganar la etiqueta de "daño irreparable";)
Simply Beautiful Art
87

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 377 :

'~'(.`*

(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 377 veces:

'~'(.`*.~*

En realidad, nunca verás terminar este programa, ya que trata de calcular un número con aproximadamente 10 380 ≈ 2 1140 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 80 , 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 380 /10 80 = ¡10 300 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 377 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 377 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 ↑ 3 10 377 , dar o tomar algunas (o 10 377 ) 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. ;-)

Ilmari Karonen
fuente
99
"...No computer ever built could store a number that big...Corrígeme si me equivoco, pero no creo que eso se aplique aquí. ¿No se trata simplemente de "almacenar" e imprimir 3 dígitos a la vez (?) Para que no sea necesario almacenar el resultado final.
Kevin Fegan el
12
@KevinFegan: Eso es cierto: el número es increíblemente repetitivo, por lo que sería fácil de comprimir. Pero entonces ya no estamos realmente almacenando el número en sí, sino más bien una fórmula abstracta a partir de la cual, en teoría, se puede calcular el número; de hecho, una de las fórmulas más compactas es probablemente el programa GolfScript anterior que lo genera. Además, una vez que vamos un paso más allá hacia el siguiente programa, incluso "imprimir" los dígitos uno por uno antes de descartarlos se vuelve poco práctico; simplemente no hay una forma conocida de llevar a cabo tantos pasos de computación clásica en el universo.
Ilmari Karonen
¡GolfScript de @ IlmariKaronen acaba de darle al Googol una cuña!
WallyWest
55
¿Qué tal si realmente llevamos esto al límite, vemos cuán grande es exactamente lo que realmente puedes lograr en GolfScript en 100 caracteres? Tal como está, su resultado es menor que el número de Graham (que mi solución de Haskell "se aproxima"), pero como usted dice, GolfScript probablemente puede ir aún más lejos.
dejó de girar en sentido contrario a las agujas del reloj el
3
@leftaroundabout: logré escribir un evaluador de notación de flecha de Conway en 80 caracteres de GolfScript, aunque no cumple con todos los requisitos de este desafío (utiliza constantes numéricas y operadores aritméticos). Probablemente podría mejorarse, pero pensé que podría plantearlo como un nuevo desafío.
Ilmari Karonen
42

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

WallyWest
fuente
99
No hay reglas dobladas en absoluto:;) * No se puede usar 0123456789 [marcar] * Usar cualquier idioma en el que los dígitos sean caracteres válidos; [marcar] * Puede usar matemática / física / etc. constantes <10. [check, used 2] * La recursión está permitida pero el número generado debe ser finito; [comprobar, sin recursión] No se puede usar *, /, ^; [verificar] Su programa puede generar más de un número; [marcar] Puede concatenar cadenas; [verificar] Su código se ejecutará tal cual; [verificar] Longitud máxima del código: 100 bytes; [verificación] Necesita finalizar con 5 segundos [verificación]
WallyWest
Afeitarse 2 caracteres pasando "."para reemplazar en lugar de/\./g
gengkev
1
@gengkev Lamentablemente, solo usar .replace (".", "") solo elimina el primero. personaje; Yo tengo a utilizar el reemplazo global para reemplazar todo. personajes de la cadena ...
WallyWest
En m=Math,p=m.PI,e=m.E,s="",alert((p*p*p+s+e*e*e).replace(/\./g,s))cambio, puede hacerlo , su puntaje es 3100627668029981620085536923187664/63 ^ 3 = 1.240017943838551e + 28
AMK
1
@Cory Por un lado, no voy a repetir una constante, de lo contrario todo el mundo lo estaría usando ... Segundo, realmente no tengo un segundo argumento ...
WallyWest
28

C, puntaje = 10 10 97.61735 / 98 3 ≈ 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 64 -1, repetido (2 64 -1) 4 veces . Primero, así es como estoy estimando (bajo) el número acumulado de dígitos de 1 a 2 64 -1 (la "subsecuencia"): El número final en la secuencia de subsecuencia es 2 64 -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 64 -1) 4 veces, por lo que la longitudde n será al menos (0.9 × (2 64 -1) × 19 + 0.1 × (2 64 -1) × 10) × (2 64 -1) 4 = 3.86613 × 10 97 dígitos. En los comentarios a continuación, @primo confirma que la longitud de n es 4.1433x10 97 . Entonces n en sí será 10 a esa potencia, o 10 10 97.61735 .

l = 98 caracteres de código

puntaje = n / l 3 = 10 10 97.61735 / 98 3

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

Piedra de Darren
fuente
2
En C, 'z'es el valor constante 122. ¿Derecho?
primo
1
Creo que printf("%d",n)hará que el número sea mucho mayor. Además, el ordenador de 64 bits no significa largos de 64 bits, por ejemplo, Windows utiliza el modelo LLP64 tanto tiempo sigue siendo de 32 bits
phuclv
3
No debería importar . El desbordamiento de entero firmado es un comportamiento indefinido en C, por lo que es imposible predecir qué sucederá cuando se ejecute su código. Puede violar el requisito de finitud.
Dennis
1
Creo que el análisis puede estar un poco fuera de lugar. La concatenación de 0..2^64-1es exactamente 357823770363079921190 dígitos de largo. Los (2^64-1)^4tiempos repetidos son 4.1433x10 ^ 97. Lleva 10 a ese poder es 10^10^97.61735≈ 10 ↑↑ 3.29875. Creo que estás reclamando un poder de diez que no tienes (nota dónde se 3.866×10^97convirtió 3.866^10^97.
Primo
2
Hola @primo. Gracias por dedicar tiempo para comprobar esto. Lo aprecio. Ya veo lo que dices. Mi exponente final está mal. Debería ser en 2.0lugar de 97. 10^10^10^2.00= 10^10^97.6. Lo reflejaré en mi puntaje ahora.
Darren Stone
19

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.

Cel Skeggs
fuente
44
Se ve muy bien; aparentemente su "Ackermann modificado" es exactamente un evaluador de la cadena Conway .
dejó de girar en sentido contrario a las agujas del reloj el
1
@leftaroundabout No del todo, pero creo que tiene la misma fuerza recursiva. Además, los ceros no son válidos en las cadenas, por lo que querrás eliminar el cero de tu cadena de Conway en la lista de puntajes.
Cel Skeggs
1
¿Por qué lo hiciste range(ord('~'))? ¿No podría haber hecho range(125)por menos bytes, lo que le permitiría obtener un número mayor como range(A(9,9,9))?
Esolanging Fruit
1
@ Challenger5: la regla 1 dice "No puede usar dígitos en su código (0123456789)"
Cel Skeggs
@ CelSkeggs: Oh, me olvidé de eso.
Esolanging Fruit
18

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 2 (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

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

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

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

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

((((((.*.*)*)*)*)*)*)*
P 7 (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.

primo
fuente
1
Entonces, ¿esto solo será una solución válida siempre que el número de versión permanezca por debajo de 10?
Sr. Lister el
3
@MrLister Sí. Afortunadamente, no existe una versión principal superior a la 6, e incluso eso no se considera totalmente 'listo', a pesar de haber sido anunciado originalmente en 2000.
primo
@primo Te das cuenta de que tendrás que revisar esta respuesta una vez que Perl ingrese un número de versión> 10, ¿verdad? ;)
WallyWest
3
@ Eliseod'Annunzio Si todavía estoy vivo cuando llegue ese día, si es que lo hago, prometo volver y arreglarlo.
primo
2
Una solución en ejecución que supera 10 ↑↑ 4. Eso es impresionante. ¡Bravo!
Tobia
16

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

        ingrese la descripción de la imagen aquí

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 15 ). Usando equivalencias para sumas finitas , lo anterior se puede expresar explícitamente como

        ingrese la descripción de la imagen aquí

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

        ingrese la descripción de la imagen aquí

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

        ingrese la descripción de la imagen aquí

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 -

        ingrese la descripción de la imagen aquí

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

        ingrese la descripción de la imagen aquí

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 15 ) ∼ 10 16 . 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 16
  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}
Andrew Cheong
fuente
Mi cálculo sobre su puntaje se basa en la observación que fhace algo como llevar el número za su propio poder. Entonces eso es algo así ↑↑↑. Por supuesto que el puntaje no es 2↑↑↑2, lo siento ... más bien, 2↑↑↑5+1parece. ¿Estaría de acuerdo, debería poner eso en la tabla de clasificación?
dejó de girar en sentido contrario a las agujas del reloj el
@leftaroundabout - Gracias por investigarlo nuevamente. No me siento lo suficientemente cómodo con la notación de flecha hacia arriba para decir si su sugerencia suena bien o no, pero calculé el orden de magnitud de mi puntaje (ver edición) si desea actualizar la tabla de clasificación con eso.
Andrew Cheong
¡Excelente! Tampoco estoy firme con las flechas hacia arriba. Así que en realidad tienes "solo" una torre de poder; Me temo que eso te coloca dos lugares más abajo en el ranking. Felicitaciones por analizar adecuadamente el resultado; mis estimaciones probablemente tengan aún más defectos, pero sentí que alguien debería al menos tratar de ordenar las respuestas.
dejó de girar en sentido contrario a las agujas del reloj el
1
Tu puntaje está mal. Cada vez que comienza un ciclo con i=o.z;while(i--)...usted no está ejecutando los o.ztiempos de ciclo , porque un ciclo se basa en una variable entera y o.zcontiene una cadena más grande que el entero representable más grande, dependiendo del tamaño de palabra de su intérprete. Suponiendo, para su beneficio, que su intérprete no vomitará al convertir una cadena de este tipo en int, icomenzará cada vez con su valor entero representable más grande, digamos 2 ^ 63, y no con el valor actual de o.z.
Tobia
2
@ acheong87 No se elimine, solo tiene que volver a calcular su puntaje, limitando las variables de bucle a 2 ^ 63 o algo así. PD: deja tu puntaje analítico publicado aquí, ¡es muy instructivo!
Tobia
14

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 44 dígitos.

Por tanto, la puntuación es de 10 10 × 123 456 789 44 /100 3 ≈ 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 31 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 2 veces
  • {⍞←n}⍣n⍣n⍣nlo haré n 3 veces
  • Podría caber 44 ⍣nallí, por lo que imprime n 44 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.

Tobia
fuente
Su número impreso se dividirá por la cantidad de bytes que utilizó para su solución ^ 3. , estás dividiendo por 100 en este momento.
ToastyMallows
2
@ToastyMallows: me parece 100 cubed(100 ^ 3).
Kevin Fegan el
1
Lo sé pero son bytes, no caracteres.
ToastyMallows
1
@ToastyMallows Lea las notas finales sobre la respuesta.
Simply Beautiful Art
Cambio {⍞←⎕D}a ⍞←lo que le ahorra tres bytes que se pueden utilizar para agregar una más ⍣ny hacer ⊢n←⍎⎕Den ⌽⍕n←⍎⎕Dun aumento de 80 veces. Si permite ejecutar con ⎕PP←17, use en ×⍨lugar de lo ⌽⍕cual casi duplica la cantidad de dígitos impresos.
Adám
12

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

Nuevo Méjico
fuente
o=length[]te da un extra !qal final y te ahorra un byte además de eso.
Khuldraeseth na'Barya
9

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.

recursivo
fuente
Tu código no se ejecuta. Solo lo print True<<(True<<(True<<(True<<True<<True)))hace, y eso genera una cadena de 19k.
Gabe
¿Cuáles son los requisitos mínimos del sistema?
Danubian Sailor
8
¿No podría acortarlo definiendo t=Truey luego usando tafter?
Bob
1
Mejor aún, solo haga un bucle que haga estos anidamientos por usted.
Simply Beautiful Art
Esto falla para mí:$python -c 'print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))' Traceback (most recent call last): File "<string>", line 1, in <module> OverflowError: long int too large to convert to int
Brian Minton
8

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

Ben Reich
fuente
7

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.

histocrat
fuente
3
esto depende del generador de números, que en la mayoría de los idiomas es poco probable que sea capaz de generar 97 veces el mismo número
monstruo de trinquete
1
Buen punto, por lo que además de suponer que el poder de cómputo aumenta continuamente y de forma rápida, también necesito asumir una fuente perfecta de aleatoriedad y una implementación de Ruby que lo use.
histocrat
7

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 ε 0crece 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) .

res
fuente
'',:o;'oo',:t;simplemente asigna los valores 0a oy 2para t; si eso es solo para evitar la falta de dígitos, entonces se puede abreviar en gran medida ,:o)):t;, excepto que no hay razón para eliminar ten primer lugar porque puede escribir expr:t;{...}:f;[[[t]f]f]fcomo [[[expr:t]{...}:f~]f]fguardar otros 3 caracteres.
Peter Taylor
Todavía no es necesario hacer estallar o: estoy bastante seguro de que [0 126]fserá uno más grande, [126]fpor lo que guarda un carácter y aumenta la salida. Aunque está dejando una cadena vacía allí, lo que probablemente rompe las cosas: podría ser mejor comenzar[[,:o'~'=]
Peter Taylor
Ah, y [son innecesarios ya que no tienes nada más en la pila.
Peter Taylor
Ha ... desplazándose estas respuestas, y luego veo esto ... y entonces me di cuenta de la respuesta aceptada ... hm ......
Simply Beautiful Art
@SimplyBeautifulArt No estoy seguro de lo que quieres decir, pero la respuesta aceptada calcula un número mucho mayor que este (suponiendo que ambos son como se afirma).
res
7

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.

Fraxtil
fuente
No tengo idea de lo que hace este código ... solo puedo suponer que es correcto. ¿Quizás podrías explicar un poco?
dejó de girar en sentido contrario a las agujas del reloj el
Explicaré el código pieza por pieza cuando tenga tiempo más tarde esta noche.
Fraxtil
Bueno, me limité a esa explicación, pero la he agregado ahora. Espero que aclare las cosas.
Fraxtil
dc-1.06.95-2 termina inmediatamente, sin haber impreso nada.
primo
1
No esperaría que funcione en ninguna máquina existente, dada la magnitud del valor que intentará generar. Tengo la misma versión de dc y falla después de unos segundos. Supongo que aquí se permiten respuestas "teóricamente correctas", ya que no hay criterios para el consumo de recursos.
Fraxtil
6

¿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 64 -1) 2 64 . Esa suma es menor que (2 64 ) 2 64 , y necesito una potencia de dos para hacer este cálculo. Por lo tanto, calcularé (2 64 ) 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 64 -1) 2 64 a 10 n ?

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

David Yaw
fuente
Tal vez. %uestaba imprimiendo números de 32 bits incluso con una compilación de 64 bits, así que simplemente hice la llcostumbre de escribir en un compilador de 32 bits.
David Yaw
Creo que %llusería para long long, y %lusería correcto para long.
tomlogic
Fijo. Fuerza del hábito: %usiempre es de 32 bits, %llusiempre es de 64 bits, ya sea compilando como 32 o 64 bits. Sin embargo, la solución aquí requiere que longsea ​​de 64 bits, por lo que tiene razón, %lues suficiente.
David Yaw
No se garantiza que sus variables en la pila se inicialicen a 0. En el segundo programa, simplemente colóquelas fuera de cualquier función. En el primero, tendrás que inicializar i.
Arte el
Además, el desbordamiento prolongado es un comportamiento indefinido y muchos compiladores modernos simplemente lo optimizarán si lo detectan, es probable que desee usar sin firmar durante mucho tiempo.
Arte el
5

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........
lebatsnok
fuente
2
No creo que necesites incluir el número en la publicación. También ocupa mucho espacio en dispositivos móviles.
Totalmente humano
@totallyhuman Estoy de acuerdo, tal vez los primeros 100 dígitos, máximo
tuskiomi
@totallyhuman ok gracias hecho :)
lebatsnok
catEs una función extraña en que el primer argumento es .... Entonces, todo antes del primer argumento nombrado va a ...(y será cat'editado), por lo que sepdebe nombrarse, de lo contrario, podría acortarse comocat(abs(.Random.seed),,"")
lebatsnok
5

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 ↑ n 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".

Kendall Frey
fuente
Maximum code length is 100 bytes;De lo contrario, esto es, cerca de inmejorable
Cruncher
@Cruncher Aaah, me perdí eso
Kendall Frey
Ahh, te odio ahora. Cada vez que trato de comprender el tamaño del número de Graham me duele la cabeza.
Cruncher el
Además, ¿el número de Graham no cuenta como una constante> 10?
serakfalcon
1
Ahora para determinar si el mío supera al de Ilmari.
Kendall Frey
5

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.

ecksemmess
fuente
1
#DEFINE C while (- long n, o, p, q, r, s, t; main () {Cn) {Co) {Cp) {Cq) {Cr {Cs {Ct) {putchar ('z' -'A ');}}}}}}}}
RobAu
@RobAu Eres un genio! Haz que sea una respuesta. Estoy seguro de que sería el ganador. Creo que olvidaste un par ), pero está bien, porque ahora solo tienes 96 caracteres.
Andrew Larsson
Para todos los que no obtuvieron el sarcasmo: ver codegolf.stackexchange.com/a/18060/7021 para una solución aún mejor;)
RobAu
5

Nuevo Ruby: puntaje ~ f ω ω2 +1 (126 2 2 126 )

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 2 126 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.

Simplemente hermoso arte
fuente
Continuemos esta discusión en el chat .
HyperNeutrino
En realidad son 103 bytes, creo que tenía una nueva línea final.
Rɪᴋᴇʀ
@Riker Creo que has copiado y pegado desde aquí. Tenga en cuenta que debe haber un carácter no imprimible en la segunda línea, por lo tanto, 104 bytes.
Simply Beautiful Art
@SimplyBeautifulArt ah, está bien. Pensé que había copiado el personaje. Lo siento.
Rɪᴋᴇʀ
@Riker Nah, ni siquiera está allí debido a que Stackexchange no me permite ocultar personajes invisibles en todas partes.
Simply Beautiful Art
4

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 2 (61), o un 4 (1) ---
  • a 3 (61)
  • ...
  • un 18 (61) o un 20 (1). Creo que esto es aproximadamente g 18 (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 ↑ 59 64 + 3, que es claramente mayor que g1 = 3 ↑ 4 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 20 (1) ~ = g 18 . El término final en a n , (a n-1 ) es mucho mayor que 3, por lo que es potencialmente mayor que g 18 . Veré si puedo averiguar si eso lo impulsaría incluso una sola iteración e informaré.

Toeofdoom
fuente
Su análisis es correcto y g <sub> 18 </sub> es una buena aproximación.
Simply Beautiful Art
length"a"ahorra un par de bytes y le permite otro.a
Khuldraeseth na'Barya
4

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'
Robert Sørlie
fuente
Obviamente nunca corriste esto. Sobrescribe su código y se bloquea.
Joshua
4

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.

iWiggins
fuente
4

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'
Joshua
fuente
SHLVL es el nivel de bash como subbash:bash -c 'bash -c "echo \$SHLVL"'
F. Hauri
stat --printfno trabajes Pruebastat -c %s
F. Hauri
@ F.Hauri: --printf funciona para mí, pero también lo hace -c, por lo que se redujeron algunos bytes. Gracias.
Joshua
4

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.

Arte
fuente
La mejor implementación de C, con diferencia. ¿Por qué usar 5 variables, cuando puedes usar una matriz de 258048 ?
primo
4

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.

Hand-E-Food
fuente
La regla 1 dice que no se permiten dígitos, tienes un 0allí.
Kyle Kanos
Maldición, yo también. Ahí va mi cuenta de personaje.
Hand-E-Food
Puede usar -ea(+'')para reducir el tamaño ( ''convertido a un número 0, cuyo valor de enumeración es SilentlyContinue). Puede usar \Dpara la expresión regular de reemplazo que es lo mismo que [^\d]. Y solo puede usar en %{$_.Length}lugar de lo select Lengthque elimina los encabezados de columna. Y luego puedes deshacerte del -splity -replacetambién, dejándote con -join(gci \ -ea(+'')-r|%{$_.Length})37 caracteres más cortos (también reordené los parámetros porque los paréntesis son necesarios de todos modos debido a +'').
Joey
4

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.

Magenta
fuente
Puede aumentar su número cambiando f(m-g,g)a f(m-g,m).
Simply Beautiful Art
o f(m-g,i). Además, al final de la primera línea, usa un número. Creo que querías usar n+g, con lo que señalaré que será n+nmás grande.
Simply Beautiful Art
Puede guardar algunos bytes cambiando len ('"') por True
Brian Minton
Y use ord ('^?') (Donde ^? Es el carácter DEL, ASCII 127) para un número mayor. EDITAR no importa, eso no es "Imprimible".
Brian Minton
@BrianMinton ¿Quién dice que tiene que ser imprimible?
Simply Beautiful Art
4

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

serakfalcon
fuente
3

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.

Cel Skeggs
fuente
Calculé su resultado, no dude en estar en desacuerdo.
dejó de girar en sentido contrario a las agujas del reloj el
Tengo que estar en desacuerdo con ese resultado. Un momento mientras escribo mi razonamiento.
Cel Skeggs
Aquí vamos. Como dije en la actualización, su estimación parece ser significativamente menor que el valor real.
Cel Skeggs
Es justo, pero de todos modos necesitamos una estimación recursiva-inductiva / a la vez, no solo un solo paso, para incluir esta respuesta en la lista de puntuación. Estoy seguro de que su puntaje es mejor que el recursivo , pero también bastante seguro de que no es mejor que el de Ilmari Karonen (que de todos modos es muy extensible, usando solo 18 caracteres en este momento), así que creo que mi estimación es lo suficientemente buena para el Propósito de puntuación.
dejó de girar en sentido contrario a las agujas del reloj el
Estoy de acuerdo. Veré si puedo trabajar más en ello y al menos llegar a un límite inferior más preciso para el resultado.
Cel Skeggs
3

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.

ybeltukov
fuente
Si no tiene suerte, su programa se detiene después de una iteración y la llamada para rand() como condición de terminación lo hace no determinista. Además, llamar rand()en cada iteración debería hacerlo terriblemente lento. Use algo como LONG_MAXdefinido en su limits.hlugar.
klingt.net
Ok non deterministic, retrocedo, porque no hay semilla como la que escribiste.
klingt.net
1
¿Qué tal en ~' 'lugar de rand(), impreso con %u? Dos bytes menos de origen y un valor más alto.
MSalters