Aggiornamenti: limite di tempo rimosso. Devi essere in grado di descrivere l'output: vedi la nuova regola.

Un pangram è una frase che utilizza ogni lettera dell'alfabeto almeno una volta, come ad esempio:

La rapida volpe marrone salta sopra il cane pigro.

Un pangram perfetto usa ogni lettera esattamente una volta.

Prendi in considerazione la possibilità di scrivere un programma che sia un diagramma perfetto, usando i 95 caratteri ASCII stampabili (codici esadecimali da 20 a 7E) come alfabeto:

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

Tale programma deve contenere esattamente 95 caratteri, con ogni carattere ASCII stampabile che si presenta esattamente una volta, ma in qualsiasi ordine. (Quindi ci sono 95! = 1.03 × 10 ¹⁴⁸ possibilità.)

Il tuo compito è scrivere questo programma in modo tale che il numero di caratteri ASCII stampabili stampati su stdout sia il più alto possibile (cioè prolifico).

Il tuo punteggio è il numero di caratteri ASCII stampabili emessi dal tuo programma (la quantità totale , non la quantità distinta : AABCpunteggi 4 invece ABCpunteggi 3) . Vince il punteggio più alto.

Dettagli

• L'output può contenere qualsiasi carattere (inclusi i duplicati) ma solo le istanze dei 95 caratteri ASCII stampabili vengono conteggiate ai fini del punteggio.
  • È possibile utilizzare questo JSFiddle per contare il numero di caratteri ASCII stampabili in qualsiasi stringa.
• Se la tua lingua non ha stdout usa l'alternativa più appropriata.
• Il tuo programma ...
  • deve avere un tempo di esecuzione limitato (il limite di tempo è stato rimosso)
  • deve avere un output finito
  • può contenere commenti
  • deve essere compilato ed eseguito senza errori (non rilevati)
  • non deve richiedere o richiedere input
  • deve essere invariante e deterministico nel tempo
  • non deve utilizzare librerie esterne
  • non deve richiedere una connessione di rete
  • non deve utilizzare file esterni
    • (è possibile utilizzare il file di programma stesso a condizione che la modifica del nome del file non modifichi il comportamento del programma)
• Se questo compito è impossibile, è un linguaggio troppo brutto.
• Devi fornire il tuo esatto output o descriverlo con precisione se è troppo grande per essere inserito in un post . In realtà non è necessario eseguire il programma. Fintanto che sarebbe eseguito in un tempo finito su un computer con una quantità illimitata di memoria è valido.

Esempio

Questo semplicistico programma Python 2 è una possibile soluzione:

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

Emette 9876543210che contiene 10 caratteri ASCII stampabili, ottenendo così un punteggio di 10.

GolfScript, oltre 2 caratteri ↑↑↑ (9871 ↑↑ 2)

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

Stampa un numero intero. Approfitta delle dimensioni illimitate del registro CPU (che determina la lunghezza massima della stringa in Ruby), la memoria e il tempo di esecuzione. L'alimentazione di linea è solo per leggibilità.

Il codice

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

Il punteggio

Definisci b = 9871 ↑↑ 2 (vedi la notazione con la freccia su di Knuth ).

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

• Il blocco interno esegue g: x ↦ f ^x (x) .

  Poiché 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 e così via, abbiamo
  g (x)> x ↑↑ (x + 1)> x ↑↑ x .

• Il blocco esterno esegue h: x ↦ g ^b (x) .

  Poiché 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 = x ↑↑↑ 4 e così via, abbiamo h (x)> x ↑↑↑ (b + 1) .

• Iniziamo con l'intero 2 nello stack, quindi il codice calcola h (2)> 2 ↑↑↑ (b + 1).

• Il punteggio è il numero di cifre decimali di h (2) , che è log (h (2)) + 1> log (2 ↑↑↑ (b + 1))> 2 ↑↑↑ b .

Pertanto, il punteggio è maggiore di 2 ↑↑↑ (9871 ↑↑ 2) .

2 ↑↑↑ n cresce a un ritmo ridicolo man mano che n diventa più grande. 2 ↑↑↑ 4: = 2 ↑↑ 2 ↑↑ 2 ↑↑ 2 = 2 ↑↑ 2 ↑↑ 4 = 2 ↑↑ 65536 , che è una torre di potere associativa di destra di 65536 copie di 2 :

Allo stesso modo, 2 ↑↑↑ 5: = 2 ↑↑ (2 ↑↑↑ 4) , che è una torre di potenza di 2 ↑↑↑ 4 copie di 2 .

Ora, il punteggio non è 2 ↑↑↑ 4 o 2 ↑↑↑ 5 , è maggiore di 2 ↑↑↑ b , dove b> 2 × 10 ^{39 428} . È un gran numero ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

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

Produzione:

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

ripetuto 18446744073709551615 * 10 ^ 987654320 volte.

$[è di default 0, quindi ~$[equivale a18446744073709551615 .

Come nota a margine, ho esaurito la memoria nel tentativo di creare il numero 10^987654320.

Vecchia risposta (7703703696):

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

L'output è:

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

ripetuto 98765432 volte.

Nota: eseguire tutti i campioni con perl -Mbignum -E

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

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

Emette numeri interi da 1 a 9x10 ¹⁵ , uno per riga. Richiede molto tempo.

Perché 9E15? Si scopre che GNU seqsembra usare float a 64 bit (doppio) internamente. Il numero intero più grande che possiamo rappresentare con questo tipo, prima che l'incremento di uno smetta di funzionare a causa della mancanza di precisione, è 2 ⁵³ o 9007199254740992. Il più vicino che possiamo ottenere con questa notazione esponenziale è 9E15 o 9000000000000000.

Per calcolare il punteggio, sto usando sommando tutti i numeri con un dato numero di cifre e aggiungendo 9E15, perché c'è una nuova riga tra ogni numero:

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

Potrei convogliare questo output odper un ordine di grandezza in più o giù di lì, ma questo rende il calcolo del punteggio molto più difficile.

Risposta modifica pre-regola:

Bash + coreutils, 18.926.221.380

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

Produce da 1 a 1592346780. Sul mio macbook di metà 2012 (che non è molto lontano dal benchmark collegato), ci vogliono circa 9m45s.

_{Non ho resistito all'ottimizzazione un po 'di più, anche se probabilmente non ha senso.}

Produzione:

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

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

GolfScript, ≈ 3 * 10 ^ (2 * 10 ^ 7) cioè ≈ ​​3x10 ^20000000

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

Come funziona

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";

Ecco Xil conteggio dei caratteri (lunghezza) della rappresentazione di stringa dell'array [0, 1, 2..,(87^9654321) - 1]che sarà simile[0 1 2 3 4 ... (87^9654321) - 1]

Sto provando a calcolare Xqui per trovare il mio punteggio. (87^9654321) - 1è approssimativamente 10^(10^7.272415829713899)con 18724742cifre decimali.

Xè più o 3*10^(2*10^7)meno allo X*Xstesso modo. Si noti che questi valori sono molto bassi poiché a causa delle limitazioni di calcolo del (pari) wolframa , non sono stato in grado di calcolare sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)quale sia il vero valore diX

MATLAB, 95

Codice

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

Produzione

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

L'output contiene tutti i caratteri ASCII specificati, ciascuno esattamente una volta e in ordine.

Ruby, 89

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

Produzione:

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

Contiene tutti i caratteri ASCII ad eccezione, p, , %, q, {, e }.

GolfScript, 93

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

Produzione:

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

Contiene tutti i caratteri ASCII tranne "e '.

Golfscript - 27 * 2 ^{6543 9870}

Questa è la mia prima presentazione Golfscript! :)

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

Spiegazione:

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

L'output è un carico di elenchi di numeri. Considera il seguente codice:

12,`{.+}1*

Con 12,esso produce il seguente array:

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

Il backtick lo trasforma in una stringa, passandolo al blocco {.+} . Questo duplica la stringa e quindi concatena i due, producendo:

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

Il 1*dice all'interprete di eseguire una volta il blocco precedente (2 ¹ = 2).

Quindi, in base a ciò:

 12,`{.+}n*

Emette l'output di 12,`2 ⁿ volte.