Maior número em dez bytes de código


77

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.


21
O que você quer dizer exatamente com "calcular". Além disso, If it takes longer than an hour to run on any computer in the world, it's invalid.não é objetivo. Eu poderia (teoricamente) fabricação de um computador que leva uma hora de mudar T-estado
user80551

4
O deslocamento de bits conta como um operador de exponenciação, pois é equivalente a * 2^x?
Claudiu 13/06

14
O fato de que o limite de tempo depende do desempenho do computador mais rápido do mundo faz com que seja impossível para nós para determinar o conjunto de respostas válidas ... Eu realmente não gosto que
David Z

6
Funções de exponenciação não são permitidas, mas a função ackermann é permitida? Isso parece realmente arbitrário. Ainda não está claro por que uma manipulação simbólica é considerada "calculando" o número.
WolframH

Respostas:


26

Wolfram Language

ack(9!,9!)

ack (9!, 9!) =insira a descrição da imagem aqui

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


3
@KyleKanos É diferente porque o código / programa não está acessando a web. Outros exemplos typescriptlang.org/Playground tryfsharp.org/Learn/getting-started
Adam Speight

35
O Wolfram Language está disponível para usar um Raspberry Pi e não requer acesso à web. Portanto, não viola essa regra.
Adam Speight

6
Eu acho que é uma resposta muito válida. Raciocínio estúpido por estar na ilha e não ter acesso à internet. O requisito 'No web' é apenas para impedir a impressão de um recurso já disponível. Todas as respostas são válidas desde que 'executem' um pedaço de código para calcular a saída. Está chegando o Visual Studio mais recente que executa seu código na nuvem do Azure, então você deseja restringir o C #? Ou você não está qualificado se tiver o chromebook?
microbiana

26
ack(99!,9)é muito, muito maior.
jimmy23013

11
Uma das outras respostas diz que ack (4,2) é o maior que ele pode calcular em uma hora assim que eu ficaria surpreso se isso fez ...
Jerry Jeremias

120

Perl,> 1.96835797883262e + 18

time*time

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


Editar:

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 100 anos), o valor "final" seria ~ 10 214 , 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!


23
Upvoted porque eu gosto da eventualidade
Tim

5
Não vai dar timevoltas e retornar um número pequeno em algum momento? Depende se é perl de 32 bits ou 64 bits, eu acho
Claudiu

3
1000 anos ~ 3e10 segundos, assim você ainda estará pairando em torno de 1e21 como sua saída. Talvez se você esperasse 1e50 anos, poderia começar a competir contra as outras respostas?
Kyle Kanos

8
Você pronuncia este "time times time"? :-) (oi Timwi!)
Pierre Arlaud

1
O tempo no calor mortal do universo é responsável pelo horário de verão? Você pode ganhar mais alguns segundos de existência.
Alpha

65

Wolfram ≅ 2,003529930 × 10 19728

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 19728

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.


85
Nada mal, mas não é páreo para a minha ack(4,2)+1solução.
user19057

13
ack (4,2) +2, EU GANHO

1
Eu acho que você ganhou.
Anonymous Pi

20
@Kyle, Yimin Há muitas declarações enganosas neste post e os comentários nele contidos. Esta não é a Wolfram Language, e não é usada como back-end do W | A. É simplesmente uma entrada em "linguagem natural" para o Wolfram | Alpha. No idioma Wolfram, a ack(4,2)entrada é inválida. A entrada de linguagem natural da W | A não deve nem contar como uma linguagem de programação. Não é Turing completo, e você não pode escrever nem mesmo programas básicos, como o algoritmo de Euclides. Por esse motivo, não acho que seja uma resposta válida, assim como uma consulta do Google seria.
precisa

4
A Wolfram Language é a linguagem de programação usada no Mathematica, documentada aqui . O Wolfram | Alpha usa a linguagem natural como entrada, não a Wolfram Language.
precisa

30

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

2
Droga! Este mostrou-se enquanto eu estava escrevendo a mesma resposta
James_pic

2
Isso é realmente justo 9 * 2**9999999, então alguém poderia argumentar que usa exponenciação.
Dennis

2
Aguarde, ***built-in*** exponentiation functionsnão são permitidos, portanto, isso pode se enquadrar nas regras. 1
user80551

1
Maneira matemática de calcular o comprimento:floor(log10(9 * 2**9999999))+1
Justin

8
9 << (9 << 99) é muito maior, se terminar.
Keith Randall

29

CJam, 2 × 10 268.435.457

A28{_*}*K*

Isso calcula b , definido da seguinte maneira:

  • a 0 = 10

  • a n = a n - 1 2

  • b = 20 × a 28

$ 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 20 , definido da seguinte maneira:

  • a 0 = 20

  • a n = (n × a n - 1 ) 2

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.                               ";
}/

21
Haha, esse é o Kirby? :)
aditsu

Você poderia descrever o que isso está fazendo?
Kyle Kanos

2
Para sua informação, fiz alguns testes para verificar o desempenho do BigInteger - calculei 100000! e convertido em string. Resultados: java 6: 21 seg cálculo, 44 ​​seg toString; java 7: 14 seg de cálculo, 42 seg toString; java 8: 5 seg de cálculo, 1 seg toString!
Aditsu

1
@aditsu: A atualização do Java reduziu o tempo de execução de 5 minutos para 2 segundos!
Dennis

20

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.


Até agora, essa parece ser a maior resposta de longe. Afinal, é um número de 10.000.000.000 de dígitos.
N15:

1
@nneonneo: Eu acredito que a minha solução é maior :)
Zaid

A sua resposta alternativa requer juuuuust menos de 1 MiYiB de memória e requer 100 bits de memória endereçável (por isso não irá funcionar até pelo menos 128 bits Python). (Fonte: minha resposta semelhante )
wizzwizz4

19

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


1
Você não pode se bronzear (PI / 2)?
user80551

1
@ user80551 Poderia fazer, mas acabei de perceber que poderia usar o último caractere restante no limite para aumentar meu resultado em 99 vezes.
Niet the Dark Absol

Muito tempo no Common Lisp: (/ 99(sin pi))(14 caracteres). Erro na TI-83: 99/sin(π(8 caracteres) causa divisão por zero. Obras em LibreOffice Calc : =99/SIN(PI((10 caracteres, sem contar =) calcula 808423047055000000. LibreOffice auto-implantes a última duas ))em =99/SIN(PI()).
kernigh

Depende da precisão do idioma. No PHP 14 dígitos decimais é um valor comum.
kenorb

@ kernigh Não importa nesse caso, mas seria 99/sin(πcinco bytes ou oito? Eu sei que o TI-BASIC armazena vários comandos como bytes únicos; é sin(um deles?
wchargin

16

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

Terceiro bala diz "O programa deve calcular ..."
user80551

8
floor(infinity)é um número finito? Que diabos Haskell?
N15:

3
1/0! = Infinito, é indefinido.
precisa

1
Você tem certeza disso, @ ckuhn203? Tanto no GHC 7.6.3 quanto no 7.8.2, recebo isInfinite $ 1 / 0 -- True. Até onde eu sei, o IEEE 754 define 1 / 0 como infinito.
Taylor Fausak

2
Oh, você quer dizer matematicamente. Eu concordo completamente. Mas no que diz respeito à programação com ponto flutuante IEEE (e Haskell em particular) 1 / 0 == Infinity,.
Taylor Fausak

15

Powershell - 1.12947668480335E + 42

99PB*9E9PB

Multiplica 99 Pebibytes por 9.000.000.000 Pebibytes.


7
98901 petabytes quadrados? Esse é algum tipo de método para medir a densidade de bits da superfície de discos rígidos (alta capacidade futura)?
user80551

Ah legal. Não sabia que pebibytes eram possíveis agora. Eu sempre pensei que ele parou em tebibytes.
Joey

@ Joey Agora, se a MS se apressasse e adicionasse yobibytes, a resposta poderia ser ainda melhor.
Rynant

1
Eu poderia acrescentar que a Pash se isso ajuda ... ;-)
Joey

1+ "1" * 309 produz 1.1111e308, embora eu suponha que isso quebre o espírito, se não a palavra da regra na impressão de caracteres. É convertido em um dobro para a saída.
tomkandy

14

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

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

!!!!!!!!9x

5
Eu encontrei um compilador , mas depois de 20 minutos, !!9xnão imprimia nada na tela. Eu sinceramente duvido que !!!!!!!!9xvai sempre ser calculado.
Kyle Kanos

16
"Se demorar mais de uma hora para rodar no computador mais rápido do mundo, é inválido." Não tenho certeza isso seria válido, pois ele não é executado dentro de uma hora
Claudiu

11
Demorou 70 minutos, mas !!9xfinalmente foi impresso em tela. Estou impressionado que ele realmente calculado o valor, mas ainda não completamente bala 5.
Kyle Kanos

6
@ Quincunx: Provavelmente verdade, porém a condição para uma resposta válida é que o programa tenha êxito na saída; essa resposta falha completamente nesse critério. Infelizmente, os promotores negligenciaram todos os comentários apontando isso e ainda os votaram acima nas respostas do CJam & Golfscript que são incrivelmente grandes e calculam em tempo razoável.
Kyle Kanos

3
Votado porque não imprime a resposta.
Isaacg

14

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


11

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.


Ótima idéia, mas infelizmente não faz calculatenada.
user80551

3
Eu acredito que a *99parte invoca um cálculo.
comando

Ah, sim, eu me sinto idiota agora.
user80551

1
Se você usar algo mais curto - digamos , id(id)ou id(0j), você pode multiplicar por999
gnibbler

1
Dentre os nomes nomeados menores em docs.python.org/2/library/functions.html , o sistema varssempre fornece o valor mais alto (mas 4 caracteres) seguido por sum. Use print(sorted([(id(x),x)for x in[id,len,max,min,str,int,ord,chr,sum,map,abs,all,any,bin,bool,eval,oct,vars,iter,list,set,repr,round,zip,type,pow,dict,dir,hex]])[::-1])para verificar.
user80551

10

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)

Qual é o problema com os dois na frente do 2564 na sua saída?
Kyle Kanos

@KyleKanos: Essa não é minha saída, é a saída de wc. Vou editar para torná-lo mais claro
Claudiu

você poderia usar wc -cpara tornar a saída mais clara
daniero

Agradável! Eu tive a mesma idéia há alguns minutos atrás, mas ela corre muito mais devagar com o CJam (o que é surpreendente, pois é mais rápido que o GolfScript em geral).
Dennis

1
Pequena melhoria: 10{.*}25entrega 33.554.434 dígitos e termina em 90 segundos na minha máquina. Não sei por que, mas 10{.*}26*não imprime nada.
Dennis

7

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 .


6

Haskell, 4950

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

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

Por que não apenas print? Além disso, 9/0.000001é maior que sum[1..99].
Taylor Fausak

5
Nesse ritmo, podemos considerar 9 999 999 999 como um limite mais baixo para os resultados.
Keen

@TaylorFausak Esta resposta obviamente não deve ser levada a sério!
Flonk

6

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

$MaxNumber

Dez caracteres exatamente.


7
Está tecnicamente calculando alguma coisa, e está produzindo todos os dígitos e não apenas notação científica?

@Yimin: A saída pode estar em qualquer formato (assim você pode imprimir 999, 5e + 100, etc.)
edc65

O valor não é definido no tempo de compilação, mas depende da máquina específica na qual o comando é executado. Eu acho que conta.
Michael Stern

5

Shell Python, 649539 999890001

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

99999*9999

6
9999999999 é maior, não é?
MadTux

5
@ MadTux Há uma restrição ambígua à calculateresposta.
user80551

1
Se esta resposta estiver correta, a minha também 9**9**9**9estará correta, pois é um operador aritmético (não função interna).
kenorb

3
@kenorb É construído em exponenciação que não é permitida.
user80551

5

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.


Tenho certeza de que este é o maior número no tópico desde o meu post, mas Wolfram se engasga em compará-lo com outros números, mesmo ((99!)!)! > 4nunca retornando.
precisa

Isso vai contra a regra que diz que você não pode obtê-lo na Web.
Kyle Kanos

1
Muitos W | A's!
Anonymous Pi

5
Não concordo que isso viole as regras. Ele não "lê na web", o que é contra as regras; na verdade, "calcula um único número e imprime", que é o que deve ser feito. O fato de a única interface disponível ser um site não significa que ele não pode contar como uma linguagem de programação.
Gbgg

1
É uma resposta completamente válida.
microbiana

4

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.



4

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.


3

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

Como o OP pediu para retornar um valor calculado , você deve colocar realmax+1. Eu tentei por diversão e surpresa, ele retorna exatamente o mesmo número que você (então eu ri quando percebi ... eps(realmax)=1.99584030953472e+292).
Hoki

3

Python, ca. 1.26e1388

9<<(9<<9L)

Dá:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056545043643045035035036037634036313038859977295626367160619139675145747597185726573351363864334560386886632464140309991451407124759291146012572595725491755156575770565450436430450350350360


3

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.


"Apenas 0,2% do espaço de armazenamento do mundo"
Benjamin Urquhart

1
@BenjaminUrquhart Se você acha que é bom, por que não votar?
wizzwizz4 13/04

Há seu voto duplo;)
Benjamin Urquhart

3

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.


2

Scala, 2 63 -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)

2

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


Essa segunda resposta será impressa -1em intérpretes que usam valores assinados para a fita
Benjamin Urquhart

2

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.


2

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

insira a descrição da imagem aqui


2

Perl 6 , 456.574 dígitos

[*] 1..ↈ

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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.