Programas prolíficos de pangramas perfectos relacionados con ASCII imprimible

23

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

code-challenge  restricted-source  busy-beaver  pangram 
— Pasatiempos de Calvin
fuente
14
Tan asombrosamente admirable como parece la aliteración, los pangramas solo tienen un golpe poderoso, ya que son bastante molestos.
— Geobits
2
Acabo de releer la regla de no totalmente distinto también. Lo examiné antes, concluyendo que obviamente era una regla distinta, no total, ya que la alternativa conduciría a construcciones absurdas, como imprimir la letra aseis billones de veces, donde ni siquiera es posible obtener un límite superior preciso en Número de letras. De todos modos, todavía estoy orgulloso de mi 95, incluso si es un poco pequeño. El tamaño no lo es todo, ya sabes.
— COTO
¿Por qué crees que esta tarea es imposible en HQ9 +?
— Peter Taylor
Voy a intentar hacer esto en FORTRAN (para poder usar la insensibilidad a mayúsculas y minúsculas). --- Y tachar eso. Necesito la letra O 4 veces: 2 veces para la declaración del programa y 2 veces para la declaración de mi bucle.
— Nzall
1
@Dennis Nº 5Más
— Calvin Aficiones

Respuestas:

12

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 2 (x) = (x ↑ x) ↑ (x ↑ x)> x ↑ x ↑ x = x ↑↑ 3 ,
    f 3 (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 2 (x) = (x ↑↑ x) ↑↑ (x ↑↑ x)> x ↑↑ x ↑↑ x = x ↑↑↑ 3 ,
    g 3 (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 :

                                                                2 ↑↑↑ 4                                                                 

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

— Dennis
fuente
@DigitalTrauma - Deberías revisar el mío;)
— Optimizer
@Dennis - ¿Cuánto cuesta aproximadamente?
— Optimizador
@Optimizer Me tienes ;-)
— Digital Trauma
¡Increíble! Me recuerda el número de Graham ... ¡Eso es grande!
— reescrito el
3
Tenga en cuenta que, si bien esto teóricamente debería imprimir una gran cantidad de ceros, en la práctica simplemente bloquea al intérprete in `*': bignum too big to convert into `long' (RangeError).
— Ilmari Karonen
22

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

— es1024
fuente
¡bonito! pero me pregunto si uno podría usar la recursividad ... (no es posible llamarse a sí mismo si tiene que usar su propio nombre, ya que repetiría los caracteres del nombre ... pero el nombre de su función no podría terminar en $ _ u otra de las variables de Perl?) ... o use llamadas de $ 0 inteligentemente (sin llenar el montón)
— Olivier Dulac
Si tuviera suficiente memoria, podría hacerloperl -E'say qw{m}x(9876543210*ord$")'
— hmatt1
2
Si ayuda, ya no hay un límite de tiempo o memoria.
— Aficiones de Calvin
2
Es lamentable que Perl use ** en lugar de ^ para exponenciación.
— Mark
11

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 15 , 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 53 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
$
— Trauma digital
fuente
¿por qué no estás haciendo seq 9876543210;?
— durron597
@ durron597 Porque eso lleva demasiado tiempo, probablemente alrededor de una hora. Debe completarse en menos de 10 minutos.
— Trauma digital
pero seguramente el único factor limitante de este programa es E / S ... cualquier otro programa en cualquier otro idioma realmente no podría superar esto.
— durron597
@ durron597 Sí, creo que es correcto. Aunque no me sorprendería si alguien en esta comunidad encuentra una manera inteligente ...
— Digital Trauma
1
@DigitalTrauma Estoy eliminando el límite de tiempo para asegurarme de que esta no sea la penúltima respuesta (sin ofender, simplemente no quiero que el concurso termine tan pronto: P), así que siéntase libre de usar 9876543210. Es posible que desee leer la nueva última regla.
— Aficiones de Calvin
6

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

— Optimizador
fuente
En teoría, habría algunas maneras de hacer que esto sea aún más pesado, pero lamentablemente BigNum de Ruby tiene límites y 87 9654321?es justo Infinity.
— Dennis
Oh! ? ¿Sabes el máximo? ;)
— Optimizador
No exactamente. Parece depender de la máquina, ya que el entero tiene que caber en la RAM. Con memoria ilimitada, no sé dónde estaría el límite. Probablemente 2**(2**64)-1para Ruby de 64 bits.
— Dennis
Tenemos una cantidad ilimitada de RAM
— Optimizer
Sí, por eso lo aclaré. Para CJam, hay un límite fijo y el intérprete simplemente se bloquea cuando agota la memoria. Ruby parece ser diferente.
— Dennis
4

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.

— COTO
fuente
1
Nota para los espectadores: esta respuesta se envió cuando la especificación solicitó maximizar los caracteres únicos . Este ya no es el objetivo, pero está bien si esta respuesta se mantiene ya que es válida.
— Aficiones de Calvin
2

Ruby, 89

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

Salida:

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

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

— Pomo de la puerta
fuente
1
Nota para los espectadores: esta respuesta se envió cuando la especificación solicitó maximizar los caracteres únicos . Este ya no es el objetivo, pero está bien si esta respuesta se mantiene ya que es válida.
— Aficiones de Calvin
2

GolfScript, 93

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

Salida:

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

Contiene todos los caracteres ASCII excepto "y '.

— Pomo de la puerta
fuente
66
Sin embargo, su programa no es un pangrama perfecto, ¿verdad? No parece contener "ni 'tampoco.
— Martin Ender
Nota para los espectadores: esta respuesta se envió cuando la especificación solicitó maximizar los caracteres únicos . Este ya no es el objetivo, pero está bien si esta respuesta se mantiene si es válida.
— Aficiones de Calvin
1
Es bastante fácil hacer que esto sea válido bajo las nuevas reglas: simplemente retírelo #de su posición actual y añádalo #"'hasta el final. Sin embargo, la puntuación se reducirá en uno.
— Ilmari Karonen
2

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 1 = 2).

Entonces, basado en eso:

 12,`{.+}n*

Emite la salida de 12,`2 n veces.

— Decaimiento Beta
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.