Atualizações: limite de tempo removido. Você deve ser capaz de descrever a saída - veja a nova regra.

Um pangram é uma frase que usa todas as letras do alfabeto pelo menos uma vez, como:

A rápida raposa marrom pula sobre o cachorro preguiçoso.

Um pangram perfeito usa todas as letras exatamente uma vez.

Considere escrever um programa que seja um pangram perfeito, usando os 95 caracteres imprimíveis ASCII (códigos hexadecimais 20 a 7E) como o alfabeto:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Esse programa deve conter exatamente 95 caracteres, com cada caractere ASCII imprimível ocorrendo exatamente uma vez, mas em qualquer ordem. (Portanto, existem 95! = 1,03 × 10 ¹⁴⁸ possibilidades.)

Sua tarefa é escrever este programa de forma que o número de caracteres ASCII imprimíveis impressos em stdout seja o mais alto possível (ou seja, prolífico).

Sua pontuação é o número de caracteres ASCII imprimíveis que seu programa produz (a quantidade total , não a quantidade distinta : AABCnotas 4 e ABCnotas 3) . A pontuação mais alta vence.

Detalhes

• A saída pode conter qualquer caractere (incluindo duplicatas), mas apenas instâncias dos 95 caracteres ASCII imprimíveis contam para a sua pontuação.
  • Você pode usar esse JSFiddle para contar o número de caracteres ASCII imprimíveis em qualquer sequência.
• Se seu idioma não possui stdout, use a alternativa mais apropriada.
• O seu programa ...
  • deve ter tempo de execução finito (o limite de tempo foi removido)
  • deve ter saída finita
  • pode conter comentários
  • deve compilar e executar sem erros (não capturados)
  • não deve solicitar ou exigir entrada
  • deve ser invariável e determinista no tempo
  • não deve usar bibliotecas externas
  • não deve exigir uma conexão de rede
  • não deve fazer uso de arquivos externos
    • (você pode usar o próprio arquivo de programa, desde que a alteração do nome do arquivo não altere o comportamento do programa)
• Se essa tarefa for impossível, alguma linguagem é muito ruim.
• Você deve fornecer sua saída exata ou descrevê-la com precisão se for muito grande para caber em uma postagem . Você não precisa realmente executar seu programa. Enquanto ele seria executado em uma quantidade finita de tempo em um computador com uma quantidade ilimitada de memória é válido.

Exemplo

Este programa simplista do Python 2 é uma solução possível:

print 9876543210#!"$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghjklmoqsuvwxyz{|}~

Ele gera 987654321010 caracteres ASCII imprimíveis, com 10 pontos.

GolfScript, mais de 2 caracteres ↑↑↑ (9871 ↑↑ 2)

2 9871.?,{;0$[45)63]n+*~}/
#!"%&'(-:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmopqrstuvwxyz|

Imprime um número inteiro. Aproveite o tamanho ilimitado do registro da CPU (que determina o comprimento máximo da string em Ruby), memória e tempo de execução. O avanço de linha é apenas para facilitar a leitura.

O código

2             # Push 2.
9871.?        # Push b := 9871↑↑2 = 9871↑9871 = 9871**9871.
,{            # For each i from 0 to b - 1:
  ;0$         #   Discard i and duplicate the integer on the stack.
  [45)63]n+*  #   Replicate ".?\n" that many times.
  ~           #   Evaluate.
 }/           #

A pontuação

Defina b = 9871 ↑↑ 2 (consulte a notação de seta para cima de Knuth ).

• .? executa f: x ↦ x ↑ x .

• O bloco interno executa g: x ↦ f ^x (x) .

  Como f (x) = x ↑ x = x ↑↑ 2 , f ² (x) = (x ↑ x) ↑ (x ↑ x)> x ↑ x ↑ x = x ↑↑ 3 ,
  f ³ (x) = (x ↑ x) ↑ (x ↑ x)) ↑ ((x ↑ x) ↑ (x ↑ x))> (x ↑ x ↑ x) ↑ (x ↑ x ↑ x) ↑ (x ↑ x ↑ x)> x ↑ x ↑ x ↑ x = x ↑↑ 4 e assim por diante, temos
  g (x)> x ↑↑ (x + 1)> x ↑↑ x .

• O bloco externo executa h: x ↦ g ^b (x) .

  Como g (x) = x ↑↑ x = x ↑↑↑ 2 , g ² (x) = (x ↑↑ x) ↑↑ (x ↑↑ x)> x ↑↑ x ↑↑ x = x ↑↑↑ 3 ,
  g ³ (x) = ((x ↑↑ x) ↑↑ (x ↑↑ x)) ↑↑ ((x ↑↑ x) ↑↑ (x ↑↑ x))> (x ↑↑ x ↑↑ x) ↑ (x ↑↑ x ↑↑ x)> x ↑↑ x ↑↑ x ↑↑ x = x ↑↑↑ 4 e assim por diante, temos h (x)> x ↑↑↑ (b + 1) .

• Começamos com o número inteiro 2 na pilha, portanto o código calcula h (2)> 2 ↑↑↑ (b + 1).

• A pontuação é o número de dígitos decimais de h (2) , que é log (h (2)) + 1> log (2 ↑↑↑ (b + 1))> 2 ↑↑↑ b .

Assim, a pontuação é maior que 2 ↑↑↑ (9871 ↑↑ 2) .

2 ↑↑↑ n cresce em um ritmo ridículo à medida que n aumenta. 2 ↑↑↑ 4: = 2 ↑↑ 2 ↑↑ 2 ↑↑ 2 = 2 ↑↑ 2 ↑↑ 4 = 2 ↑↑ 65536 , que é uma torre de força associativa à direita com 65536 cópias de 2 :

Da mesma forma, 2 ↑↑↑ 5: = 2 ↑↑ (2 ↑↑↑ 4) , que é uma torre de energia de 2 ↑↑↑ 4 cópias de 2 .

Agora, a pontuação não é 2 ↑↑↑ 4 ou 2 ↑↑↑ 5 , é maior que 2 ↑↑↑ b , onde b> 2 × 10 ^{39 428} . Esse é um grande número ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

say q{!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|}x(1e987654320*~$[)

Saída:

!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|

repetido 18446744073709551615 * 10 ^ 987654320 vezes.

$[é por padrão 0, então ~$[é equivalente a 18446744073709551615.

Como observação, fiquei sem memória tentando criar o número 10^987654320.

Resposta antiga (7703703696):

say qw(!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10)x98765432

A saída é:

!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10

repetido 98765432 vezes.

Nota: Execute todas as amostras com perl -Mbignum -E

Bash + coreutils, 151.888.888.888.888.905 (1,5 * 10 ^ 17)

seq 9E15;#\!%*+,-./2346780:=@ABCDFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[

Emite números inteiros 1 a 9x10 ¹⁵ , um por linha. Leva muito tempo.

Por que 9E15? Acontece que o GNU seqparece usar flutuadores de 64 bits (duplo) internamente. O maior número inteiro que podemos representar com esse tipo, antes que o incremento de um pare de funcionar devido à falta de precisão, seja 2 ⁵³ ou 9007199254740992. O mais próximo que podemos chegar disso com notação exponencial é 9E15 ou 9000000000000000.

Para calcular a pontuação, estou usando a soma de todos os números com um determinado número de dígitos e adicionando 9E15, porque há uma nova linha entre cada número:

8000000000000001*16 + 900000000000000*15 + 90000000000000*14 + 9000000000000*13 + 900000000000*12 + 90000000000*11 + 9000000000*10 + 900000000*9 + 90000000*8 + 9000000*7 + 900000*6 + 90000*5 + 9000*4 + 900*3 + 90*2 + 9 + 9000000000000000

Eu poderia canalizar essa saída por oduma ordem extra de magnitude, mais ou menos, mas isso dificulta muito o cálculo da pontuação.

Resposta pré-mudança de regra:

Bash + coreutils, 18.926.221.380

seq 1592346780;#\!%*+,-./:=@ABCDEFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[

Saídas 1 a 1592346780. No meu macbook de meados de 2012 (que não está muito longe do benchmark vinculado), isso leva cerca de 9m45s.

_{Eu não pude resistir a otimizá-lo um pouco mais, mesmo que seja provavelmente sem sentido.}

Saída:

$ time ./pangram.sh | wc
 1592346780 1592346780 18926221380

real    9m46.564s
user    11m7.419s
sys 0m10.974s
$ 

GolfScript, ≈ 3 * 10 ^ (2 * 10 ^ 7) ou seja, 3x10 ^20000000

 87 9654321?,`0${;.p}/#!"%&'()*+-9:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnoqrstuvwxyz|~

Como funciona

87 9654321?                "Pushes 87^9654321 to stack";
           ,               "Pushes an array [0, 1, 2 ... (87^9654321) - 1] to stack";
            `              "Creates a string representation of the array like "[0 1 2...]";
             0$            "Copies the string";
               {;.p}/      "Print the string wrapped in quotes X times";
                     #...  "This is all comment";

Aqui Xestá a contagem de caracteres (comprimento) da representação de string da matriz, [0, 1, 2..,(87^9654321) - 1]que será como[0 1 2 3 4 ... (87^9654321) - 1]

Estou tentando calcular Xaqui para encontrar minha pontuação. (87^9654321) - 1é aproximadamente 10^(10^7.272415829713899)com 18724742dígitos decimais.

Xé aproximadamente 3*10^(2*10^7)assim X*Xtambém é o mesmo. Observe que esses valores estão em um lado muito inferior, devido às limitações de computação do (mesmo) wolframa , não pude calcular sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)qual é o verdadeiro valor deX

MATLAB, 95

Código

char(37-5:126)% !"#$&'*+,./0489;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bdefgijklmnopqstuvwxyz{|}~

Saída

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

A saída contém todos os caracteres ASCII especificados, cada um exatamente uma vez e em ordem.

Ruby, 89

p %q{!"#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnorstuvwxyz|~}

Saída:

"!\"\#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnorstuvwxyz|~"

Contém todos os caracteres ASCII exceto, p, , %, q, {, e }.

GolfScript, 93

{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}

Saída:

{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}
}

Contém todos os caracteres ASCII, exceto "e '.

Golfscript - 27 * 2 ^{6543 9870}

Esta é a minha primeira submissão Golfscript! :)

12,`{.+}6543 9870?*#!"$%&'()-/:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz|~

Explicação:

12,                     - Creates an array of ascending numbers from 0 to 11
   `                    - Converts the array to a string
    {.+}                - Duplicates the string on the stack and concatenates the two
        6543 9870?      - Calculates 6543^9870 and pushes it to the stack
                  *     - Repeat the block 6543^9870 times
                   #... - The rest is a comment

A saída é uma carga de listas de números. Considere o seguinte código:

12,`{.+}1*

Com 12,ele produz a seguinte matriz:

[0 1 2 3 4 5 6 7 8 9 10 11]

O backtick transforma isso em uma string, passando para o bloco {.+} . Isso duplica a sequência e concatena as duas, produzindo:

[0 1 2 3 4 5 6 7 8 9 10 11][0 1 2 3 4 5 6 7 8 9 10 11]

o 1* diz ao intérprete para executar o bloco anterior uma vez (2 ¹ = 2).

Então, com base nisso:

 12,`{.+}n*

Emite a saída de 12,`2 ⁿ vezes.