Scrivi un programma il più breve possibile (come misurato dal conteggio dei byte), non accetta input, non contiene commenti e genera una stringa / sequenza di caratteri, in modo tale che programma + output concatenati siano lunghi esattamente 95 caratteri e contengano tutti i caratteri ASCII stampabili esattamente una volta , ovvero programma + output è una permutazione dei 95 caratteri con codici ASCII 32-126:

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

In caso di pareggio, il vincitore è la voce il cui programma concatenato (95 caratteri) + output è il più vicino alla stringa sopra, misurata dalla distanza di modifica di Levenshtein (ovvero il numero di cancellazioni, inserzioni o sostituzioni necessarie per metterlo in ordine ASCII).

GolfScript, 14 caratteri

{`),32>46-^}.~

Uscita :

 !"#$%&'(*+/015789:;<=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]_abcdefghijklmnopqrstuvwxyz|

Perl, 89 caratteri

Questo è il migliore che sono stato in grado di fare finora:

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

Per chi non è pratico in Perl minuzie, i due argomenti della printdichiarazione potrebbero essere resi come ~(-($=)) . (73 * 2)e tr///.

Il programma genera 6 caratteri:

591460

Purtroppo ogni singola iterazione costrutto che mi viene in mente in Perl ( for, while, until, map, grep) azioni almeno un personaggio con print. Se all'output fosse permesso di apparire nuove righe, allora potrei usare Perl 5.010 per ottenere una soluzione di 87 caratteri:

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

PHP 67 byte

<?=U4eB1gkFdA6J9snZD2IE8y5PhwQV^xHGmqYMfNjKpbR3vcLalCWi0_TtrOSXouz;

Produzione:

-|"/@>& *+}:[!],'~(){.\`7#%$

Sembra che ci dovrebbe essere una soluzione a 65 byte, che genera 30 caratteri anziché solo 28, ma non riesco a farla allineare. I 6 personaggi inutilizzati OSXouzsono stati invece incollati su uno dei letterali a stringa.

Modifica: dopo ulteriori riflessioni, non è possibile generare più di 28 caratteri in questo modo. UPPER ^ lowercomporterà sempre un carattere tra 32 e 63, quindi sono necessarie tutte e 10 le cifre @[\]_`{|}~. Quattro dei restanti 22 sono usati nello stesso script, lasciando solo 18 che possono essere ottenuti solo con lettere. Tuttavia, il tiebreaker potrebbe essere migliorato in modo significativo.

Rubino, 91 caratteri

%{ !"#$&\',-/450:<=>ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcefghijklmnqvwxyz|~};puts(?@‌​.ord*98+1)

Uscite 6273.

%{...} trucco rubato da Jan Dvorak

Perl, 61 caratteri

print$:x8^CJIBQTOWAEULHVGFNMKRPZY,q<#"/;*g~?|={.>&+u15m97ws26

Produzione:

c@db[yo]le_ah\jfD`kX}zS-! %)('v304

$:il valore predefinito è " \n-". x8lo ripete otto volte; il risultato di 24 caratteri viene quindi bitored xored con un barestring di 23 caratteri (l'ultimo -viene lasciato così com'è). La seconda parte è una stringa Q di 12 caratteri bit a bit e una limitazione di 10 caratteri (gli ultimi 2 caratteri vengono scartati).

Rubino, 95 caratteri, 6 modifiche

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

Sì. Questo è tutto. Solo una stringa fluttuante letterale che non viene mai stampata. Ruby supporta i letterali di stringa (presi in prestito da Perl, credo) nella forma delimitatore di tipo percentuale - il delimitatore è un carattere non alfanumerico e se il delimitatore di apertura è una parentesi aperta (una delle [({<), il delimitatore di chiusura è il corrispondente parentesi di chiusura (sono consentite parentesi nidificate).

Mi rendo conto che si tratta più di una presentazione di base, ma a meno che qualcuno non riesca effettivamente a stampare qualcosa o a meno che non ci sia una lingua con una stringa a forma libera a due caratteri letterale con un delimitatore di apertura e chiusura diverso , questo è il migliore che ci sia.

Tcl 96, modifica distanza 12

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