Su objetivo es imprimir (a la salida estándar) el mayor número posible, utilizando solo diez caracteres de código.

• Puede usar cualquier característica de su idioma, excepto las funciones de exponenciación incorporadas.
  • Del mismo modo, no puede usar la notación científica para ingresar un número. (Por lo tanto, no 9e+99.)
• El programa debe imprimir el número sin ninguna entrada del usuario. Del mismo modo, no se puede leer desde otros archivos, ni desde la Web, etc.
• Su programa debe calcular un solo número e imprimirlo. No puede imprimir una cadena, ni puede imprimir el mismo dígito miles de veces.
• Puede excluir del límite de 10 caracteres cualquier código necesario para imprimir cualquier cosa. Por ejemplo, en Python 2, que usa la print xsintaxis, puede usar hasta 16 caracteres para su programa.
• El programa realmente debe tener éxito en la salida. Si tarda más de una hora en ejecutarse en la computadora más rápida del mundo, no es válido.
• La salida puede estar en cualquier formato (para que pueda imprimir 999, 5e+100etc.)
• El infinito es un concepto abstracto , no un número. Entonces no es una salida válida.

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =

La salida está en notación de flecha.

Perl,> 1.96835797883262e + 18

time*time

Puede que no sea la respuesta más grande ... ¡hoy! ¡Pero espera suficientes milenios y lo será!

Para abordar algunos de los comentarios, por "milenios suficientes", de hecho me refiero a ^cientos de años.

Para ser justos, si la gran muerte por congelación / calor del universo es cómo terminará el universo (se estima que ocurrirá ~ 10 ¹⁰⁰ años), el valor "final" sería ~ 10 ²¹⁴ , que ciertamente es mucho menor que algunos de los otras respuestas (sin embargo, "las fluctuaciones cuánticas aleatorias o la tunelización cuántica pueden producir otro Big Bang en 10 ^{10 56} años"). Si adoptamos un enfoque más optimista (p. Ej., Un modelo cíclico o multiverso), entonces el tiempo continuará infinitamente y, por lo tanto, algún día en algún universo, en alguna arquitectura de bits altos, la respuesta excedería a algunos de los otros.

Por otro lado, como se señaló, de timehecho está limitado por el tamaño de entero / largo, por lo que en realidad algo así ~0siempre produciría un número mayor que time(es decir, el máximo timeadmitido por la arquitectura).

Esta no fue la respuesta más seria, ¡pero espero que la hayan disfrutado!

Wolfram ≅ 2.003529930 × 10 ¹⁹⁷²⁸

Sí, es un idioma! Conduce el back-end del popular sitio Wolfram Alpha. Es el único idioma que encontré donde la función Ackermann está incorporada y abreviada a menos de 6 caracteres.

En ocho personajes:

$ ack(4,2)

200352993...719156733

O ≅ 2.003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)etc. son mucho más grandes, pero demasiado grandes. ack(4,2)es probablemente el mayor número de Ackermann que se puede calcular completamente en menos de una hora.

Los números más grandes se representan en forma simbólica, por ejemplo:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

Las reglas dicen que se permite cualquier formato de salida, por lo que puede ser válido. Esto es mayor que 10 ^{10 19727} , que es mayor que cualquiera de las otras entradas aquí, excepto por el factorial repetido.

Sin embargo,

$ ack(9,9)

2↑⁷12 - 3

es mayor que el factorial repetido. El número más grande que puedo obtener en diez caracteres es:

$ ack(99,99)

2↑⁹⁷102 - 3

Esto es increíblemente enorme, el Universo no es lo suficientemente grande como para representar una parte significativa de sus dígitos, incluso si tomaste registros repetidos del número.

Python2 shell, 3,010,301 dígitos

9<<9999999

Cálculo de la longitud: Python agregará una "L" a estos números largos, por lo que informa 1 carácter más que el resultado tiene dígitos.

>>> len(repr( 9<<9999999 ))
3010302

Primeros y últimos 20 dígitos:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268,435,457

A28{_*}*K*

Esto calcula b , definido como sigue:

• a ₀ = 10

• a _n = a _{n - 1} ²

• b = 20 × a ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

Antecedentes

Esto sigue la misma idea que la respuesta de Claudiu , pero no se basa en ella. Tuve una idea similar que publiqué solo unos minutos después de que él publicara la suya , pero la descarté porque no se acercaba al límite de tiempo.

Sin embargo, la sugerencia de aditsu de actualizar a Java 8 y mi idea de usar potencias de 10 le permitió a CJam calcular números más allá del alcance de GolfScript, lo que parece deberse a algunos errores / limitaciones de Ruby's Bignum.

Cómo funciona

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

CJam, ≈ 8.1 × 10 ^1,826,751

KK,{)*_*}/

Toma menos de cinco minutos en mi máquina, por lo que todavía hay margen de mejora.

Esto calcula un ₂₀ , definido de la siguiente manera:

• a ₀ = 20

• a _n = (n × a _{n - 1} ) ²

Cómo funciona

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Python 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18,100,795,813

9 * 2 ^ (2 ^ 35)> 10 ^ 10,343,311,894

Editar: Mi nueva respuesta es:

9<<(7<<33)

Antigua respuesta, para la posteridad:

9<<(1<<35)

Diez personajes exactamente.

Estoy imprimiendo el número en hexadecimal, y

Puede excluir del límite de 10 caracteres cualquier código necesario para imprimir cualquier cosa. Por ejemplo, en Python 2, que usa la sintaxis print x, puede usar hasta 16 caracteres para su programa.

Por lo tanto, mi código actual es:

print(hex(9<<(7<<33)))

Prueba de que se ejecuta en el tiempo especificado y genera un número del tamaño especificado:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

Mi número> 10 ^ (15032385538 * log (16))> 10 ^ 18100795813

3 dígitos hexadecimales menos que la impresión wc anterior debido a la inicial 0x9.

Python 3 es necesario porque en python 2 7<<33sería largo y <<no toma mucho tiempo como entradas.

No puedo usar 9 << (1 << 36) en su lugar porque:

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

Por lo tanto, este es el mayor número posible del formulario a<<(b<<cd)imprimible en mi computadora.

Con toda probabilidad, la máquina más rápida del mundo tiene más memoria que yo, por lo que mi respuesta alternativa es:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1.7172038461 * 10 ^ 30)

Sin embargo, mi respuesta actual es la más grande que alguien haya enviado, por lo que probablemente sea lo suficientemente buena. Además, todo esto supone que el cambio de bits es permisible. Parece ser, de las otras respuestas que lo usan.

Cualquier idioma con nombres constantes lo suficientemente cortos, 18 dígitos aprox.

99/sin(PI)

¡Publicaría esto como una respuesta de PHP, pero lamentablemente M_PIhace que esto sea demasiado largo! Pero PHP produce 8.0839634798317E + 17 para esto. Básicamente, abusa de la falta de precisión absoluta en PI: p

Haskell

Sin ningún truco:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

Posiblemente sin calcular nada:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

Adaptando la respuesta de Niet :

main = print
    $99/sin pi -- 8.083963479831708e17

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Multiplica 99 Pebibytes por 9,000,000,000 Pebibytes.

J ( ((((((((9)!)!)!)!)!)!)!)!)

Si, eso es mucho. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))para no ser muy exacto

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 crea un vector de números del 0 al 169
• 1.6+ agrega uno a cada elemento del vector y convierte a reales (el rango es de 1.6 a 170.6)
• */ multiplica cada elemento de la matriz juntos

Si Kona admitiera la precisión cuádruple, podría hacerlo */9.+!999y obtener 1e2584. Lamentablemente, no lo hace y estoy limitado a doble precisión.

método antiguo

*/9.*9+!99

• !99 crea un vector de números del 0 al 98
• 9+ agrega 9 a cada elemento del vector (ahora varía de 9 a 107)
• 9.* multiplica cada elemento por 9.0 (convirtiendo implícitamente a reales, por lo que 81.0 a 963.0)
• */ multiplica cada elemento del vector juntos

HTML, 9999999999

9999999999

.. dado en el clavo.

Python - Varía, hasta 13916486568675240 (hasta ahora)

No del todo serio, pero pensé que sería divertido.

print id(len)*99

De todas las cosas que probé, me lenestaba dando consistentemente identificadores grandes.

Obtuve 13916486568675240 (17 dígitos) en mi computadora y 13842722750490216 (también 17 dígitos) en este sitio . Supongo que es posible que esto te dé tan bajo como 0, pero también podría ir más alto.

Golfscript, 1e + 33,554,432

10{.*}25*

Computa 10 ^ (2 ^ 25), sin usar exponentes, se ejecuta en 96 segundos:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

Puede calcular hasta 9 ^ (2 ^ 9999), si solo se le da suficiente tiempo, pero el incremento del exponente interno en uno hace que tome ~ el triple del tiempo, por lo que el límite de una hora se alcanzará muy pronto.

Explicacion :

Usando una versión anterior con la misma idea:

8{.*}25*

Desglosándolo:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

La pila al comienzo de cada bloque consta de un número, el número actual. Esto comienza como 8. Entonces:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

Entonces, la pila, paso a paso, se ve así:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... etc. Escrito en notación matemática, la progresión es:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

wxMaxima ~ 3x10 ^49,948 (o 10 ^{8,565,705,514} )

999*13511!

La salida es

269146071053904674084357808139[49888 digits]000000000000000000000000000000

No estoy seguro si se ajusta bastante a las especificaciones (particularmente el formato de salida uno), pero puedo golpear aún más grande:

bfloat(99999999!)

La salida es

9.9046265792229937372808210723818b8565705513

Eso es aproximadamente 10 ^{8,565,705,514,} que es significativamente más grande que la mayoría de las respuestas principales y se calculó en aproximadamente 2 segundos. La bfloatfunción da precisión arbitraria .

Haskell, 4950

Aww hombre, eso no es mucho! 10 caracteres comienzan después del signo de dólar.

main=putStr.show$sum[1..99]

Mathematica, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

Diez personajes exactamente.

Python shell, 649539 999890001

Supera a Haskell, no es realmente una respuesta seria.

99999*9999

Wolfram Alpha (¿un sitio web cuenta como idioma)?

9! ! ! ! !

salidas

10^(10^(10^(10^(10^(6.27...))))

Gracias a Cory por el consejo de que los espacios funcionan tan bien como los parens.

Befunge-93 (1,853,020,188,851,841)

Me alegro de que nadie haya hecho Befunge todavía (es mi nicho), pero maldita sea, no puedo encontrar ningún truco inteligente para aumentar el número.

9:*:*:*:*.

Entonces son 9 ^ 16.

:*

Básicamente multiplica el valor en la parte superior de la pila consigo mismo. Entonces, el valor en la parte superior de la pila va:

9
81
6561
43046721
1853020188851841

y

.

Emite el valor final. Me interesaría ver si alguien tiene mejores ideas.

Prefiero publicar esto como un comentario arriba, pero aparentemente no puedo ya que soy un novato.

Pitón:

9<<(2<<29)

Iría con un cambio de bit más grande, pero Python parece querer que el operando correcto de un cambio sea un número entero no largo. Creo que esto se acerca al máximo teórico:

9<<(7<<27)

El único problema con estos es que podrían no satisfacer la regla 5.

Matlab (1.7977e + 308)

Matlab almacena el valor del número de punto flotante más grande (precisión doble) en una variable llamada realmax. Invocarlo en la ventana de comando (o en la línea de comando) imprime su valor:

>> realmax

ans =

  1.7977e+308

Python, ca. 1.26e1388

9<<(9<<9L)

Da:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L37634036313038859977295626367160619139675145747597185726573351363864334560386886632464140309991451407124759291146012572595725491755156575770565902727276177784480073656350252773773773773763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590272727617778448007365635025277377377377

Al menos Python 3.5.0 (64 bits), más de 10 ^ 242944768872896860

print("{:x}".format( 9<<(7<<60) ))

En un mundo ideal, esto sería 9<<(1<<63)-1, pero no hay suficientes bytes para eso. Este número es tan grande que requiere casi 1 EiB de memoria para mantenerlo, que es un poco más de lo que tengo en mi computadora. Afortunadamente, solo necesita usar alrededor del 0.2% del espacio de almacenamiento del mundo como intercambio para mantenerlo. El valor en binario es 1001seguido por 8070450532247928832 ceros.

Si Python sale para máquinas de 128 bits, el máximo sería 9<<(9<<99), lo que requiere menos de 1 MiYiB de memoria. Esto es bueno, porque tendría suficiente espacio direccionable para almacenar el intérprete de Python y el sistema operativo.

Cubix , 9.670457478596419e + 147 (no competidor)

****"///**

No competir porque Cubix es más nuevo que este desafío. Puede probarlo en línea aquí , pero tenga en cuenta que en realidad no imprime el número; tendrá que pausar el programa después de *ejecutar los últimos dos segundos para ver el valor en la pila.

Cómo funciona

Cubix es un esolang bidimensional donde el código se envuelve alrededor de un cubo. Este código es exactamente equivalente al siguiente cubo de red, donde .es un no-op:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

Luego se ejecuta el código, con el puntero de instrucción (IP) comenzando en la esquina superior izquierda de la cara más a la izquierda, hacia la derecha. "activa el modo de cadena, donde todos los caracteres encontrados hasta el siguiente "empujan sus códigos de caracteres a la pila. La IP envuelve todo el código, empujando tres /s (47), dos *s (42) y dos .s (46) a la pila, antes de salir nuevamente del modo de cadena.

Aquí es donde se pone interesante. El primer espejo /refleja la IP, por lo que está hacia arriba; luego gira alrededor del cubo, golpeando estos caracteres:

           
    * *
  /     *      
  .     .      
    . .

Los tres *s multiplican los dos primeros elementos de la pila. Ahora, a diferencia de la mayoría de los lenguajes basados ​​en pila donde los operadores aritméticos hacen estallar sus argumentos, Cubix deja los valores anteriores en la pila. Eso significa que esto calcula 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

Cuando la IP llega de /nuevo, se gira a la derecha. Luego golpea el siguiente espejo y sigue este camino:

    *  
    *  
    /         .
    .         .
    .  
    .  

Los dos asteriscos multiplican los dos elementos superiores una vez más. Luego, el espejo dirige la IP nuevamente a la derecha, y el tercer espejo repite el proceso una vez más:

      *
      *
      /     .  
      .     .  
      .
      .

Finalmente, la IP deja la sección de espejo en dirección este. Los dos últimos asteriscos se multiplican dos veces más, dejando un resultado de 9.670457478596419e + 147 en la pila. Esto podría imprimirse O, pero no hay una manera fácil de hacerlo, ya que prácticamente todos los puntos en el cubo ya están en uso.

Scala, 2 ⁶³ -1

Pobre, pobre Scala. Toma al menos 8 caracteres para obtener un BigIntvalor, que no deja suficiente espacio para que sea grande.

Pero con solo 7 caracteres de código (contado), podemos imprimir el mayor positivo posible Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Si ignora el hecho de que la mayoría de los compiladores e intérpretes generan datos como equivalentes ascii (sea eficiente, es lo que es;))} , esto devolverá el valor máximo del tipo de datos del intérprete / compilador.

En algunos sistemas esto es solo 256, aunque en algunos (el mío, por ejemplo), este es el valor máximo de un entero de 32 bits, es decir, 2 147 483 647.

Editar:

-.

Imprimirá lo mismo en muchos menos caracteres

Perl, no compitiendo

Estoy usando esto para resaltar un pequeño rincón de perl.

Perl realmente no puede competir en este caso porque no tiene bignums incorporados (por supuesto, podría cargar una biblioteca de bignum).

Pero lo que todos saben no es del todo cierto. Una función central en realidad puede manejar grandes números.

El packformato wpuede convertir un número natural de cualquier tamaño entre base 10y base 128. Sin embargo, el entero base 128 se representa como bytes de cadena. La cadena de bits se xxxxxxxyyyyyyyzzzzzzzconvierte en bytes: 1xxxxxxx 1yyyyyyy 0zzzzzzz(cada byte comienza con 1 excepto el último). Y puede convertir dicha cadena a base 10 con descomprimir. Entonces puedes escribir código como:

unpack w,~A x 4**4 .A

lo que da:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Puede reemplazarlos 4**4por valores más grandes hasta que sienta que toma demasiado tiempo o usa demasiada memoria.

Desafortunadamente, esto es demasiado largo para el límite de este desafío, y puede argumentar que el resultado de base 10 se convierte en una cadena antes de convertirse en el resultado, por lo que la expresión realmente no produce un número. Pero internamente, Perl realmente hace la aritmética necesaria para convertir la entrada a la base 10, que siempre consideré bastante ordenada.

TI-36 (no 84, 36), 10 bytes, aprox. 9.999985426E99

Las calculadoras más antiguas también se pueden programar hasta cierto punto;)

69!58.4376

Esto está muy cerca del rango máximo que puede mostrar una calculadora TI:-1E100<x<1E100

Perl 6 , 456,574 dígitos

[*] 1..ↈ

No hay TIO porque tarda 2 minutos en ejecutarse.