Algunos de ustedes pueden estar familiarizados con el BigNum Bakeoff , que terminó de manera bastante interesante. El objetivo puede resumirse más o menos como escribir un programa en C cuya producción sería la más grande, bajo algunas restricciones y condiciones teóricas, por ejemplo, una computadora que podría ejecutar el programa.
En el mismo espíritu, estoy planteando un desafío similar abierto a todos los idiomas. Las condiciones son:
Máximo 512 bytes .
El resultado final debe imprimirse en STDOUT. Este es tu puntaje. Si se imprimen varios enteros, se concatenarán.
La salida debe ser un número entero. (Nota: Infinity no es un número entero ).
No hay constantes incorporadas mayores de 10, pero los números / dígitos están bien (por ejemplo, la constante de Avogadro (como una constante incorporada) no es válida, pero 10000 no lo es).
El programa debe finalizar cuando se proporcionan recursos suficientes para ejecutarse.
La salida impresa debe ser determinista cuando se proporcionan recursos suficientes para ejecutarse.
Se le proporcionan enteros o bigints suficientemente grandes para que su programa se ejecute. Por ejemplo, si su programa requiere la aplicación de operaciones básicas a números menores de 10 1,000,000 , entonces puede suponer que la computadora que ejecuta esto puede manejar números de al menos hasta 10 1,000,000 . (Nota: Su programa también puede ejecutarse en una computadora que maneja números de hasta 10 2,000,000 , por lo que simplemente llamar al número entero máximo que la computadora puede manejar no dará resultados deterministas).
Se le proporciona suficiente potencia informática para que su programa termine de ejecutarse en menos de 5 segundos. (Por lo tanto, no se preocupe si su programa ha estado ejecutándose durante una hora en su computadora y no va a terminar pronto).
Sin recursos externos, así que no piense en importar esa función de Ackermann a menos que sea una función integrada.
Todos los artículos mágicos están siendo prestados temporalmente de una deidad generosa.
Extremadamente grande con límite desconocido.
- Steven H , Pyth f 3 + B³F + ω² (256 26 )
donde B³F es el ordinal Iglesia-Kleene con la secuencia fundamental de
B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F
Tabla de clasificación:
Simply Beautiful Art , Ruby f ψ 0 (X (Ω M + X (Ω M + 1 Ω M + 1 ) )) + 29 (9 9 9 )
Steven H , Pyth f ψ (Ω Ω ) + ω² + 183 (256 27! )
Leaky Nun , Python 3 f ε 0 (9 9 9 )
fejfo , Python 3 f ω ω 6 (f ω ω 5 (9e999))
Steven H , Python 3 f ω ω + ω² (9 9 9 99 )
Simply Beautiful Art , Ruby f ω + 35 (9 9 99 )
i .. , Python 2 , f 3 (f 3 (141))
Algunas notas al margen:
Si no podemos verificar su puntaje, no podemos ponerlo en la tabla de clasificación. Por lo tanto, puede esperar explicar un poco su programa.
Del mismo modo, si no comprende qué tan grande es su número, explique su programa e intentaremos resolverlo.
Si utiliza un tipo de programa de número de Loader , lo ubicaré en una categoría separada llamada "Extremadamente grande con límite desconocido" , ya que el número de Loader no tiene un límite superior no trivial en términos de la jerarquía de rápido crecimiento para ' secuencias fundamentales estándar.
Los números se clasificarán a través de la jerarquía de rápido crecimiento .
Para aquellos que deseen aprender cómo usar la jerarquía de rápido crecimiento para aproximar números realmente grandes, estoy alojando un servidor Discord solo para eso. También hay una sala de chat: Ordinality .
Desafíos similares:
Golf un número más grande que el ÁRBOL (3)
Programa de finalización más corto cuyo tamaño de salida excede el número de Graham
Para aquellos que desean ver algunos programas simples que generan la jerarquía de rápido crecimiento para valores pequeños, aquí están:
Ruby: jerarquía de rápido crecimiento
#f_0:
f=->n{n+=1}
#f_1:
f=->n{n.times{n+=1};n}
#f_2:
f=->n{n.times{n.times{n+=1}};n}
#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}
#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}
#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}
#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}
#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}
#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}
etc.
Para ir de f_x
a f_(x+1)
, agregamos un bucle de n.times{...}
.
De lo contrario, estamos diagonalizando contra todos los anteriores, por ejemplo
f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)
f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)
etc.
fuente