Il tuo compito è costruire un programma (usando solo caratteri ASCII stampabili e / o tabulazioni e nuove righe) che stampa esattamente i caratteri nello spazio ASCII stampabile ( 0x20a 0x7e) che non compaiono nel codice sorgente del tuo programma (in qualsiasi ordine, comunque molte volte vuoi).

Il codice più breve per farlo in qualsiasi lingua vince.

GolfScript, 15 12 caratteri

{`),32>^.}.~

Basato sulla risposta di Jan Dvorak con alcuni colpi di scena e anche nello stile di quello di Peter Taylor .

Polyglot, 95

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

• Perl
• Perl 6
• Qualsiasi * shell nx-simile ( tclsh, bash, sh, ksh, ecc)
• Awk (GNU / POSIX)
• Brainfuck , Brian & Chuck , altri derivati
• Rubino
• Coffescript
• Golfscript
• Pitone
• R
• Julia
• Lo spazio bianco
• rk
• Gaot ++
• avanti Cristo
• JQ
• Gioia
• Tcl
• 99
• V (FMota)
• Acc !!
• C - se non main()è necessario. Grazie all'urogeno
• Probabilmente di più.

Non fa nulla.

PHP 5.2, 4

<?<<

Salva come file chiamato NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.phpda qualche parte in /home. short_open_tagdeve essere Onnel tuo php.ini.

L'output è:

PHP Parse error:  syntax error, unexpected T_SL in /home/wherever/NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.php on line 1

JavaScript - 88

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

stampa "bcdfghijkmnpquvxyz"

Spazio bianco, 61 57 caratteri

Non è il più breve ma probabilmente ha la logica più semplice (in realtà è solo un loop).

Qui è completamente commentato, dove S è spazio, T è tab, L è line feed:

SSSTSSSSSL     # push 0x20
LSSSL          # label S
SSSTL          # push 1
TSSS           # add
SLS            # duplicate top of stack
SLS            # duplicate again
TLSS           # output ASCII character
SSSTTTTTTSL    # push 0x7E
TSST           # subtract (result - 0x7E)
LTTSL          # branch to label S if top of stack is negative
LLL            # end

Grazie a @res per la correzione di quanto sopra (duplicato extra richiesto per l'istruzione di diramazione) e per numeri più piccoli da inserire nello stack.

C, 83 74 69 caratteri

main(z) {for(;++z<96;"\33iE!vk?}GkRP8z"[z/7]&1<<z%7&&putchar(z+32));}

Ho davvero provato a farlo scendere sotto gli 80 caratteri, ma non sono stato in grado di farlo. Alla fine ho deciso di pubblicare quello che ho, partendo dal presupposto che io (o qualcun altro) scopriremo la soluzione a 79 caratteri dieci minuti dopo aver pubblicato questo. Okay, non sono stati dieci minuti, ma ha funzionato in linea di principio.

Volevo davvero pubblicare una versione che non dovesse avere uno spazio gratuito nel codice sorgente, ma quella fosse atterrata in un'orbita di attrattore strano, rimbalzando tra una manciata di soluzioni. Dopo molti minuti passati a provare a spingerne uno in una soluzione stabile, ho rinunciato e ho aggiunto lo spazio.

Golfscript, 26 24 caratteri

"126,32>''+".~\-'.~\-"'-

Prende uno script di generazione di intervalli, lo duplica, lo esegue, lo sottrae dal suo risultato, quindi sottrae il codice di sottrazione del risultato e l'altro carattere di citazione.

Pesce - 80

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

Quando si verificano errori di pesce, viene stampato "qualcosa che odora di pesce ...". Poiché z è una cattiva istruzione, sbaglia immediatamente

So che non sta vincendo alcun concorso. Volevo solo provarlo in una lingua normalmente non utilizzata, solo per i calci.

Java - 209 195 152 140 caratteri

class a{public static void main(String[]a){for(char c=0;;c++)System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:}".indexOf(c)<0?c:"");}}

Con interruzioni di riga e schede

class a{
    public static void main(String[]a) {
        for(char c=0;;c++)
            System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"");
    }
}

Fai attenzione se esegui: il programma non termina. haha

Spiegazione

1. for(char c=0;;c++): Poiché un charpuò essere trattato come un int, lo uso a mio vantaggio qui per incrementare tutti i possibili valori di c. Ometto la condizione di terminazione nel ciclo (quella che andrebbe tra i due punti e virgola) per salvare i caratteri, poiché non è stato specificato che il programma doveva terminare. :)
2. "publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"": Purtroppo, non è un approccio molto elegante, ma fa il suo lavoro. Elenca manualmente ogni carattere presente nel codice sorgente come Stringletterale, quindi controlla se la corrente si char cverifica al suo interno con indexOf(). Se la indexOf()chiamata ritorna -1, non esiste e quindi dovremmo stamparla. Il resto usa solo l'operatore ternario per risparmiare caratteri e spazio.

Perl, 49 caratteri

say grep/[^+-246\[-^aceghmprsy]/,map chr,041..126

Questa è una sfida interessante: è una specie di anti-quine, e sono riuscito a ridurre il programma un paio di volte aumentando la gamma di personaggi che vi appaiono.

Rubino, 81 78 68 66 62 57

(?!..?~).map{|a|$><<a if/[()ifmap{}|?!.~\/\\\[\]$><]/!~a}

Si controlla da solo. Caratteri duplicati rimossi manualmente.

Grazie a Josh per aver salvato 4 caratteri e minitech per aver salvato 5 caratteri!

Befunge (48)

<|::-1,+*88:<+3*87
6<@.**85
9>"()~&"/%$ |!#';=?}

Output: {zyxwvutsrqponmlkjihgfedcba` _ ^] [ZYXWVUTSRQPONMLKJIHGFEDCBA240

Non molto serio, ma ho dovuto provarlo:

JSFuck (138152)

(fonte compilata qui)

Fonte originale:

for(x=0x7e;x>0x19;x--){
    console.log(String.fromCharCode(x).replace(/[\[\]!\+\(\)]/ig, ''))
}

Stampa tutti i caratteri tranne () + []!

Il tuo compito è costruire un programma (usando solo caratteri ASCII stampabili e / o schede e nuove righe)

Accidenti, hai reso difficile APL (è delibarato?)
Quindi decido di ignorare tutte le regole !!!

APL (Dyalog), 3 10

⎕AV

Stampa il vettore atomico (che include tutti i caratteri ASCII stampabili)

Ho scoperto che mi ero completamente dimenticato della parte "senza" ...
Ma è una soluzione semplice

⎕AV~'AV'''

~'AV'''significa exclude ( ~) i caratteri A, V e virgoletta singola (scappato come virgolette doppie raddoppiate)

Per quanto riguarda la stampa non ASCII, beh, sto ignorando tutte le regole.

GolfScript ( 18 16 caratteri)

"),@`^^32>#.~".~

Demo online con una riga aggiuntiva che esegue un controllo di correttezza e visualizza il numero di caratteri in errore.

(Ho varie alternative equivalenti. @`^Può essere sostituito con \\`; #può essere sostituito con `o ]. La giusta combinazione può essere usata con il trucco di Howard per eguagliare il suo punteggio di 15 perché le barre rovesciate non hanno bisogno di scappare in blocchi come fanno in letterali stringa: {),\`^32>].~}.~Ma Howard merita il merito per quel trucco).

Brainfuck, 173

+++++[->++++++<]>>>++[------<+>]<++++>>----[----<+>]>-[-------<+>]>-[---<+>]<------->>-[---<+>]<+++++++++>>--[-----<+>]<+++++>>+[---------<++>]+++++++++++++[<[.+<]>[>]<-]\=,

Abbastanza a lungo, potrei riprovare più tardi.

J ( 52 40)

Modifica: Duh, dimenticato e.

'''(-@.e#[)~95{32}a'(-.@e.#[)~95{.32}.a.

Vecchia versione:

(>@(*/@('(>@*/''&~:).#]32{95}a'&~:)&.>)#])95{.32}.a.

Altra variante (stessa lunghezza ma meno output):

([#~*/"1@('([#~*/"1@''&:0)95{.32}a'&~:"0))95{.32}.a.

Python 3 - 68 61

x=r"print(*set(map(chr,range(32,127)))-set(x+'=\"'))"
exec(x)

... grazie a @WolframH per i miglioramenti.

PowerShell: 96

Deve essere salvato ed eseguito come script.

diff([char[]](gc $MyInvocation.InvocationName))([char[]](32..126))-Pa|?{$_.SideIndicator-eq'=>'}

diffè un alias incorporato per Compare-Object.

gcè un alias incorporato per Get-Content.

$MyInvocation.InvocationName ottiene il percorso completo per l'esecuzione dello script.

32..126è l'equivalente decimale per 0x20..0x7e, e quindi crea una matrice dei codici ASCII decimali che stiamo cercando.

[char[]]prende i contenuti dell'oggetto successivo e li inserisce in un array, suddividendoli e convertendoli in caratteri ASCII. Quindi, ora abbiamo due matrici di caratteri ASCII: una estratta da questo script, l'altra definita dai criteri di sfida.

-Paimpostato Compare-Objectsul formato "Passthru", quindi solo gli elementi che si trovano diversi tra gli input vengono emessi sulla console - gli indicatori di quali elementi erano in cui gli input sono ancora memorizzati nei dati dell'oggetto, ma non vengono visualizzati.

|?{$_.SideIndicator-eq'=>'}Compare-Objectl'output di pipe a Where-Object, che lo filtra solo agli elementi che sono esclusivi per il secondo input.

PHP - 92

<? //A"$%&'()*+[,.]0123456789:=-@ABCDEFGHIJKLMNOPQRSTUVWYZ\^_`abcdefghijklmopqrstuvwxyz{|}~#

Produzione:

Niente

L'OP chiede di stampare tutti i personaggi inutilizzati, beh, li uso solo tutti

Javascript, 92

(function f(){for(i=32;126>i++;)!~(""+f).indexOf(c=String.fromCharCode(i))&&console.log(c)})()

Java - 126 caratteri

minimizzato:

class hjq{public static void main(String...w){for(char z='"'|0;++z!='a';)if("'()+.0;=OS".indexOf(z)==~0)System.out.print(z);}}

unminimized:

class hjq {
    public static void main(String... w) { 
        for (char z = '"'|0; ++z != 'a';) {
            if ("'()+.0;=OS".indexOf(z) == ~0) {
                System.out.print(z);
            }
        }
    }
}

Questo è un problema interessante, perché i singoli token potrebbero trarre vantaggio dalla loro forma più lunga perché riutilizza i personaggi. Ad esempio, normalmenteString[] sarebbe più breve, ma String...rimuove la necessità delle parentesi quadre nella stringa condizionale.

Ho scoperto che il trucco era cercare di usare i caratteri all'inizio e alla fine dell'intervallo in modo da poterli escludere dall'output semplicemente modificando l'inizio e la fine del tuo ciclo.

Per Java, un carattere chiave da escludere è ", perché avere quello nella stringa richiede di scappare, che si aggiunge \al programma, che deve andare nella stringa, che aggiunge \\. Rimuovendo "dalla stringa condizionale rimuovi 4 caratteri. Questo può essere ottenuto assicurandoti di usare e! di iniziare la vostra ciclo da #.

Tutte le lettere minuscole appaiono verso la fine della gamma, con la sola {, |, }e ~venire dopo di loro. A causa della verbosità di Java, la maggior parte delle lettere minuscole viene utilizzata solo per la caldaia. Allo stesso modo, {e }sono banali per un programma Java, perché la piastra della caldaia li richiede.

|può essere utilizzato se si dispone di una condizione o, ma non sono riuscito a trovare un modo per trarne vantaggio da un programma più breve rispetto al semplice utilizzo |come operatore bit a bit. Il|0 mi fa sentire un po 'sporco, perché è l'unica parte che è un NOP solo per ottenere il carattere in là.

~0rendimenti -1, il che è utile perché è quello con cui dobbiamo verificare indexOf. Combinando questo con l'utilizzo !=per il condizionale del ciclo si elimina del <tutto il carattere, il che significa che non è necessario andare all'interno della stringa condizionale.

sh (47)

tr</dev/urandom -cd \[:print:]|tr -d "`cat $0`"

Utilizza l'approccio autoreferenziale. Presuppone /dev/urandomche alla fine verrà emesso ogni ottetto almeno una volta. Non termina.

Se supponiamo che mansia installato, potremmo invece utilizzare la ascii(7)manpage (e quindi avere un programma di chiusura) ( 44 caratteri, grazie @fennec).

man ascii|tr -cd \[:print:]|tr -d "`cat $0`"

BitShift , 1038 byte

BitShift è un linguaggio che supporta solo 0e 1come sintassi. Ho pensato che sarebbe stato facile stampare tutti gli altri personaggi, ma dal momento che non supporta veramente il loop, è finito con un enorme 1038 byte.
Tuttavia, credo che non sia davvero possibile andare più piccolo di così ...

101001100101011011010100110111010100100101011001101111010100100101011001000101011011010100101100110110101001001010110010001010110110101000001101010010010101100100010101101101010000010000011001010110110101000010000101011011010100110111010100100101011111100101011011010100110111010100100101011001101111010100100101011001000101011011010100000000011010100100101011001000101011011010100110010000101011011010100110111010100100101011001101001101010010010101100100010101101101010011001000010101101101010011011101010010010101111011111110010101101101010011011101010010010101100101100101011011010100010001010110110101001000010101101101010011011101010010010101110111110010101101101010011011101010010010101111111100101011011010100110111010100100101011111011110101001001010110010001010110110101001000100000101011011010100110111010100100101011111010011010100100101011001000101011011010100100000101011011010100110111010100100101011001101111010100100101011001000101011011010100010000010101101101010011011101010010010101101001101101010010010101101001101010

stampe

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

Provalo qui

Sicuramente la soluzione più lunga qui, ma la codifica in Lino è sempre divertente:

L.in.oleum -655 523 caratteri

"libraries"/arch/cpu/base;/hmi/conout;/data/bytes;/data/string/t2s;/data/heap;/data/heap/connect/mgrab;"stockfile"a;"directors"displaystatus=engage;"injection"c=524;b<-bytes.bytesizeconvert:c;b<-heap.alloc:b;a<-heap.alloc:c;[filecommand]=readfile;[filename]=stockfile;[fileposition]=0;[fileblocksize]=c;[fileblockpointer]=b;arch.fileread;[string.psource]=b;[string.ptarget]=a;string.t2s;b<-heap.alloc:7fh;c=32;d=b;"f"[d_32]=c;+c;+d;?c<7fh>f;"w"d=[a];+a;?d=0>y;?d<32>w;?d>7eh>w;e=b;e+d;[e]=33;^w;"y"b+32;"v"conout.say:b;bye;

Nessun commento, legge solo la fonte compilata in binario. Salva come a.txto non verrà compilato!

Brainfuck, 133 123 114 110 byte

++++++++++++++++[->++++++>++>+++>++++>++<<<<<]>-->>->->+[---<.+.+<.+<.+<.+.+.+>>>>]++[-<.+.+.+<.+>>]<+.<+.<++.

Un po 'più di armeggiamento con una soluzione precedente (prima di rendermi conto che il seguito era più piccolo, anche se questo era prima che facessi qualche pesante ottimizzazione). Funziona memorizzando 4 serie di numeri ASCII e stampandoli con alcuni loop complicati, quindi restituendo successivamente i caratteri mancanti (ovvero quelli che si trovano tra numeri ASCII non validi).

Presentazione originale

>>+++++++++++[<+<+>>->++>+++<<]<++>>++++++>>+++++[-<<<++++++>>>]<<<+<<[->>+.<<]>>++.++<[->+.<]>++.+>[-<+.>]<++.+>>[-<<+.>>]

Fa quanto segue:

• Crea 4 registri contenenti 11. 13, 28, 33
• Creare un quinto con il valore 31 per iniziare la stampa
• Stampa ascii 32-42 (11)
• Stampa ascii 44
• Stampa ascii 47-59 (13)
• Stampa ascii 61
• Stampa ascii 63-90 (28)
• Stampa ascii 92
• Stampa ascii 94-126 (33)

Haskell (70)

import Data.List
main=putStrLn$[' '..'~']\\" \\\"$'.=DLS[]aimnoprstu~"

La noiosa soluzione duplicata-caratteri-in-programma-in-una-stringa, sottrai-da-insieme universale. Lungi dall'essere un vincitore del codegolf, anche se è sorprendentemente leggibile per la sua lunghezza.

(Ora con la sottrazione dell'elenco anziché filter/ notWith.)

J - 21

(u:32+i.97)-.1!:1<":5

scrivere questo in un file chiamato 5nella directory corrente. Quindi carica esegui lo script con0!:1<'5'

O 25 senza il trucco dei file:

(-.~".)'(":u:32+i.0-~95)'

Clojure (142, 106, 103)

(defn -main[](let[c"(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]((load-string c)c)))

formattato:

(defn -main []
  (let [c "(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]
    ((load-string c) c)))

Pensa che lo faccia, potrebbe aver bisogno di alcune modifiche. produzione:

#{@ ` ! A B b # C $ D % E & F ' G H I * J + K k , L M . N / O 0 P Q q R S 4 T 5 U V v 7 W w 8 X x 9 Y y : Z z { < | = } > ^ ? _}

esegue la stringa, che è un codice clojure valutabile, su se stessa. String ha alcuni commenti alla fine per ottenere i caratteri utilizzati al di fuori della stringa (metodo principale, ecc.)

Python 2, 69

for x in range(38):print chr(x+59)#!"$%&'*,-./012467bdjklmqsuvwyz{|}~

Uso la sequenza più lunga (che sono in grado di trovare) di caratteri continui che posso stampare e aggiungere gli altri come commento dopo il codice.