Seu objetivo é imprimir (na saída padrão) o maior número possível, usando apenas dez caracteres de código.

• Você pode usar qualquer recurso do seu idioma, exceto as funções de exponenciação incorporadas.
  • Da mesma forma, você não pode usar notação científica para inserir um número. (Assim, não 9e+99.)
• O programa deve imprimir o número sem nenhuma entrada do usuário. Da mesma forma, nenhuma leitura de outros arquivos ou da Web e assim por diante.
• Seu programa deve calcular um único número e imprimi-lo. Você não pode imprimir uma sequência nem o mesmo dígito milhares de vezes.
• Você pode excluir do limite de 10 caracteres qualquer código necessário para imprimir qualquer coisa. Por exemplo, no Python 2, que usa a print xsintaxe, você pode usar até 16 caracteres para o seu programa.
• O programa deve realmente ter êxito na saída. Se demorar mais de uma hora para rodar no computador mais rápido do mundo, é inválido.
• A saída pode estar em qualquer formato (assim você pode imprimir 999, 5e+100etc.)
• O infinito é um conceito abstrato , não um número. Portanto, não é uma saída válida.

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =

A saída está na notação de seta.

Perl,> 1.96835797883262e + 18

time*time

Pode não ser a maior resposta ... hoje! Mas espere milênios o suficiente e será!

Para abordar alguns dos comentários, por "milênios suficientes", quero dizer, na verdade, ^centenas de anos.

Para ser justo, se a grande morte por congelamento / calor do universo é como o universo terminará (estimado em aproximadamente 10 ¹⁰⁰ anos), o valor "final" seria ~ 10 ²¹⁴ , o que certamente é muito menor do que alguns dos outras respostas (porém, "flutuações quânticas aleatórias ou tunelamento quântico podem produzir outro Big Bang em 10 ^{10 56} anos"). Se adotarmos uma abordagem mais otimista (por exemplo, um modelo cíclico ou multiverso), o tempo continuará infinitamente, e assim, algum dia em algum universo, em alguma arquitetura de alto nível, a resposta excederia algumas das outras.

Por outro lado, como apontado, timeé de fato limitado pelo tamanho de número inteiro / comprimento, portanto, na realidade, algo como ~0sempre produziria um número maior que time(isto é, o máximo timesuportado pela arquitetura).

Essa não foi a resposta mais séria, mas espero que vocês tenham gostado!

Wolfram ≅ 2,003529930 × 10 ¹⁹⁷²⁸

Sim, é uma linguagem! Ele dirige o back-end do popular site Wolfram Alpha. É o único idioma que encontrei onde a função Ackermann é incorporada e abreviada para menos de 6 caracteres.

Em oito caracteres:

$ ack(4,2)

200352993...719156733

Ou ≅ 2,003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)etc. são muito maiores, mas muito grandes. ack(4,2)é provavelmente o maior número de Ackermann que pode ser completamente calculado em menos de uma hora.

Números maiores são renderizados em forma simbólica, por exemplo:

$ ack(4,3)

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

As regras dizem que qualquer formato de saída é permitido, portanto, isso pode ser válido. Isso é maior que 10 ^{10 19727} , que é maior que qualquer uma das outras entradas aqui, exceto o fatorial repetido.

Contudo,

$ ack(9,9)

2↑⁷12 - 3

é maior que o fatorial repetido. O maior número que posso obter em dez caracteres é:

$ ack(99,99)

2↑⁹⁷102 - 3

Isso é incrivelmente grande, o Universo não é grande o suficiente para representar uma parte significativa de seus dígitos, mesmo se você fizer registros repetidos do número.

Shell Python2, 3.010.301 dígitos

9<<9999999

Calculando o comprimento: Python acrescentará um "L" a esses números longos, para que ele reporte 1 caractere a mais do que o resultado tenha dígitos.

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

Primeiro e último 20 dígitos:

40724177878623601356... ...96980669011241992192

CJam, 2 × 10 ^268.435.457

A28{_*}*K*

Isso calcula b , definido da seguinte maneira:

• 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

fundo

Isso segue a mesma ideia da resposta de Claudiu , mas não é baseada nela. Tive uma ideia semelhante que publiquei apenas alguns minutos depois que ele postou a dele , mas a descartei, pois ela não chegou nem perto do limite de tempo.

No entanto, a sugestão do aditsu de atualizar para o Java 8 e minha ideia de usar potências de 10 permitiram ao CJam calcular números além do alcance do GolfScript, o que parece ser devido a alguns bugs / limitações do Ruby Bignum.

Como 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,{)*_*}/

Leva menos de cinco minutos na minha máquina, então ainda há espaço para melhorias.

Isso calcula um ₂₀ , definido da seguinte maneira:

• a ₀ = 20

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

Como 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

Edit: Minha nova resposta é:

9<<(7<<33)

Resposta antiga, para a posteridade:

9<<(1<<35)

Dez caracteres exatamente.

Estou imprimindo o número em hexadecimal e

Você pode excluir do limite de 10 caracteres qualquer código necessário para imprimir qualquer coisa. Por exemplo, no Python 2, que usa a sintaxe print x, você pode usar até 16 caracteres para o seu programa.

Portanto, meu código real é:

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

Prova de que é executado no tempo especificado e gera um número do tamanho especificado:

time python bignum.py > bignumoutput.py

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

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

3 dígitos hexadecimais a menos do que a impressão em wc acima, devido à inicial 0x9.

O Python 3 é necessário porque no python 2 7<<33seria longo e <<não demoraria muito como entrada.

Não posso usar 9 << (1 << 36) porque:

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

Portanto, este é o maior número possível de formulários a<<(b<<cd)imprimíveis no meu computador.

Com toda a probabilidade, a máquina mais rápida do mundo tem mais memória do que eu, então minha resposta alternativa é:

9<<(9<<99)

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

No entanto, minha resposta atual é a maior que alguém já enviou, portanto provavelmente é boa o suficiente. Além disso, tudo isso pressupõe que a troca de bits seja permitida. Parece ser, das outras respostas que o utilizam.

Qualquer idioma com nomes constantes curtos o suficiente, 18 dígitos aprox.

99/sin(PI)

Eu postaria isso como uma resposta PHP, mas infelizmente M_PItorna isso um pouco longo demais! Mas o PHP produz 8.0839634798317E + 17 para isso. Basicamente, abusa da falta de precisão absoluta no PI: p

Haskell

Sem truques:

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

Indiscutivelmente sem calcular nada:

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

Adaptando a resposta 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)!)!)!)!)!)!)!)!)

Sim, isso é muito. 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))para não ser muito exato.

!!!!!!!!9x

K / Kona : 8.977649e261 1.774896e308

*/1.6+!170

• !170 cria um vetor de números de 0 a 169
• 1.6+ adiciona um a cada elemento do vetor e converte em reais (o intervalo é de 1,6 a 170,6)
• */ multiplica cada elemento da matriz juntos

Se a Kona suportasse a precisão quad, eu poderia fazer */9.+!999e dar a volta 1e2584. Infelizmente, isso não acontece e estou limitado à precisão dupla.

método antigo

*/9.*9+!99

• !99 cria um vetor de números de 0 a 98
• 9+ adiciona 9 a cada elemento do vetor (agora varia de 9 a 107)
• 9.* multiplica cada elemento por 9.0 (convertendo implicitamente em reais, então 81.0 a 963.0)
• */ multiplica cada elemento do vetor juntos

HTML, 9999999999

9999999999

.. acertou em cheio.

Python - Varia de até 13916486568675240 (até o momento)

Não é nada sério, mas achei que seria divertido.

print id(len)*99

Dentre todas as coisas que tentei, lenestava conseguindo me identificar de maneira mais consistente.

Rendi 13916486568675240 (17 dígitos) no meu computador e 13842722750490216 (também 17 dígitos) neste site . Suponho que seja possível que isso seja tão baixo quanto 0, mas também poderia ir mais alto.

Golfscript, 1e + 33.554.432

10{.*}25*

Computa 10 ^ (2 ^ 25), sem usar expoentes, é executado em 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

Ele pode calcular até 9 ^ (2 ^ 9999), se for dado tempo suficiente, mas incrementar o expoente interno em um faz com que ele triplique o tempo, de modo que o limite de uma hora será atingido em breve.

Explicação :

Usando uma versão anterior com a mesma ideia:

8{.*}25*

Dividindo:

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

A pilha no início de cada bloco consiste em um número, o número atual. Isso começa como 8. Então:

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

Portanto, a pilha, passo a passo, fica assim:

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

... etc. Escrito em notação matemática, a progressão é:

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 (ou 10 ^{8.565.705.514} )

999*13511!

Saída é

269146071053904674084357808139[49888 digits]000000000000000000000000000000

Não tenho certeza se ele se encaixa perfeitamente nas especificações (particularmente no formato de saída 1), mas posso atingir ainda mais:

bfloat(99999999!)

Saída é

9.9046265792229937372808210723818b8565705513

São aproximadamente ^{8.565.705.514,} que são significativamente maiores que a maioria das principais respostas e foram calculadas em cerca de 2 segundos. A bfloatfunção fornece precisão arbitrária .

Haskell, 4950

Aww cara, isso não é muito! 10 caracteres começam após o cifrão.

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

Qual é a raiz quadrada de 999 (2√ (32)) =?

$MaxNumber

Dez caracteres exatamente.

Shell Python, 649539 999890001

Bate Haskell, não é realmente uma resposta séria.

99999*9999

Wolfram Alpha (um site conta como idioma)?

9! ! ! ! !

saídas

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

graças a Cory pela dica de que os espaços funcionam tão bem quanto parens.

Befunge-93 (1.853.020.188.851.841)

Ainda bem que ninguém fez o Befunge ainda (é o meu nicho), mas caramba, não consigo encontrar nenhum truque inteligente para aumentar o número.

9:*:*:*:*.

Então é 9 ^ 16.

:*

Multiplica basicamente o valor no topo da pilha consigo mesmo. Portanto, o valor no topo da pilha é:

9
81
6561
43046721
1853020188851841

e

.

Emite o valor final. Eu estaria interessado em ver se alguém tem alguma idéia melhor.

Prefiro postar isso como um comentário acima, mas aparentemente não posso, já que sou um noob.

Pitão:

9<<(2<<29)

Eu usaria uma mudança de bits maior, mas o Python parece querer que o operando certo de uma mudança seja um número inteiro não longo. Eu acho que isso se aproxima do máximo teórico:

9<<(7<<27)

O único problema é que eles podem não atender à regra 5.

Matlab (1.7977e + 308)

O Matlab armazena o valor do maior número de ponto flutuante (precisão dupla) em uma variável chamada realmax. Invocá-lo na janela de comando (ou na linha de comando) imprime seu valor:

>> realmax

ans =

  1.7977e+308

Python, ca. 1.26e1388

9<<(9<<9L)

Dá:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056545043643045035035036037634036313038859977295626367160619139675145747597185726573351363864334560386886632464140309991451407124759291146012572595725491755156575770565450436430450350350360

Pelo menos Python 3.5.0 (64 bits), mais de 10 ^ 242944768872896860

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

Em um mundo ideal, isso seria 9<<(1<<63)-1, mas não há bytes suficientes para isso. Esse número é tão grande que requer quase 1 EiB de memória para mantê-lo, o que é um pouco mais do que eu tenho no meu computador. Felizmente, você só precisa usar cerca de 0,2% do espaço de armazenamento do mundo como swap para mantê-lo. O valor em binário é 1001seguido por 8070450532247928832 zeros.

Se o Python for lançado para máquinas de 128 bits, o máximo seria 9<<(9<<99), o que requer menos de 1 MiYiB de memória. Isso é bom, porque você teria espaço endereçável suficiente para armazenar o interpretador Python e o sistema operacional.

Cubix , 9.670457478596419e + 147 (não concorrente)

****"///**

Não competir porque o Cubix é mais novo que esse desafio. Você pode testá-lo online aqui , mas observe que ele não imprime o número; você precisará pausar o programa depois que os dois últimos *s forem executados para ver o valor na pilha.

Como funciona

Cubix é um esolang bidimensional em que o código é envolvido em um cubo. Esse código é exatamente equivalente à seguinte rede de cubos, onde .é um no-op:

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

Em seguida, o código é executado, com o ponteiro de instrução (IP) começando no canto superior esquerdo da face mais à esquerda, voltado para a direita. "ativa o modo de seqüência de caracteres, onde todos os caracteres encontrados até o próximo "enviam seus códigos de caracteres para a pilha. O IP envolve todo o código, empurrando três /s (47), dois *s (42) e dois .s (46) para a pilha, antes de sair do modo de string novamente.

Aqui é onde fica interessante. O primeiro espelho /reflete o IP, então ele está voltado para cima; ele gira em torno do cubo, atingindo os seguintes caracteres:

           
    * *
  /     *      
  .     .      
    . .

Os três *s multiplicam os dois principais itens da pilha. Agora, diferentemente da maioria das linguagens baseadas em pilha em que operadores aritméticos apresentam seus argumentos, o Cubix deixa os valores anteriores na pilha. Então isso significa que isso calcula 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976.

Quando o IP atinge /novamente, ele é virado para a direita. Em seguida, ele atinge o próximo espelho e segue este caminho:

    *  
    *  
    /         .
    .         .
    .  
    .  

Os dois asteriscos multiplicam os dois itens principais mais uma vez. Em seguida, o espelho direciona o IP novamente e o terceiro espelho repete o processo mais uma vez:

      *
      *
      /     .  
      .     .  
      .
      .

Por fim, o IP deixa a seção de espelho indo para o leste. Os dois asteriscos finais se multiplicam mais duas vezes, deixando um resultado de 9.670457478596419e + 147 na pilha. Isso pode ser impresso O, mas não há uma maneira fácil de fazer isso, pois praticamente todos os pontos do cubo já estão sendo usados.

Scala, 2 ⁶³ -1

Pobre, pobre Scala. São necessários pelo menos 8 caracteres para obter um BigIntvalor, o que não deixa espaço suficiente para torná-lo grande.

Mas com apenas 7 caracteres do código (contado), podemos imprimir o maior positivo possível Long:

print(-1L>>>1)

Brainf ** k 256 - 2147483647

>+[<+>+]<.

_{Se você ignorar o fato de que a maioria dos compiladores e intérpretes gera dados como equivalentes ascii (seja flexível, é o que é;))} , isso retornará o valor máximo do tipo de dados do interpretador / compilador.

Em alguns sistemas, isso é apenas 256, embora em alguns (o meu, por exemplo), esse seja o valor máximo de um número inteiro de 32 bits, ou seja, 2 147 483 647.

Editar:

-.

Imprimirá a mesma coisa em muito menos caracteres

Perl, não concorrente

Estou usando isso para destacar um pouco do canto do perl.

O Perl não pode competir com esse porque não possui bignums integrados (é claro que você pode carregar uma biblioteca de bignum).

Mas o que todo mundo sabe não é completamente verdade. Uma função principal, na verdade, pode lidar com grandes números.

O packformato wpode converter qualquer número natural de tamanho entre base 10e base 128. O número inteiro 128 base é, no entanto, representado como bytes da cadeia. A cadeia de bits passa xxxxxxxyyyyyyyzzzzzzza ser os bytes: 1xxxxxxx 1yyyyyyy 0zzzzzzz(cada byte começa com 1, exceto o último). E você pode converter essa string para a base 10 com a descompactação. Então você pode escrever código como:

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

que dá:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

Você pode substituir os 4**4valores maiores até sentir que demora muito ou usa muita memória.

Infelizmente, isso é muito longo para o limite desse desafio, e você pode argumentar que o resultado da base 10 é convertido em uma sequência antes de se tornar o resultado, para que a expressão não produza realmente um número. Mas internamente o perl realmente faz a aritmética necessária para converter a entrada na base 10, que eu sempre considerei bastante interessante.

TI-36 (não 84, 36), 10 bytes, aprox. 9.999985426E99

As calculadoras mais antigas também podem ser programadas;)

69!58.4376

Isso está muito próximo do intervalo máximo que uma calculadora de TI pode exibir:-1E100<x<1E100

Perl 6 , 456.574 dígitos

[*] 1..ↈ

Não há TIO porque leva 2 minutos para ser executado.