Maior número imprimível

113

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

Vereos
fonte
16
Alguém já disse explicitamente "base 10"?
precisa saber é
1
O grande número conta se for digitado 12e10(12 * 10 ^ 10) como 12*10^10?
hichris123
4
Eu acho que uma restrição melhor em vez de proibir *, / e ^ seria permitir apenas operações lineares , por exemplo , +, -, ++, -, + =, - =, etc. Caso contrário, os codificadores podem tirar vantagem da seta para cima / biblioteca Ackermann de Knuth funciona se disponibilizada no idioma de sua escolha, o que parece trapaça.
Andrew Cheong
14
Eu ainda estou esperando para ver alguém ganhar nota de rodapé [4].
Brian Minton
1
Digamos, se meu programa for impresso 500b, isso é inválido? Ou seja, podemos ignorar todas as coisas não numéricas que um programa imprime? E se sim, algo como 50r7contaria 507?
Simply Beautiful Art

Respostas:

20

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

Peter Taylor
fonte
Se não me engano, o número que seu programa calcula (chame de n) pode ser escrito n = f ^ 9 (g (3)), onde f (x) = g ^ (4x) (x) eg ( x) é a vida útil do worm [x]. Se tratarmos g como sendo aproximadamente o mesmo que f_eps_0 na hierarquia de rápido crescimento, meus cálculos de "back-of-envelope" mostram que f_ (eps_0 + 2) (9) <n <f_ (eps_0 + 2) (10 ) Claro que é o atual vencedor - de longe.
res
@res, acho que está subestimando bastante. .{foo}*mapeia xpara foo^x (x). Se tomarmos h_0 (x) = g^4 (x)e, em h_{i+1} (x) = h_i^x (x)seguida, o valor calculado é h_9 (g(3)). O seu f(x) = g^(4x) (x) = h_0^x (x) = h_1 (x).
Peter Taylor
(Isso pertence ao seu programa original - acabei de ver que você fez algumas edições.) Ohhh ... eu entendi errado como isso *funciona. É seguro dizer que h_0 (x) = g ^ 4 (x) >> f_eps_0 (x); consequentemente, a relação h_ {i + 1} (x) = h_i ^ x (x) define efetivamente uma hierarquia de rápido crescimento "acelerada", de modo que h_i (x) >> f_ (eps_0 + i) (x). Ou seja, o número calculado h_9 (g (3)) é certamente muito maior que f_ (eps_0 + 9) (g (3)). Quanto a g (3), acho que posso mostrar que é maior que g_4, o quarto número na sequência g_i usado para definir o número de Graham (que é g_64).
res
@res, então j_i ~ f_{eps_0 + i}; isso faz k_i ~ f_{eps_0 + i omega + i^2}?
Peter Taylor
Dado o que você escreveu, eu entendi k_i ~ f_{ε_0 + ω}^i (k_0). Aqui está o raciocínio: k_ {i + 1} = j_ {k_i} (k_i) = j_ω (k_i) ~ f_ {ε_0 + ω} (k_i) ~ f_ {ε_0 + ω} ^ 2 (k_ {i-1}) ... ~ f_ {ε_0 + ω} ^ {i + 1} (k_0), então k_i ~ f_ {ε_0 + ω} ^ i (k_0). Um limite inferior muito conservador em k_i, inteiramente em termos da hierarquia de rápido crescimento, é então k_i >> f_{ε_0 + ω}^i (i) = f_{ε_0 + ω + 1} (i).
res
91

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.

Mão-E-Comida
fonte
19
Puro gênio não adulterado!
precisa saber é o seguinte
7
Eu acho que você deveria cubo o comprimento solução em que eu recebo cerca de 321 como pontuaçãoYour printed number will be divided for the number of bytes you used for your solution^3.
Cruncher
1
77 votações positivas, e ainda ... Notei que a pontuação é 321 ...
Simply Beautiful Art
3
@SimplyBeautifulArt, não é a pontuação, mas a jornada. :-D
Hand-E-Food
4
Aparentemente sim, uma que riu muito. Agora, se pudéssemos colocar isso na tabela de classificação ... alguém precisa ganhar a tag "dano irreparável";)
Simply Beautiful Art
87

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 377 :

'~'(.`*

(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 377 vezes:

'~'(.`*.~*

Você nunca verá esse programa terminar, pois ele tenta calcular um número com cerca de 10 380 ≈ 2 1140 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 80 , 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 380 /10 80 = 10 300 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 377 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 377 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 ↑ 3 10 377 , mais ou menos algumas (ou 10 377 ) 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. ;-)

Ilmari Karonen
fonte
9
"...No computer ever built could store a number that big...Corrija-me se estiver errado, mas acho que não se aplica aqui. Não é apenas "repetidamente" armazenando e imprimindo 3 dígitos por vez (?), Portanto não é necessário armazenar o resultado final.
precisa saber é o seguinte
12
@ KevinFegan: Isso é verdade - o número é incrivelmente repetitivo, por isso seria fácil comprimir. Mas então não estamos mais armazenando o número em si, mas sim uma fórmula abstrata a partir da qual o número pode, teoricamente, ser computado; de fato, uma das fórmulas mais compactas é provavelmente o programa GolfScript acima, que o gera. Além disso, uma vez que avançamos um passo adiante no próximo programa, até mesmo "imprimir" os dígitos um de cada vez antes de descartá-los se torna impraticável - simplesmente não há maneira conhecida de realizar tantos passos da computação clássica no universo.
Ilmari Karonen
O GolfScript da @ IlmariKaronen acabou de dar um presente para o Googol!
Wally West
5
Que tal levar isso ao limite, ver qual o tamanho exato que você realmente pode atingir no GolfScript dentro de 100 caracteres? Como está, seu resultado é menor que o número de Graham (que minha solução Haskell "aproxima"), mas como você diz, o GolfScript provavelmente pode ir ainda mais longe.
deixou de girar no sentido anti-horáriowis
3
@leftaroundabout: Consegui escrever um avaliador de notação de seta Conway em 80 caracteres do GolfScript, embora ele não atenda a todos os requisitos desse desafio (ele usa constantes numéricas e operadores aritméticos). Provavelmente poderia ser melhorado, mas pensei que poderia colocar isso como um novo desafio.
Ilmari Karonen
42

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

WallyWest
fonte
9
Nenhuma regra é dobrada:;) * Não é possível usar 0123456789 [check] * Use qualquer idioma em que dígitos sejam caracteres válidos; [check] * Você pode usar matemático / físico / etc. constantes <10. [check, used 2] * A recursão é permitida, mas o número gerado precisa ser finito; [marcar, sem recursão] Não é possível usar *, /, ^; [marcar] Seu programa pode gerar mais de um número; [check] Você pode concatenar strings; [check] Seu código será executado como está; [check] Comprimento máximo do código: 100 bytes; [check] Precisa terminar w / i 5 s [check]
WallyWest 9/14/14
Raspe 2 caracteres passando "."para substituir, em vez de/\./g
gengkev 12/01
1
@gengkev Infelizmente, apenas o uso de .replace (".", "") remove apenas o primeiro. personagem; Eu tenho que usar a substituição global para substituir ALL. caracteres da string ...
WallyWest 12/01
Você pode fazer isso m=Math,p=m.PI,e=m.E,s="",alert((p*p*p+s+e*e*e).replace(/\./g,s)), sua pontuação será 3100627668029981620085536923187664/63 ^ 3 = 1,240017943838551e + 28
AMK
1
@Cory Por um lado, eu não vou repetir uma constante, caso contrário, todos seriam usá-lo ... Em segundo lugar, eu realmente não tem um segundo argumento ...
Wally West
28

C, escore = 10 10 97,61735 / 98 3 ≈ 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 64 -1, repetida (2 64 -1) 4 vezes . Primeiro, veja como estou estimando (baixo) o número acumulado de dígitos de 1 a 2 64 -1 (a "subsequência"): O número final na sequência de subsequência é 2 64 -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 64 -1) 4 vezes, então o comprimentode n terá .pelo menos (0,9 × (2 64 -1) × 19 + 0,1 × (2 64 -1) × 10) × (2 64 -1) 4 = 3,86613 × 10 97 dígitos. Nos comentários abaixo, @primo confirma que o comprimento de n é 4,1433x10 97 . Então n em si será 10 para esse poder, ou 10 10 97.61735

eu = 98 caracteres de código

score = n / l 3 = 10 10 97.61735 / 98 3

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

Darren Stone
fonte
2
Em C, 'z'é o valor constante 122. Direito?
primo
1
Eu acho que printf("%d",n)vai aumentar o número. Além disso, o computador de 64 bits não significa comprimentos de 64 bits, por exemplo, o Windows usa o modelo LLP64 enquanto ainda é de 32 bits
phuclv
3
Não deveria importar . Estouro de número inteiro assinado é um comportamento indefinido em C, por isso é impossível prever o que acontecerá quando seu código for executado. Pode violar o requisito de finitude.
Dennis
1
Eu acho que a análise pode ser um pouco complicada. A concatenação 0..2^64-1é de exatamente 357823770363079921190 dígitos. Os (2^64-1)^4tempos repetidos são 4,1433x10 ^ 97. Tome 10 para esse poder é 10^10^97.61735≈ 10 ↑↑ 3,29875. Eu acho que você está reivindicando uma potência de dez que não possui (observe onde 3.866×10^97se tornou 3.866^10^97.
primo 15/01
2
Oi @primo. Obrigado por reservar um tempo para verificar isso. Aprecie isso. Entendo o que você está dizendo. Meu expoente final está errado. Deve ser em 2.0vez de 97. 10^10^10^2.00= 10^10^97.6. Vou refletir isso na minha pontuação agora.
Darren Pedra
19

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.

Cel Skeggs
fonte
4
Parece ótimo; aparentemente, seu "Ackermann modificado" é exatamente um avaliador da cadeia Conway .
deixou de girar no sentido anti-horáriowis
1
@leftaroundabout Não é bem assim, mas acho que tem a mesma força recursiva. Além disso, os zeros não são válidos nas cadeias, portanto, você deve soltar o zero da sua cadeia Conway na lista de pontuações.
Cel Skeggs
1
Porque você fez range(ord('~'))? Você não poderia ter feito range(125)por menos bytes, o que permitiria espremer um número maior como range(A(9,9,9))?
Esolanging Fruit
1
@ Challenger5: a regra 1 diz "Você não pode usar dígitos no seu código (0123456789)"
Cel Skeggs
@ CelSkeggs: Ah, eu esqueci disso.
Esolanging Fruit
18

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 2 (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

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

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

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

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

((((((.*.*)*)*)*)*)*)*
P 7 (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.

primo
fonte
1
Portanto, essa será apenas uma solução válida, desde que o número da versão permaneça menor que 10?
Lister
3
@MrLister Sim. Felizmente, nenhuma versão principal superior a 6 existe, e mesmo isso não é considerado para ser totalmente 'pronto', apesar de ter sido originalmente anunciado em 2000.
primo
@primo Você percebe que terá que revisar esta resposta quando o Perl entrar em um número de versão> 10, certo? ;)
WallyWest
3
@ Eliseod'Annunzio Se ainda estiver vivo quando esse dia chegar, prometo voltar e consertá-lo.
Primo
2
Uma solução em execução que ultrapassa 10 ↑↑ 4. Isso é impressionante. Bravo!
precisa saber é
16

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

        insira a descrição da imagem aqui

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 15 ). Usando equivalências para somas finitas , o acima pode ser expresso explicitamente como

        insira a descrição da imagem aqui

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

        insira a descrição da imagem aqui

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

        insira a descrição da imagem aqui

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 -

        insira a descrição da imagem aqui

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

        insira a descrição da imagem aqui

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 15 ) ∼ 10 16 . 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 16
  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}
Andrew Cheong
fonte
Meu cálculo sobre sua pontuação é baseado na observação de que falgo como levar o número zao seu próprio poder. Então é assim ↑↑↑. Claro que a pontuação não é 2↑↑↑2, desculpe ... 2↑↑↑5+1parece mais. Você concorda, devo colocar isso na tabela de classificação?
deixou de girar no sentido anti-horáriowis
@leftaroundabout - Obrigado por investigar novamente. Não me sinto confortável o suficiente com a notação de seta para cima para dizer se sua sugestão soa correta ou não, mas calculei a ordem de magnitude da minha pontuação (consulte a edição), se você quiser atualizar a tabela de classificação com isso.
Andrew Cheong
Excelente! Também não sou nada firme com as setas para cima. Então, na verdade você tem "apenas" uma torre de poder; Receio que você coloque dois pontos mais baixos no ranking. Parabéns por analisar adequadamente o resultado; minhas estimativas provavelmente têm ainda mais falhas, mas achei que alguém deveria pelo menos tentar obter alguma ordem nas respostas.
deixou de girar no sentido anti-horáriowis
1
Sua pontuação está errada. Sempre que você inicia um loop, i=o.z;while(i--)...você não está executando os o.ztempos do loop , porque ele é baseado em uma variável inteira e o.zcontém uma string maior que o maior inteiro representável, dependendo do tamanho da palavra do intérprete. Supondo que, para seu benefício, seu intérprete não vomite em converter uma string para int, iiniciará cada vez com seu maior valor inteiro representável, digamos 2 ^ 63, e não com o valor atual de o.z.
Tobia
2
@ acheong87 Não se remova, você apenas tem que recalcular sua pontuação, limitando as variáveis ​​de loop para 2 ^ 63 ou algo assim. PS: deixe sua pontuação analítica postada aqui, é muito instrutivo!
Tobia
14

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 44 dígitos.

Portanto, a pontuação é 10 10 × 123456789 44 /100 3 ≈ 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 31 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 2 vezes
  • {⍞←n}⍣n⍣n⍣n vai fazer isso n 3 vezes
  • Eu poderia caber 44 ⍣nlá, para que ele imprima n 44 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.

Tobia
fonte
Seu número impresso será dividido pelo número de bytes que você usou para sua solução ^ 3. , você está dividindo por 100 agora.
usar o seguinte código
2
@ToastyMallows - parece 100 cubed(100 ^ 3) para mim.
precisa saber é o seguinte
1
Eu sei, mas são bytes, não caracteres.
precisa saber é o seguinte
1
@ToastyMallows Leia as notas finais na resposta.
Simply Beautiful Art
Altere {⍞←⎕D}para ⍞←que você economiza três bytes que você pode usar para adicionar mais um ⍣ne aumentar ⊢n←⍎⎕Dem ⌽⍕n←⍎⎕D80 vezes. Se você permitir a execução ⎕PP←17, use em ×⍨vez de ⌽⍕quase o dobro do número de dígitos impressos.
Adám 15/01
12

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

nm
fonte
o=length[]você recebe um extra !qno final e economiza um byte em cima disso.
Khuldraeseth na'Barya
9

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.

recursivo
fonte
Seu código não é executado. Apenas print True<<(True<<(True<<(True<<True<<True)))faz, e isso gera uma string de 19k.
Gabe
Quais são os requisitos mínimos de sistema?
Danubian Sailor
8
Você não poderia reduzi-lo definindo t=Truee depois usando tdepois?
Bob
1
Melhor ainda, basta fazer um loop que faça esses aninhamentos para você.
Arte simplesmente linda
Isso falha para mim:$python -c 'print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))' Traceback (most recent call last): File "<string>", line 1, in <module> OverflowError: long int too large to convert to int
Brian Minton
8

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

Ben Reich
fonte
7

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.

histocrata
fonte
3
isso depende do gerador de números que, na maioria dos idiomas, é improvável que seja capaz de gerar 97 vezes o mesmo número
ratchet freak
1
Bom ponto, então, além de assumir um poder de computação que aumenta continuamente, também preciso assumir uma fonte perfeita de aleatoriedade e uma implementação Ruby que a utilize.
histocrat
7

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 ε 0cresce 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 .)

res
fonte
'',:o;'oo',:t;apenas atribui os valores 0para oe 2para t; se isso é apenas para solucionar a falta de dígitos, pode ser abreviado fortemente para ,:o)):t;, exceto que não há razão para excluir tem primeiro lugar, porque você pode escrever expr:t;{...}:f;[[[t]f]f]fpara [[[expr:t]{...}:f~]f]fsalvar outros 3 caracteres.
Peter Taylor
Ainda não há necessidade de aparecer o: tenho certeza de que [0 126]fserá maior do que [126]fvocê salva um caractere e aumenta a saída. Embora você esteja deixando uma string vazia lá dentro, o que provavelmente quebra as coisas: talvez seja melhor começar #[[,:o'~'=]
342 Peter Taylor
Ah, e isso [é desnecessário, pois você não tem mais nada na pilha.
Peter Taylor
Ha ... rolar essas respostas, e então eu vejo isso ... e então percebo a resposta aceita ... hm ......
Simply Beautiful Art
@SimplyBeautifulArt Não sei ao certo o que você quer dizer, mas a resposta aceita calcula um número muito maior que esse (supondo que ambos sejam como reivindicados).
res
7

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.

Fraxtil
fonte
Não faço ideia do que esse código faz ... só posso assumir que está correto. Talvez você possa explicar um pouco?
deixou de girar no sentido anti-horáriowis
Vou explicar o código, pedaço por pedaço, quando tiver tempo mais tarde.
Fraxtil
Bem, eu espaçei essa explicação, mas a adicionei agora. Espero que isso esclareça as coisas.
Fraxtil 13/01
dc-1.06.95-2 termina imediatamente, não imprimindo nada.
Primo
1
Eu não esperaria que funcionasse em qualquer máquina existente, dada a magnitude do valor que ela tentaria gerar. Eu tenho a mesma versão do dc e segfaults depois de alguns segundos. Estou assumindo que respostas "teoricamente corretas" são permitidas aqui, pois não há critérios para o consumo de recursos.
Fraxtil 16/01
6

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 64 -1) 2 64 . Esse somatório é menor que (2 64 ) 2 64 , e eu preciso de uma potência de dois para fazer esse cálculo. Portanto, vou calcular (2 64 ) 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 64 -1) 2 64 para 10 n ?

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

David Yaw
fonte
Talvez. %uestava imprimindo números de 32 bits mesmo com uma compilação de 64 bits, então acabei de llcriar o hábito de escrever em um compilador de 32 bits.
David Yaw
Eu acho %lluque seria long long, e %luestaria correto long.
tomlogic
Fixo. Força do hábito: %ué sempre de 32 bits, %llué sempre de 64 bits, seja compilando como 32 ou 64 bits. No entanto, a solução aqui exige que longseja de 64 bits, então você tem razão, %lué suficiente.
David Yaw
Não é garantido que suas variáveis ​​na pilha sejam inicializadas em 0. No segundo programa, basta colocá-las fora de qualquer função. No primeiro, você precisará inicializar i.
Art
Além disso, o overflow longo é um comportamento indefinido e muitos compiladores modernos apenas o otimizam se detectá-lo. Você provavelmente deseja usar o sinal não assinado por muito tempo.
Art
5

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........
lebatsnok
fonte
2
Eu não acho que você precise incluir o número na postagem. Também ocupa muito espaço no celular.
totallyhuman
@totallyhuman Concordo, talvez os primeiros 100 dígitos, max
tuskiomi
@totallyhuman ok obrigado feito :)
lebatsnok
caté uma função estranha, pois o primeiro argumento é .... Portanto, tudo antes do primeiro argumento nomeado vai para ...(e será cat'ed), e é por isso que sepdeve ser nomeado - caso contrário, pode-se abreviá-lo comocat(abs(.Random.seed),,"")
lebatsnok
5

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 ↑ n 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".

Kendall Frey
fonte
Maximum code length is 100 bytes;Caso contrário, este é perto imbatível
Cruncher
@Cruncher Aaah, eu perdi isso
Kendall Frey
Ahh, eu te odeio agora. Toda vez que tento entender o tamanho do número de Graham, minha cabeça dói.
Cruncher
além disso, o número de Graham não conta como uma constante> 10?
serakfalcon
1
Agora, para determinar se o meu bate o de Ilmari.
Kendall Frey
5

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.

ecksemmess
fonte
1
#DEFINE C while (- longo n, o, p, q, r, s, t; main () {Cn) {Co) {Cp) {Cq) {Cr {Cs {Ct) {putchar ('z' -'A ');}}}}}}}}
RobAu
@RobAu Você é um gênio! Faça disso uma resposta. Tenho certeza de que seria o vencedor. Acho que você esqueceu um casal ), mas tudo bem, porque você tem apenas 96 caracteres no momento.
Andrew Larsson
Para todos que não conseguiu o sarcasmo: ver codegolf.stackexchange.com/a/18060/7021 para uma solução ainda melhor;)
Robau
5

Novo Ruby: score ~ ​​f ω ω2 +1 (126 2 2 126 )

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 2 126 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.

Arte simplesmente bonita
fonte
Vamos continuar esta discussão no chat .
HyperNeutrino
Na verdade, são 103 bytes, acho que você tinha uma nova linha à direita.
Rɪᴋᴇʀ
@Riker Eu acredito que você copiou e colou a partir daqui. Observe que deve haver um caractere não imprimível na segunda linha, portanto 104 bytes.
Simply Simply Art
@SimplyBeautifulArt ah, ok. Eu pensei que copiei o personagem. Desculpa.
Rɪᴋᴇʀ
@Riker Nah, nem está lá devido ao Stackexchange não me deixar esconder caracteres invisíveis em todos os lugares.
Simply Simply Art
4

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 2 (61) ou 4 (1) ---
  • a 3 (61)
  • ...
  • um 18 (61) ou um 20 (1). Eu acho que isso é aproximadamente g 18 (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 ↑ 59 64 + 3, que é claramente maior que g1 = 3 ↑ 4 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 20 (1) ~ = g 18 . O termo final em n , (a n-1 ) é muito maior que 3, portanto é potencialmente maior que g 18 . Vou ver se consigo descobrir se isso aumentaria uma única iteração e reportaria de volta.

Toeofdoom
fonte
Sua análise está correta e g <sub> 18 </sub> é uma boa aproximação.
Simply Beautiful Art
length"a"economiza alguns bytes e permite outro.a
Khuldraeseth na'Barya
4

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'
Robert Sørlie
fonte
Você obviamente nunca fez isso. Ele substitui seu código e trava.
Joshua
4

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.

iWiggins
fonte
4

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'
Joshua
fonte
SHLVL é o nível de festa como subbash:bash -c 'bash -c "echo \$SHLVL"'
F. Hauri
stat --printfnão trabalha Tentestat -c %s
F. Hauri
@ F.Hauri: --printf funciona para mim, mas o faz -c, de modo que reduziu alguns bytes. Obrigado.
Joshua
4

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.

Arte
fonte
Melhor implementação C, de longe. Por que usar 5 variáveis, quando você pode usar uma matriz de 258048 ?
Primo
4

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.

Mão-E-Comida
fonte
A regra 1 diz que nenhum dígito é permitido, você tem um 0.
Kyle Kanos
Porra, eu também. Lá se vai minha contagem de caracteres.
Hand-E-Food
Você pode usar -ea(+'')para reduzir o tamanho ( ''convertido em um número 0cujo valor de enumeração é SilentlyContinue). Você pode usar \Dpara a regex de substituição que é a mesma que [^\d]. E você pode simplesmente usar em %{$_.Length}vez de select Lengthse livrar dos cabeçalhos das colunas. E então você pode se livrar de -splite -replacetambém, deixando-o com -join(gci \ -ea(+'')-r|%{$_.Length})37 caracteres mais curtos (também reordenei os parâmetros porque os parênteses são necessários de qualquer maneira por causa de +'').
Joey
4

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.

Magenta
fonte
Você pode aumentar seu número alterando f(m-g,g)para f(m-g,m).
Simply Simply Art
ou f(m-g,i). Além disso, no final da primeira linha, você usa um número. Eu acredito que você pretendia usar n+g, e depois vou apontar que n+nserá maior.
Simply Beautiful Art
Você pode salvar alguns bytes alterando len ('"') para True
Brian Minton 18/17
E use ord ('^?') (Onde ^? É o caractere DEL, ASCII 127) para um número maior. EDIT não importa, isso não é "Imprimível".
Brian Minton
@BrianMinton Quem disse que deve ser imprimível?
Simply Beautiful Art
4

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

serakfalcon
fonte
3

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.

Cel Skeggs
fonte
Estimei o resultado, fique à vontade para discordar.
deixou de girar no sentido anti
Eu tenho que discordar desse resultado. Um momento enquanto digito meu raciocínio.
precisa saber é o seguinte
Aqui vamos nós. Como eu disse na atualização, sua estimativa parece ser significativamente menor que o valor real.
Cel Skeggs
É justo o suficiente, mas de qualquer forma, precisamos de uma estimativa recursiva indutiva / de uma só vez, e não apenas uma única etapa, para incluir essa resposta na lista de pontuação. Tenho certeza de que sua pontuação é melhor que a recursiva , mas também com certeza não melhor que a de Ilmari Karonen (que é muito extensível de qualquer maneira, usando apenas 18 caracteres no momento), então acho que minha estimativa é boa o suficiente para o objetivo de pontuação.
deixou de girar no sentido anti-horáriowis
Concordo. Vou ver se consigo trabalhar mais nisso e, pelo menos, criar um limite inferior mais preciso para o resultado.
precisa saber é o seguinte
3

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.

ybeltukov
fonte
Se você tiver azar, seu programa será interrompido após uma iteração e a solicitação rand()como condição de encerramento o tornará não determinístico. Além disso, chamar rand()todas as iterações deve torná-la terrivelmente lenta. Use algo como LONG_MAXdefinido em limits.hvez disso.
Klingt.net
Ok, eu pego de non deterministicvolta, porque não há sementes como você escreveu.
Klingt.net
1
Que tal em ~' 'vez de rand()imprimir com %u? Dois bytes a menos de origem e um valor mais alto.
MSalters