Seu objetivo é escrever um programa que imprima um número. Quanto maior o número, mais pontos você receberá. Mas tenha cuidado! O comprimento do código é limitado e pesa bastante na função de pontuação. Seu número impresso será dividido pelo cubo do número de bytes que você usou para sua solução .

Então, digamos que você tenha impresso 10000000e seu código tenha 100bytes. Sua pontuação final será 10000000 / 100^3 = 10.

Existem outras regras a serem seguidas, a fim de dificultar um pouco esse desafio.

• Você não pode usar dígitos no seu código (0123456789);
• Você pode usar matemático / físico / etc. constantes, mas apenas se forem menores que 10. (por exemplo, você pode usar Pi ~ = 3,14, mas não pode usar a constante Avogadro = 6e23)
• A recursão é permitida, mas o número gerado precisa ser finito (o infinito não é aceito como solução. Seu programa precisa terminar corretamente, assumindo tempo e memória ilimitados e gerar a saída solicitada);
• Você não pode usar as operações *(multiplicar), /(dividir), ^(poder) nem qualquer outra maneira de indicá-las (por exemplo, 2 div 2não é permitido);
• Seu programa pode gerar mais de um número, se você precisar fazer isso . Somente o mais alto contará para pontuação;
• No entanto, você pode concatenar seqüências de caracteres: isso significa que qualquer sequência de dígitos adjacentes será considerada como um único número;
• Seu código será executado como está. Isso significa que o usuário final não pode editar nenhuma linha de código, nem pode inserir um número ou qualquer outra coisa;
• O tamanho máximo do código é 100 bytes.

Entre os melhores

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Arte Simplesmente Bela , Ruby _φ 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 Simplesmente Bela , 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 ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Magenta , Python, ≈ ack (126,126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Kendall Frey , ECMAScript 6, ≈ 10 ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Ilmari Karonen , GolfScript, ≈ 10 ↑ ^três 10 ³⁷⁷ /18 de ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 ³
14. recursiva , Python, ≈ 2 ↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2 ↑↑ 7/100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. David guinada , C, ≈ 10 ^{10 4 × 10 22 de} / 83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. primo , Perl, ≈ 10 ^{(12750684161!) 5 x 2 27 de} / 100 ³ ≈ 10 ↑↑ 4,11369
18. Arte , C, ≈ 10 ^{10 2 x 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Robert Sørlie , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ ≈ 10 ↑↑ 3.71585
20. Tobia , APL, ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40616
21. Darren Stone , C, ≈ 10 ^{10 97.61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C, ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3,29749
23. Adam Speight , vb.net, ≈ 10 ^{5000 × (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3,28039
24. Joshua , festa, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_{Notas de rodapé}

1. ^{Se todos os elétrons do universo fossem um qubit e todas as suas superposições pudessem ser usadas de maneira proveitosa para armazenar informações (que, desde que você não precise saber o que está sendo armazenado, é teoricamente possível), esse programa requer mais memória do que poderia possivelmente existe e, portanto, não pode ser executado - agora ou em qualquer ponto concebível no futuro. Se o autor pretender imprimir um valor maior que ≈3 ↑↑ 3,28 de uma só vez, essa condição será aplicada.}
2. ^{Este programa requer mais memória do que existe atualmente, mas não tanto que não poderia teoricamente ser armazenado em um número escasso de qubits e, portanto, um computador pode existir um dia para executar esse programa.}
3. ^{Todos os intérpretes atualmente disponíveis emitem um erro de tempo de execução ou o programa falha ao executar como o autor pretendia.}
4. ^{A execução deste programa causará danos irreparáveis ​​ao seu sistema.}

Edit @primo : atualizei uma parte do placar usando uma notação esperançosamente mais fácil de comparar, com decimais para indicar a distância logarítmica até a próxima potência superior. Por exemplo 10 ↑↑ 2,5 = 10 ^{10 √10} . Também alterei algumas pontuações, se considero que a análise do usuário é defeituosa, sinta-se à vontade para contestar qualquer uma delas.

Explicação desta notação:

Se 0 ≤ b < 1então .a↑↑b = ab

Se b ≥ 1então .a↑↑b = aa↑↑(b-1)

Se b < 0então .a↑↑b = loga(a↑↑(b+1))

GolfScript; marcar pelo menos f _{ε_0 + ω + 1} (17) / 1000

Seguindo a sugestão de res de usar a resposta Lifetime de um worm para esta pergunta, apresento dois programas que melhoram bastante sua derivação da solução de Howard.

Eles compartilham um prefixo comum, modulo o nome da função:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

calcula g(g(1)) = g(5)onde g(x) = worm_lifetime(x, [x])cresce aproximadamente como f _{ε 0} (que res observa, é "a função na hierarquia de rápido crescimento que cresce aproximadamente na mesma taxa que a função Goodstein").

O ligeiramente mais fácil (!) De analisar é

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*mapeia xpara foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

assim dá g^(g(5)) ( g(5) ); os 8 níveis adicionais de iteração são semelhantes ao encadeamento de flechas. Para expressar em termos simples: se h_0 = ge h_{i+1} (x) = h_i^x (x)depois calculamos h_10 (g(5)).

Eu acho que este segundo programa quase certamente tem uma pontuação muito melhor. Desta vez, o rótulo atribuído à função gé uma nova linha (sic).

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

Desta vez, utilizo melhor ^como uma função diferente.

.['.{
}*'n/]*zip n*~

assume xa pilha e sai xseguido por uma sequência contendo xcópias de .{seguido por gseguido de xcópias de }*; em seguida, avalia a sequência. Já que eu tinha um lugar melhor para gravar personagens extras, começamos com j_0 = g; se j_{i+1} (x) = j_i^x (x)então a primeira avaliação do ^computa j_{g(5)} (g(5))(que eu tenho certeza que já supera o programa anterior). Eu então executo ^mais 16 vezes; então se k_0 = g(5)e k_{i+1} = j_{k_i} (k_i)então ele calcula k_17. Sou grato (novamente) a res por estimar que k_i>> f _{ε_0 + ω + 1} (i).

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

NOTA: NÃO EXECUTE ISTO!

Salve o seguinte em um arquivo em lotes e execute-o como Administrador.

CD|Format D:/FS:FAT/V/Q

Saída quando executado em uma unidade de 4 TB com o primeiro número impresso em negrito.

Insira um novo disco para a unidade D:
e pressione ENTER quando estiver pronto ... O tipo do sistema de arquivos é NTFS.
O novo sistema de arquivos é FAT.
QuickFormatting 3907172M
O volume é muito grande para o FAT16 / 12.

GolfScript, pontuação: forma demasiado

OK, qual o número que podemos imprimir em alguns caracteres do GolfScript?

Vamos começar com o seguinte código ( obrigado, Ben! ), Que imprime 126:

'~'(

Em seguida, vamos repeti-lo 126 vezes, fornecendo um número igual a cerca de 1,26126 × 10 ³⁷⁷ :

'~'(.`*

(Isso é repetição de string, não multiplicação, por isso deve estar de acordo com as regras.)

Agora, vamos repetir esse número de 378 dígitos um pouco mais de 10 ³⁷⁷ vezes:

'~'(.`*.~*

Você nunca verá esse programa terminar, pois ele tenta calcular um número com cerca de 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ dígitos. Nenhum computador já construído poderia armazenar um número tão grande, nem poderia ser construído usando a física conhecida; o número de átomos no universo observável é estimada em cerca de 10 ⁸⁰ , por isso mesmo se pudéssemos de alguma forma usar toda a matéria no universo para armazenar esse número enorme, teremos ainda de alguma forma tem que empinar cerca de 10 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰ dígitos em cada átomo!

Mas vamos supor que temos o intérprete GolfScript de Deus, capaz de executar esse cálculo, e que ainda não estamos satisfeitos. OK, vamos fazer isso de novo!

'~'(.`*.~*.~*

A saída deste programa, se pudesse ser concluída, teria cerca de 10 ^{10 383} dígitos e, portanto, seria aproximadamente 10 ^{10 10 383} .

Mas espere! Esse programa está ficando meio repetitivo ... por que não o transformamos em um loop?

'~'(.`*.{.~*}*

Aqui, o corpo do loop é executado cerca de 10 ³⁷⁷ vezes, dando-nos uma saída teórica que consiste em cerca de 10 10 ^{× 10 377} dígitos, onde a torre de potências iteradas de 10 tem cerca de 10 ³⁷⁷ passos. (Na verdade, isso é uma subestimação grosseira, já que estou negligenciando o fato de que o número repetido também aumenta mais a cada vez, mas, relativamente falando, esse é um problema menor.)

Mas ainda não terminamos. Vamos adicionar outro loop!

'~'(.`*.{.{.~*}*}*

Até escrever corretamente uma aproximação de tais números requer notação matemática esotérica. Por exemplo, em notação de seta para cima Knuth , o número (teoricamente) produzido pelo programa acima deve ser cerca de 10 ↑ ³ 10 ³⁷⁷ , mais ou menos algumas (ou 10 ³⁷⁷ ) potências de dez, assumindo que eu fiz as contas corretamente.

Números como esse vão muito além do "incrivelmente grande" e chegam ao reino do "inconcebível". Por exemplo, não só é impossível contar até ou escrever esses números (já ultrapassamos esse ponto no terceiro exemplo acima), mas eles literalmente não têm uso ou existência concebível fora da matemática abstrata. Podemos provar, a partir do axiomas da matemática , que tais números existem, assim como podemos provar a partir da especificação GolfScript que o programa acima os computaria, se os limites da realidade e do espaço de armazenamento disponível não interferissem), mas não há literalmente nada em o universo físico que poderíamos usá-los para contar ou medir em qualquer sentido.

Ainda assim, os matemáticos às vezes fazem uso de números ainda maiores . (Teoricamente), computar números tão grandes exige um pouco mais de trabalho - em vez de apenas aninhar mais loops um por um, precisamos usar a recursão para telescópio a profundidade dos loops aninhados. Ainda, em princípio, deveria ser possível escrever um programa GolfScript curto (bem abaixo de 100 bytes, eu esperaria) para (teoricamente) calcular qualquer número expressável em, digamos, notação de seta encadeada de Conway ; os detalhes são deixados como um exercício. ;-)

JavaScript 44 chars

Isso pode parecer um pouco barato:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Pontuação = 31415926535897932718281828459045/44 ^ 3 ≈ 3,688007904758867e + 26 ≈ 10 ↑↑ 2,1536134004

C, escore = 10 ^{10 97,61735} / 98 ³ ≈ 10 ↑↑ 2,29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

Agradeço a ajuda na pontuação. Quaisquer informações ou correções são apreciadas. Aqui está o meu método:

n = a concatenação de cada número de 1 a 2 ⁶⁴ -1, repetida (2 ⁶⁴ -1) ⁴ vezes . Primeiro, veja como estou estimando (baixo) o número acumulado de dígitos de 1 a 2 ⁶⁴ -1 (a "subsequência"): O número final na sequência de subsequência é 2 ⁶⁴ -1 = 18446744073709551615com 20 dígitos. Assim, mais de 90% dos números na subsequência (aqueles que começam com 1.. 9) têm 19 dígitos. Vamos assumir os 10% restantes em média de 10 dígitos. Será muito mais que isso, mas essa é uma estimativa baixa para matemática fácil e sem trapaça. Essa subsequência é repetida (2 ⁶⁴ -1) ⁴ vezes, então o comprimentode n terá .pelo menos (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3,86613 × 10 ⁹⁷ dígitos. Nos comentários abaixo, @primo confirma que o comprimento de n é 4,1433x10 ⁹⁷ . Então n em si será 10 para esse poder, ou 10 ^{10 97.61735}

eu = 98 caracteres de código

score = n / l ³ = 10 ^{10 97.61735} / 98 ³

Requisito: deve ser executado em um computador de 64 bits em que sizeof(long) == 8. Mac e Linux farão isso.

Python 3-99 caracteres - (provavelmente) significativamente maior que o número de Graham

Eu criei uma função que aumenta mais rapidamente com base em uma extensão da função 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 inspirou, mas você não precisa procurar lá para entender meu número.

Aqui está a versão modificada da função ackermann que usarei na minha análise:

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

Minha função Ano código acima tecnicamente não é a mesma, mas na verdade é mais forte, com a seguinte declaração para substituir a terceira linha da definição acima:

A(a,0,...)=A(a-1,a,...)

(a tem que ser pelo menos 1, então deve ser mais forte)

Mas, para meus propósitos, assumirei que é o mesmo que o mais simples, porque a análise já está parcialmente feita para a função de Ackermann e, portanto, para essa função quando ela possui dois argumentos.

Minha função é garantida para parar de recursar, porque sempre: remove um argumento, diminui o primeiro argumento ou mantém o mesmo primeiro argumento e diminui o segundo argumento.

Análise de tamanho

O número de Graham, AFAIK, pode ser representado como G(64)usando:

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Onde um ↑^(n) b é a notação de seta para cima de knuth.

Também:

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)

O número expresso no programa acima é A(0,1,2,3,4,...,123,124,125) .

Como g^64(4)é o número de Graham e, assumindo que minha matemática está correta, é menor que A(1,64,100), meu número é significativamente maior que o número de Graham.

Aponte quaisquer erros na minha matemática - embora, se não houver, esse deve ser o maior número calculado até o momento para responder a essa pergunta.

Perl - score ≈ 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Mais uma vez abusando do mecanismo de regex do perl para processar uma quantidade inimaginável de combinações, desta vez usando uma descida recursiva.

Na maior parte interna da expressão, temos uma clara . para impedir a recursão infinita e, assim, limitando os níveis de recursão ao comprimento da string.

O que vamos terminar é o seguinte:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... repetiu 671088640 vezes, para um total de 12750684161 aninhamentos - o que coloca completamente minha tentativa anterior de 23 envergonha aninhamentos. Notavelmente, o perl nem sequer se engasga com isso (mais uma vez, o uso da memória se mantém estável em cerca de 1,3 GB), embora demore um pouco até que a primeira declaração de impressão seja emitida.

Da minha análise anterior abaixo, pode-se concluir que o número de dígitos de saída será da ordem de (! 12750684161) ^671088640 , onde ! K é o fatorial esquerdo de k (consulte A003422 ). Podemos aproximar isso como (k-1)! , que é estritamente menor, mas na mesma ordem de magnitude.

E se perguntarmos wolframalpha :

... o que quase não altera minha pontuação. Eu tinha certeza de que seriam pelo menos 10 ↑↑ 5 . Eu acho que a diferença entre 10 ↑↑ 4 e 10 ↑↑ 4,1 é muito maior do que você imagina.

Perl - pontuação ≈ 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Abusar o mecanismo perl regex para fazer algumas combinações para nós. O código embutido
(??{print}) seu resultado diretamente no regex. Como $_é composto inteiramente de 2s (e o resultado de printé sempre 1), isso nunca pode corresponder e envia o perl girando por todas as combinações possíveis, das quais existem algumas.

Constantes usadas

• $^F- o identificador máximo de arquivos do sistema, normalmente 2.
• $] - o número da versão perl, semelhante a 5.016002 .

$_ é então uma string contendo o dígito 2 repetido 671088640 vezes. O uso da memória é constante em cerca de 1,3 GB, a saída começa imediatamente.

Análise

Vamos definir P _k (n) a ser o número de vezes que a declaração de impressão é executado, onde k é o número de assentamentos, e n é o comprimento da corda mais uma (só porque eu não me sinto como a escrita n + 1 em toda parte).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

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

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

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

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

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

etc. Em geral, a fórmula pode ser generalizada da seguinte maneira:

Onde

Ou seja, o fatorial esquerdo de k , ou seja, a soma de todos os fatoriais menores que k (consulte A003422 ).

Não consegui determinar os formulários fechados para D _k e E _k , mas isso não importa muito, se observarmos que

e

Com 23 ninhos, isso nos dá uma pontuação aproximada de:

Isso deve ser quase exato, na verdade.

Mas, para colocar isso em uma notação um pouco mais fácil de visualizar, podemos aproximar a base do expoente interno:

e então o expoente em si:

e depois pergunte a wolframalpha :

que você também pode chamar 10 ↑↑ 4 e terminar com isso.

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)

Com base na observação de que a iteração máxima fé o melhor caminho a percorrer, substituí as 13 chamadas fpor 3 níveis de chamada de loops aninhados f, zvezes cada (enquanto fcontinua aumentandoz ).

Estimei a pontuação analiticamente em um pedaço de papel - digitarei se alguém estiver interessado em vê-la.

Pontuação aprimorada: 10 ↑↑ 13

Javascript, com exatamente 100 caracteres, novamente:

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)

Isso melhora minha resposta original de três maneiras:

1. Definir zo escopo global nos impede de digitar a o.zcada vez.

2. É possível definir um getter no escopo global (janela) e digitar em fvez de o.f.

3. Ter mais iterações fvale mais do que começar com um número maior; portanto, em vez de (Math.E+'').replace('.','')(= 2718281828459045, 27 caracteres), é melhor usar ~~Math.E+''(= 2, 11 caracteres) e usar os caracteres recuperados para chamar fmuitas mais vezes.

Como, conforme analisado mais abaixo, cada iteração produz, a partir de um número na ordem de magnitude M , um número maior na ordem de magnitude 10 ^M , esse código produz após cada iteração

1. 210 ∼ O (10 ² )
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)

Pontuação: ∼10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

Javascript, com exatamente 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 um o.finvoca o loop while, para um total de 5 loops. Após apenas a primeira iteração, a pontuação já ultrapassou 10 ^{42381398144233621} . Na segunda iteração, o Mathematica não conseguiu calcular nem o número de dígitos no resultado.

Aqui está uma explicação passo a passo do código:

Iniciar

Comece com 2718281828459045 removendo o ponto decimal de Math.E.

Iteração 1

Concatene a sequência decrescente de números,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3
• 2
• 1
• 0 0

para formar um novo número (gigantesco),

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Quantos dígitos existem nesse número? Bem, é a concatenação 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

No Mathematica,

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

Em outras palavras, é 2,72⋅10 ^{42381398144233625} .

Fazendo minha pontuação, após apenas a primeira iteração, 2,72⋅10 ^{42381398144233619} .

Iteração 2

Mas isso é apenas o começo. Agora, repita os passos, começando com o número gigantesco ! Ou seja, concatenar a sequência decrescente de números,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3
• 2
• 1
• 0 0

Então, qual é a minha nova partitura, 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[]

Iteração 3

Repetir.

Iteração 4

Repetir.

Iteração 5

Repetir.

Pontuação analítica

Na primeira iteração, calculamos o número de dígitos na concatenação da sequência decrescente começando em 2718281828459045, contando o número de dígitos em

• 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

Essa soma pode ser representada pela fórmula,

em que Z indica o número de partida ( por exemplo 2718281828459045) e ó _Z indica a sua ordem de grandeza ( por exemplo, 15, visto que Z ~ 10 ¹⁵ ). Usando equivalências para somas finitas , o acima pode ser expresso explicitamente como

que, se tomarmos 9 × 10, reduz ainda mais a

e, finalmente, expandindo termos e ordenando-os por ordem decrescente de magnitude, obtemos

Agora, uma vez que estamos apenas interessados na ordem de grandeza do resultado, vamos substituir Z com "um número na ordem de grandeza de O _Z ", ou seja, 10 ^{O _Z} -

Finalmente, o segundo e o terceiro termos são cancelados e os dois últimos podem ser descartados (o tamanho é trivial), deixando-nos com

a partir do qual o primeiro mandato vence.

Reapresentado, fpega um número na ordem de magnitude de M e produz um número aproximadamente na ordem de magnitude de M (10 ^M ).

A primeira iteração pode ser facilmente verificada manualmente. 2718281828459045 é um número na ordem de magnitude 15 - portanto, fdeve produzir um número na ordem de magnitude 15 (10 ¹⁵ ) ∼ 10 ¹⁶ . De fato, o número produzido é, de antes, 2,72 ^× 10 ^{42381398144233625} — ou seja, 10 ^{42381398144233625 ×} 10 ^{10 16} .

Observando que M não é um fator significativo em M (10 ^M ), a ordem de magnitude do resultado de cada iteração segue um padrão simples de tetração:

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

Fontes 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}

APL, 10 ↑↑ 3,4

Aqui está minha tentativa revisada:

{⍞←⎕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 *, executando no hardware atual (usa uma quantidade desprezível de memória e variáveis ​​int regulares de 32 bits), embora demore muito tempo para concluir.

Você pode realmente executá-lo em um intérprete APL e ele começará a imprimir dígitos. Se for permitido concluir, ele terá impresso um número com 10 × 123456789 ⁴⁴ dígitos.

Portanto, a pontuação é 10 ^{10 × 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

Explicação

• ⎕D é uma cadeia constante predefinida igual a '0123456789'
• n←⍎⎕D define n como o número representado por essa sequência: 123456789 (que é <2 ³¹ e, portanto, pode ser usado como uma variável de controle de loop)
• {⍞←⎕D} imprimirá os 10 dígitos na saída padrão, sem uma nova linha
• {⍞←⎕D}⍣n vai fazer isso n vezes ( ⍣é o "operador de energia": não é *, /, nem ^, porque não é uma operação matemática, é uma espécie de loop)
• {⍞←n}⍣n⍣nrepetirá a operação anterior n vezes, imprimindo os 10 dígitos n ² vezes
• {⍞←n}⍣n⍣n⍣n vai fazer isso n ³ vezes
• Eu poderia caber 44 ⍣nlá, para que ele imprima n ⁴⁴ vezes a corda '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL pode ser escrito na sua própria (legado) de conjunto de caracteres de byte único que mapeia símbolos APL para os 128 valores de bytes superiores. Portanto, para fins de pontuação, um programa de N caracteres que usa apenas caracteres ASCII e símbolos APL pode ser considerado como N bytes.}

Haskell, pontuação: (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 tem exatamente 100 bytes de código Haskell puro. Ele imprimirá o quarto número de Ackermann, eventualmente consumindo toda a energia, matéria e tempo disponíveis do Universo e além no processo ( excedendo ligeiramente o limite de 5 segundos).

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (notação de seta para cima Knuth)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

Provavelmente, nenhum computador tem memória suficiente para executar isso com êxito, mas isso não é realmente culpa do programa. Com os requisitos mínimos do sistema atendidos, ele funciona.

Sim, isso está mudando um pouco os valores booleanos. Trueé coagido 1nesse contexto. Python possui números inteiros arbitrários.

GolfScript 3.673e + 374

'~'(.`*

Eu acho que o * é permitido, pois indica repetição de cordas, não multiplicação.

Explicação: '~'(deixará 126 (o valor ASCII de "~") na pilha. Em seguida, copie o número, converta-o em uma sequência e faça a repetição da sequência 126 vezes. Isso dá o 126126126126...que é aproximadamente 1.26 e+377. A solução tem 7 caracteres, então divida por 7^3, para uma pontuação de aproximadamente3.673e+374

Ruby, probabilisticamente infinito, 54 caracteres

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x é inicializado para 97. Em seguida, iteramos o seguinte procedimento: Gere x números aleatórios entre 0 e 1. Se todos forem iguais, encerre e imprima x. Caso contrário, dobre x e repita. Como os números aleatórios de Ruby têm 17 dígitos de precisão, as chances de terminar a qualquer passo são de 1 in (10e17) ^ x. A probabilidade de terminar em n etapas é, portanto, a soma de x = 1 en de (1 / 10e17) ^ (2 ^ n), que converge para 1 / 10e34. Isso significa que, para qualquer número, não importa quão grande, é extremamente improvável que este programa produza um número menor.

Agora, é claro, a questão filosófica é se um programa que tem menos de 1 em 10 ^ 34 chances de terminar no passo n para qualquer n pode terminar. Se assumirmos não apenas tempo e potência infinitos, mas que o programa tem a capacidade de executar em velocidade crescente a uma taxa que excede a taxa em que a probabilidade de término diminui, podemos, de fato, fazer a probabilidade de terminando por hora t arbitrariamente próximo de 1.

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126))))))))))

Isso é vergonhosamente adaptado de outra resposta de @Howard e incorpora sugestões de @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

Meu entendimento do GolfScript é limitado, mas acredito que os operadores *e ^acima não são os operadores aritméticos proibidos pelo OP.

(Vou excluí-lo com prazer se @Howard quiser enviar sua própria versão, que sem dúvida seria superior a esta).

Este programa calcula um número que é aproximadamente f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))) ))) - uma iteração nove vezes maior de f _{ε 0} - em que f _{ε 0} é a função na hierarquia de rápido crescimento que cresce aproximadamente na mesma taxa que a função Goodstein. (f _{ε 0}cresce tão rápido que as taxas de crescimento da função n (k) de Friedman e das setas encadeadas em Conway com dobra em k são praticamente insignificantes, mesmo em comparação com apenas um único f _{ε 0} não iterado .)

dc, 100 caracteres

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Com tempo e memória suficientes, isso calculará um número em torno de 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. Inicialmente, eu havia implementado a função de hiperoperação , mas ela exigia muitos caracteres para esse desafio, então removi as condições n = 2, b = 0e n >= 3, b = 0, transformando a n = 1, b = 0condição emn >= 1, b = 0 .

Os únicos operadores aritméticos usados ​​aqui são adição e subtração.

EDIT: como prometido nos comentários, aqui está um detalhamento do que esse código faz:

[            # 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 observado, isso se desvia da função de hiperoperação, pois os casos base para multiplicação e superiores são substituídos pelo caso base para adição. Esse código se comporta como sea*0 = a^0 = a↑0 = a↑↑0 ... = a , em vez do matematicamente correto a*0 = 0e a^0 = a↑0 = a↑↑0 ... = 1. Como resultado, calcula valores um pouco mais altos do que deveriam, mas isso não é grande coisa, pois estamos buscando números maiores. :)

Edição: Acabei de perceber que um dígito entrou no código por acidente, na macro que executa incrementos para n=0. Eu o removi substituindo-o por 'F' (15), que tem o efeito colateral de dimensionar cada operação de incremento em 15. Não tenho certeza de quanto isso afeta o resultado final, mas provavelmente é muito maior agora.

Não há mais limite de tempo de execução? OK então.

O programa precisa ser executável em computadores modernos?

Ambas as soluções usam uma compilação de 64 bits, ou longseja, um número inteiro de 64 bits.

C: superior a 10 ^{(2 64 -1) 2 64} , que é superior a 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 essas fórmulas, vou usar t = 2^64-1 = 18446744073709551615.

mainchamará fcom um parâmetro de t, que repetirá os ttempos, sempre que imprimir o valor te chamar fcom um parâmetro de t-1.

Total de dígitos impressos: 20 * t.

Cada uma dessas chamadas fcom um parâmetro de t-1iterará os ttempos, imprimindo o valor te chamando f com um parâmetro de t-2.

Total de dígitos impressos: 20 * (t + t*t)

Eu tentei este programa usando o equivalente a números inteiros de 3 bits (eu configurei i = 8e fiz a chamada principal f(7)). Ele atingiu a declaração de impressão 6725600 vezes. Isso funciona bem. 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7Portanto, acredito que esta é a contagem final para o programa completo:

Total de dígitos impressos: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Não sei como calcular (2 ⁶⁴ -1) ^{2 64} . Esse somatório é menor que (2 ⁶⁴ ) ^{2 64} , e eu preciso de uma potência de dois para fazer esse cálculo. Portanto, vou calcular (2 ⁶⁴ ) ^{2 64 -1} . É menor que o resultado real, mas como é um poder de dois, posso convertê-lo para um poder de 10 para comparação com outros resultados.

Alguém sabe como executar esse somatório ou como converter (2 ⁶⁴ -1) ^{2 64} para 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
divida esse expoente pela base de log 2 de 10 para alternar a base do expoente para potências de 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Mas lembre-se, esse é o número de dígitos impressos. O valor do número inteiro é 10 elevado a essa potência, então 10 ^ 10 ^ 355393490465494856447

Este programa terá uma profundidade de pilha de 2 ^ 64. São 2 ^ 72 bytes de memória apenas para armazenar os contadores de loop. São 4 bilhões de terabytes de contadores de loop. Sem mencionar as outras coisas que seriam colocadas na pilha por 2 ^ 64 níveis de recursão.

Editar: corrigiu um par de erros de digitação e usou um valor mais preciso para log2 (10).

Edit 2: Espere um segundo, eu tenho um loop que o printf está fora. Vamos consertar isso. Adicionado inicialização i.

Edit 3: Dang it, eu estraguei a matemática na edição anterior. Fixo.

Este será executado em computadores modernos, embora não termine tão cedo.

C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3,3329100567

#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 caracteres.

Isso imprimirá o inverso bit a bit de zero, 2 ^ 64-1, uma vez para cada iteração. 2 ^ 64-1 é um número de 20 dígitos.

Número de dígitos = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Arredondando o comprimento do programa para 100 caracteres, Pontuação = número impresso / 1.000.000

Pontuação = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R - 49 41 caracteres do código, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

irá imprimir [reproduzindo aqui apenas o começo]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 é G (1) onde G (64) é o 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)

Saída: 10 ^ 3 ↑↑↑↑ 3

Dicas:

Gé a função em que G (64) é o número de Graham. A entrada é um número inteiro. Saída é uma string unária escrita com 0. Removida por questões de brevidade.

Ké a função de seta para cima Knuth a ↑ ⁿ b onde a é implicitamente 3. A entrada é n, uma cadeia unária eb, uma cadeia unária. Saída é uma string unária.

u é "1".

v é "0000" ou G (0)

e é "000".

C

(Com desculpas 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

score ≈ 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

[Pontuação = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6)]

Note que eu mereço ser açoitado sem piedade por esta resposta, mas não pude resistir. Não recomendo agir como eu na stackexchange, por razões óbvias. :-P

EDIT: Seria ainda mais difícil resistir à tentação de usar algo como

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... mas suponho que uma regra pretendida, mas não especificada, fosse que toda a sequência de dígitos que compõe o número fosse impressa.

Novo Ruby: score ~ ​​f _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

onde f _α (n) é a hierarquia de rápido crescimento.

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

Experimente online!

O *nsão apenas cordas e multiplicação matriz, então eles devem estar bem.

Código não destruído:

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]}

onde b.-b<=>0retorna um número inteiro 1mais próximo do 0que b.

Explicação:

Imprime nno início de cada chamada de H.

H[[]]dobra n( nvezes), ie n = n<<n.

H[[0,a,b,c,...,z]]chamadas H[[a,b,c,...,z]](nhoras).

H[[k+1,a,b,c,...,z]]chamadas H[[k]*n+[a,b,c,...,z]]( nhorários), onde [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]chamadas H[[n]*n+[a,b,c,...,z]]( nhoras).

H[[-(k+1),a,b,c,...,z]]chamadas H[[-k]*n+[a,b,c,...,z]]( nhoras).

H[k] = H[[k]].

Meu programa inicializa n = 126e depois chama H[-n-1]126 ² 2 ¹²⁶ vezes.

Exemplos:

H[[0]]chamará o H[[]]que se aplica n = n<<n(n horas).

H[[0,0]]chamará H[[0]](n vezes).

H[[1]]chamará H[[0]*n](n vezes).

H[[-1]]chamará H[[n]*n](n vezes).

H[[-1,-1]]chamará H[[n]*n+[-1]](n vezes).

H[[-3]]chamará H[[-2]*n](n vezes).

Experimente online!

Veja as revisões para outras coisas legais.

Função Haskell - Ackermann aplicada ao seu resultado 20 vezes - 99 caracteres

Esta é a melhor solução haskell que eu posso criar com base na função ackermann - você pode notar algumas semelhanças com a solução nm, o i = round $ log pi foi inspirado a partir daí e o resto é coincidência: 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

Executa a função ackermann em si mesma 20 vezes, iniciando em uma, sendo a sequência

• 1
• 3
• 61,
• a (61,61),
• a (a (61,61), a (61,61)) --- chamaremos isso de ₂ (61) ou ₄ (1) ---
• a ₃ (61)
• ...
• um ₁₈ (61) ou um ₂₀ (1). Eu acho que isso é aproximadamente g ₁₈ (veja abaixo).

Quanto à estimativa, a Wikipedia diz:

a (m, n) = 2 ↑ ^m-2 (n + 3) - 3

A partir disso, podemos ver a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3, que é claramente maior que g1 = 3 ↑ ⁴ 3, a menos que os 3 no início sejam muito mais importantes do que eu penso. Depois disso, cada nível faz o seguinte (descartando as constantes insignificantes em um _n ):

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Se estes são aproximadamente equivalentes, então ₂₀ (1) ~ = g ₁₈ . O termo final em _n , (a _n-1 ) é muito maior que 3, portanto é potencialmente maior que g ₁₈ . Vou ver se consigo descobrir se isso aumentaria uma única iteração e reportaria de volta.

código de máquina x86 - 100 bytes (Montado como arquivo .com do MSDOS)

Nota: pode dobrar as regras um pouco

Este programa produzirá 2 ^{(65536 * 8 + 32)} noves, que colocariam a pontuação em (10 ^{2 524320} -1) / 1000000

Como contador, este programa usa a pilha inteira (64kiB) mais dois registradores de 16 bits

Código montado:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Montagem:

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'

C

O tamanho do arquivo é 45 bytes.

O programa é:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

E o número produzido é maior que 10 ^ (10 ^ (10 ^ 1.305451600608433)).

O arquivo para o qual eu redirecionei o std está atualmente com mais de 16 Gb e ainda está crescendo.

O programa terminaria em um período de tempo razoável se eu tivesse um computador melhor.

Minha pontuação é incontestável com ponto flutuante de precisão dupla.

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 em qualquer sistema razoável. SHLVL é um pequeno número inteiro positivo (geralmente 1 ou 2, dependendo de / bin / sh ser bash ou não).

Somente UNIX de 64 bits:

Pontuação: ~ 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'

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];);}

Criamos uma matriz de 258048 números inteiros não assinados. Não podia ser comprado sem assinatura, porque isso tornava o programa muito longo. Eles não estão assinados porque eu não quero usar comportamento indefinido, esse código é C adequado (exceto a falta de retorno de main ()) e será compilado e executado em qualquer máquina normal; ele continuará sendo executado por um longo tempo . Esse tamanho é o maior que podemos expressar legalmente sem usar caracteres não-ascii.

Fazemos um loop pela matriz a partir do último elemento. Imprimimos os dígitos de 2^32-1, incrementamos o elemento e eliminamos o loop se o elemento não tiver sido ajustado para 0. Dessa forma, repetiremos os (2^32 - 1)^254048 = 2^8257536tempos, imprimindo 10 dígitos de cada vez.

Aqui está um código de exemplo que mostra o princípio em um intervalo de dados mais 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");
        }
}

O resultado é aproximadamente 10 ^ 10 ^ 2485766 dividido por um milhão, que ainda é aproximadamente 10 ^ 10 ^ 2485766.

Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10 ↑↑ 1.701853371)

Isso leva muito mais que 5 segundos para ser executado.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Ele recupera e concatena o comprimento de bytes de cada arquivo em sua unidade atual. Regex remove quaisquer caracteres que não sejam dígitos.

Python 3, score = 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))

A função f é a função ackermann, que eu tenho apenas espaço suficiente para chamar.

Edit: anteriormente "else n + 1", que violava as regras do desafio - parabéns a Simply Beautiful Art.

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)

gera 2.718e + 239622337 ≈ 10 ↑↑ 2.9232195202

Para pontuação de pouco mais de 2.718e + 239622331 ≈ 10 ↑↑ 2.9232195197

que é o maior que posso fazer sem o navegador travar.

(console.log (a) mostrará a saída completa)

Não execute estes:

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)

produziria 2.718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (também conhecido como 2.718 * 10 ^ (1.213 * 10 ^ 12) para comparar com a resposta mais longa:

versão mais extrema, se não travar o seu 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 criaria um número com o mesmo tamanho de e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

Edit: solução original de código atualizado gerada apenas 2.718e + 464

Caracteres do Python 3: 98, ≈ 10 ↑↑ 256

Usando uma função de argumento variável:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

Efetivamente, E decrementa o primeiro argumento enquanto aumenta o restante dos argumentos, exceto que, em vez de colocar -1 nos argumentos, elimina o argumento. Como todo ciclo diminui o primeiro argumento ou diminui o número de argumentos, isso é garantido para terminar. A função crescente usada é int ("% d% d"% (k, k)), que fornece um resultado entre k ** 2 + 2 * k e 10 * k ** 2 + k. Meu código usa o símbolo * - mas não como multiplicação. É usado para trabalhar com números variáveis ​​de argumentos, que eu acho que devem seguir as regras, já que o ponto claro das regras era restringir operações específicas, não os próprios símbolos.

Alguns exemplos de quão grande E fica rapidamente:

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)

Apenas os dois primeiros são executáveis ​​no meu computador em um período de tempo razoável.

Então, E é invocado por E(*range(ord('~')))- o que significa:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

Não tenho muita certeza de quão grande é (tenho tentado aproximar-se sem sucesso) - mas é óbvio que é realmente grande.

Como exemplo, em cerca de doze ciclos, o resultado é: (tecnicamente um pouco mais 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)

Estimativa do resultado:

Se aproximarmos o passo crescente lambda k: 10 * k**2, a função pode ser descrita 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₁²ⁿ), ... )

O importante que estamos fazendo aqui é construir uma torre de potências de dez, para que a pontuação final possa ser aproximada em 10 ↑↑ 256.

Melhor (embora parcial) estimativa de resultado:

Isso usa o mesmo 10 * k**2que a outra estimativa.

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

Sob a estimativa anterior, seria:

E(a, b) = 10**(a**2/a) * b**(2*a)

Qual é significativamente menor que o valor real, pois usa em a**2vez de 2**apara 10 e usa em a*2vez de 2**apara b.

C (pontuação ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3,005558275)

• ~ 20 GB de saída
• 41 caracteres (41 ^ 3 significa nada)

main(){for(;rand();printf("%d",rand()));}

Apesar do rand()resultado ser determinístico, porque não há função de semente.