Actualizaciones: límite de tiempo eliminado. Debe poder describir la salida; consulte la nueva regla.

Un pangrama es una oración que usa todas las letras del alfabeto al menos una vez, como:

El rápido zorro marrón salta sobre el perro perezoso.

Un pangrama perfecto usa cada letra exactamente una vez.

Considere escribir un programa que sea un pangrama perfecto, utilizando los 95 caracteres ASCII imprimibles (códigos hexadecimales 20 a 7E) como alfabeto:

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

Dicho programa debe contener exactamente 95 caracteres, y cada carácter ASCII imprimible debe aparecer exactamente una vez, pero en cualquier orden. (Por lo tanto, hay 95! = 1.03 × 10 ¹⁴⁸ posibilidades.)

Su tarea es escribir este programa de manera que el número de caracteres ASCII imprimibles impresos en stdout sea lo más alto posible (es decir, prolífico).

Su puntaje es el número de caracteres ASCII imprimibles que genera su programa (la cantidad total , no la cantidad distinta : AABCpuntajes 4 mientras que ABCpuntajes 3) . El puntaje más alto gana.

Detalles

• El resultado puede contener cualquier carácter (incluidos los duplicados), pero solo las instancias de los 95 caracteres ASCII imprimibles cuentan para su puntaje.
  • Puede usar este JSFiddle para contar el número de caracteres ASCII imprimibles en cualquier cadena.
• Si su idioma no tiene stdout, use la alternativa más apropiada.
• Su programa ...
  • debe tener un tiempo de ejecución finito (se ha eliminado el límite de tiempo)
  • debe tener salida finita
  • puede contener comentarios
  • debe compilarse y ejecutarse sin errores (no detectados)
  • no debe solicitar ni requerir entrada
  • debe ser invariante en el tiempo y determinista
  • no debe usar bibliotecas externas
  • no debe requerir una conexión de red
  • no debe hacer uso de archivos externos
    • (puede usar el archivo del programa en sí mismo siempre que cambiar el nombre del archivo no altere el comportamiento del programa)
• Si esta tarea es imposible es algún lenguaje que es demasiado malo.
• Debe dar su resultado exacto o describirlo con precisión si es demasiado grande para caber en una publicación . En realidad, no tiene que ejecutar su programa. Siempre que se ejecute en un tiempo finito en una computadora con una cantidad ilimitada de memoria, es válida.

Ejemplo

Este programa simplista de Python 2 es una posible solución:

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

Salida 9876543210que contiene 10 caracteres ASCII imprimibles, obteniendo así 10.

GolfScript, más de 2 caracteres ↑↑↑ (9871 ↑↑ 2)

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

Imprime un número entero. Aproveche el tamaño de registro de CPU ilimitado (que determina la longitud máxima de la cadena en Ruby), la memoria y el tiempo de ejecución. El salto de línea es únicamente para facilitar la lectura.

El 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.
 }/           #

El marcador

Defina b = 9871 ↑↑ 2 (vea la notación de flecha hacia arriba de Knuth ).

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

• El bloque interno ejecuta g: x ↦ f ^x (x) .

  Dado que 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 ↑↑ 4 y así sucesivamente, tenemos
  g (x)> x ↑↑ (x + 1)> x ↑↑ x .

• El bloque externo ejecuta h: x ↦ g ^b (x) .

  Dado que 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 y así sucesivamente, tenemos h (x)> x ↑↑↑ (b + 1) .

• Comenzamos con el número entero 2 en la pila, por lo que el código calcula h (2)> 2 ↑↑↑ (b + 1).

• El puntaje es el número de dígitos decimales de h (2) , que es log (h (2)) + 1> log (2 ↑↑↑ (b + 1))> 2 ↑↑↑ b .

Por lo tanto, la puntuación es mayor que 2 ↑↑↑ (9871 ↑↑ 2) .

2 ↑↑↑ n crece a un ritmo ridículo como n se hace más grande. 2 ↑↑↑ 4: = 2 ↑↑ 2 ↑↑ 2 ↑↑ 2 = 2 ↑↑ 2 ↑↑ 4 = 2 ↑↑ 65536 , que es una torre de poder asociativa derecha de 65536 copias de 2 :

Del mismo modo, 2 ↑↑↑ 5: = 2 ↑↑ (2 ↑↑↑ 4) , que es una torre de poder de 2 ↑↑↑ 4 copias de 2 .

Ahora, el puntaje no es 2 ↑↑↑ 4 o 2 ↑↑↑ 5 , es mayor que 2 ↑↑↑ b , donde b> 2 × 10 ^{39 428} . Ese es un gran número ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

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

Salida:

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

repetido 18446744073709551615 * 10 ^ 987654320 veces.

$[es por defecto 0, entonces ~$[es equivalente a 18446744073709551615.

Como nota al margen, me quedé sin memoria tratando de crear el número 10^987654320.

Respuesta anterior (7703703696):

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

Salida es:

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

repetido 98765432 veces.

Nota: ejecute todas las muestras con perl -Mbignum -E

Bash + coreutils, 151,888,888,888,888,905 (1.5 * 10 ^ 17)

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

Emite números enteros de 1 a 9x10 ¹⁵ , uno por línea. Toma mucho tiempo.

¿Por qué 9E15? Resulta que GNU seqparece usar flotantes de 64 bits (doble) internamente. El número entero más grande que podemos representar con este tipo, antes de que el incremento en uno deje de funcionar debido a la falta de precisión, es 2 ⁵³ o 9007199254740992. Lo más cercano que podemos llegar a esto con notación exponencial es 9E15 o 9000000000000000.

Para calcular el puntaje, estoy usando la suma de todos los números con un número dado de dígitos y agregando 9E15, porque hay una nueva línea 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

Podría canalizar esta salida por odun orden adicional de magnitud más o menos, pero eso hace que el cálculo de la puntuación sea mucho más difícil.

Respuesta al cambio previo a la regla:

Bash + coreutils, 18,926,221,380

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

Salidas 1 a 1592346780. En mi macbook de mediados de 2012 (que no está tan lejos del punto de referencia vinculado), esto toma alrededor de 9m45s.

_{No pude resistirme a optimizarlo un poco más, aunque probablemente no tenga sentido.}

Salida:

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

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

GolfScript, ≈ 3 * 10 ^ (2 * 10 ^ 7) es decir, ≈ 3x10 ^20000000

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

Cómo 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";

Aquí Xestá el recuento de caracteres (longitud) de la representación de cadena de la matriz [0, 1, 2..,(87^9654321) - 1]que será como[0 1 2 3 4 ... (87^9654321) - 1]

Estoy tratando de calcular Xaquí para encontrar mi puntaje. (87^9654321) - 1es aproximadamente 10^(10^7.272415829713899)con 18724742dígitos decimales.

Xes más o menos 3*10^(2*10^7)así X*Xque también es lo mismo. Tenga en cuenta que estos valores están en un lado muy inferior ya que debido a las limitaciones de cálculo de (incluso) wolframa , no pude calcular sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)cuál es el verdadero valor deX

MATLAB, 95

Código

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

Salida

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

La salida contiene todos los caracteres ASCII especificados, cada uno exactamente una vez y en orden.

Ruby, 89

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

Salida:

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

Contiene todos los caracteres ASCII, salvo, p, , %, q, {, y }.

GolfScript, 93

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

Salida:

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

Contiene todos los caracteres ASCII excepto "y '.

Golfscript - 27 * 2 ^{6543 9870}

Esta es mi primera presentación Golfscript! :)

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

Explicación:

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

La salida es una carga de listas de números. Considere el siguiente código:

12,`{.+}1*

Con 12,esto produce la siguiente matriz:

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

El backtick lo convierte en una cadena y lo pasa al bloque {.+}. Esto duplica la cadena y luego concatena las dos, produciendo:

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

El 1*le dice al intérprete que ejecute el bloque anterior una vez (2 ¹ = 2).

Entonces, basado en eso:

 12,`{.+}n*

Emite la salida de 12,`2 ⁿ veces.