In particolare, utilizzare ciascuno di questi simboli almeno una volta nel codice sorgente:

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

I simboli all'interno di commenti, valori letterali a stringa, regexps (o qualsiasi altro tipo di valore letterale ecc.) Non contano (ma i loro delimitatori come /**/o ""contano).

Il programma non dovrebbe eseguire alcuna azione. Deve solo compilare e non fare nulla quando eseguito.

Se per qualche motivo alcuni dei simboli non possono essere utilizzati nella lingua di tua scelta, spiegalo rigorosamente (cosa e perché devono essere esclusi).

Aggiornamento: alcune risposte hanno usato simboli con espressioni regolari. Lo considererei un po 'problematico, è la stessa cosa che inserirli in valori letterali o commenti di stringhe (è per questo che ho inserito ecc. In tale requisito). Per favore, prova senza questo. Ho anche aggiornato il requisito sopra.

Aggiornamento: il codice più corto vince (etichettato come code-golf ). Come suggerito, molto probabilmente avremo bisogno di alcuni criteri di tie-breaker. Suggerisco che se c'è un pareggio, quello vincente è quello in cui i simboli ASCII appaiono il più ordinati possibile. Formalmente: filtra la prima occorrenza di ciascuno dei simboli elencati da un programma. Ciò comporterà una permutazione sui simboli elencati. Vince il programma con meno numero di inversione della sua permutazione.

Aggiornamento: sarei felice di vedere alcune / più soluzioni in linguaggi normali / tradizionali, come C (++), Java, Scala, Haskell, ecc.

Brainf * ck, 32 caratteri

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

Stampa una faccina (se la tua console può generare il simbolo ASCII 1)

Yay, una soluzione Branf * ck che batte Golfscript! : P

Se insisti su nessun output, scambia semplicemente +e .:

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

Perl, 32 caratteri

nessun simbolo nascosto nei commenti, nei letterali di stringa o nelle espressioni regolari. usa tutti i simboli esattamente una volta.

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

Descrizione

ho cercato di indicare la precedenza dell'operatore con rientro: le espressioni più a destra vengono valutate prima di quelle alla loro sinistra

        $`            # scalar variable $ named `
      <               # numeric less-than inequality <
        @"            # array variable @ named "
                      #   (array evaluated in scalar context)
    ^                 # bitwise XOR ^
        [(\{_},)]     # array reference [] 
                      #   containing array () 
                      #     containing reference \
                      #       to anonymous hash reference {}
                      #         with one key "_" 
                      #           and no value (nothing following comma ,)
                      #             (reference evaluated in scalar context)
      /               # numeric division /
        +-~%'         # unary addition +
                      #   and unary negation -
                      #     and bitwise complement ~
                      #       on hash variable % named '
                      #         (hash evaluated in scalar context)
  ?                   # ternary conditional operator ?:
    &|                # code reference variable & named |
  :                   # ternary conditional operator ?:
    ! *.              # logical negation !
                      #   on typeglob variable * named .
                      #     (typeglob evaluated in scalar context)
  =>                  # fat comma => for compound expression
                      #   (evaluates LHS as string, RHS is empty)
;                     # end of expression ;
#                     # start of comment #

Spazio bianco, 32

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

tutti i caratteri non bianchi vengono ignorati, quindi in realtà si tratta di un programma vuoto

Python 65

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

Ho usato i personaggi ?e $dentro una stringa letterale. Questi caratteri non sono legali al di fuori dei valori letterali o dei commenti delle stringhe.

PHP, 32 caratteri

Probabilmente un po 'un troll, questo programma PHP è anche un QUINE e usa tutti i simboli nell'ordine esatto in cui sono elencati.

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

Eseguito dalla riga di comando, l'output sarà semplicemente il contenuto del file, poiché non è <?phpnecessario invocare l'interprete.

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

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

Perl 6 (43 caratteri)

Definiamo un operatore infix con un nome piuttosto insolito:

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

Non è un letterale né un letterale in una RE o qualcosa di nascosto in un commento. Non mi credi? L'esecuzione del seguente programma produrrà "2":

sub infix:<!"#$%&'()*+,-./:;=?@[]^_´\|~>($a, $b){ $a + $b }
say 1 !"#$%&'()*+,-./:;=?@[]^_´\|~ 1;

Ma sono abbastanza sicuro che i nitpicker estenderanno ulteriormente le regole per escludere la ridefinizione della lingua stessa per renderci infelici perl. :(

Haskell, 53

a@""#%&*+/?^b|a'<-a!!0=(\_->a`b`[]);main=do{print$1}

Possiamo renderlo un po 'più breve

45

a'@""#%&*+/?!<|^b=(\_->1`b`[]);main=do{main}

tuttavia questo programma non termina, e gli usi più caratteri ( '!', '<', '|') nel infisso appena definito.

k (33 caratteri)

Molto facile in k. Purtroppo "deve essere accoppiato.

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

GolfScript (33 caratteri)

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

"deve essere associato. Ci sono voluti un po 'di tentativi ed errori per non produrre nulla - la maggior parte delle altre posizioni del :'risultato in qualche output.

J, 33 caratteri

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

' deve essere raddoppiato per evitare errori di sintassi.

Alla mia prima risposta mancavano alcuni simboli.

C, 48 caratteri

Tipo di imbroglio.

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

Postscript - 32 caratteri

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

Risultati in un oggetto nello stack, ma per il resto non ha effetti. Postscript consente quasi tutti i caratteri in un identificatore ad eccezione dei <>()[]{}/quali sono speciali moduli di sintassi e %che introducono un commento. Il programma è tokenizzato come

{                  % start a procedure object
!"#$&'             % an identifier
()                 % an empty string
*+,-.              % an identifier
/:;=               % a symbol
<>                 % an empty hex string
?@                 % an identifier
[\]                % an array
^_`~|              % an identifier
}                  % close the procedure object
%                  % a comment

C # (91 caratteri)

#define a 
class a{static int @Main(){return(char)1.1*""[0]/1%1-1+1!=1?1:~1^1>>1<<1&1+'\0';}}

Per quanto ne so, il carattere $ non è un carattere valido al di fuori dei letterali di stringa, quindi non l'ho usato nella mia risposta.

EDIT : Grazie a Peter Taylor , ho abbreviato il codice.

PowerShell (52 caratteri)

$_+=(@(1.1,1)[0]-1)*1/1%'1'::ToInt|&{!"">~\1}<#^#>`;

Ho dovuto mettere il carattere ^ come una stringa letterale perché, per quanto ne so, il ^ carattere non è un carattere PowerShell legale al di fuori dei letterali stringa. Correggimi se sbaglio.

L'unico modo per trovare il carattere : è usare l' operatore :: per effettuare una chiamata a un metodo statico.

Schema, 41 caratteri

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

Questo sfrutta l'incredibile tolleranza di Scheme per i personaggi con nomi di variabili. In questo programma creo una variabile con il nome! $% & * +, -. /: <=>? @ [] ^ _ `{|} ~ Che Scheme accetta felicemente.

Tcl 37 caratteri

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

Definisce una variabile !#$%&'()*+,-./:<=>?@[]^\_`|~con una stringa vuota

C: 83 56 caratteri

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

I segni di at e backtick non fanno parte della sintassi C consentita, quindi li ho inseriti tra virgolette.

Lisp comune, 33 caratteri

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

La parte principale di quanto sopra valuta (o meglio, valuterebbe se non fosse per il #+() fronte) al simbolo chiamato:

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

È #+()evitare l'output. Non sono sicuro che la |foo|sintassi dei simboli sia considerata letterale, ma i simboli sono usati come nomi di variabili / funzioni in Common Lisp, e ci sono già alcune risposte che usano i caratteri necessari in quelli.

Smalltalk (dialetto Squeak 4.x) 38 caratteri

Implementare questo metodo in Oggetto, la sintassi è valida se Preferenze Consenti assegnazione di trattino basso (che è l'impostazione predefinita)

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

dichiarare Z come var globale nel menu a comparsa se interattivo

spiegazioni:

• % & * + / <=>? @! ~ è un selettore binario (un operatore)
• y è il parametro (l'operando)
• "" è un commento vuoto
• ^ significa ritorno
• Z è una variabile globale
• _ è un compito
• () delimita una sottoespressione
• [: z |] delimita un blocco di codice con un parametro z
• {} delimita un array
• # '' è un simbolo letterale costituito da una stringa vuota (primo elemento dell'array)
• , è un messaggio binario inviato al simbolo sopra
• $ `è un carattere letterale usato come argomento del messaggio precedente
• ; serve per concatenare un secondo messaggio inviato allo stesso Symbol symbol # ''
• il secondo messaggio è -
• y è usato come secondo argomento del messaggio
• . serve per separare la prossima istruzione (qui è un periodo finale)

Accidenti, chi ha detto che Smalltalk è leggibile?

Nota che non ho imbrogliato, l'unico personaggio non valido `è messo in un personaggio letterale. EDIT vedi sotto, questa era una falsa affermazione (almeno in Squeak)

Ma possiamo arrivare a 34 caratteri con questo trucco

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

Questa volta:

• # () delimita una matrice letterale
• che contiene 4 simboli letterali: _; `e 1 carattere letterale $ '

A rigor di termini, possiamo considerare questo come un imbroglio ... Non è una stringa letterale, ma è ancora un letterale non vuoto ...

Devo ancora raddoppiare la citazione del commento "" (a meno che non crei un carattere letterale con esso $ ", ma poi devo raddoppiare la citazione della stringa '')
Devo ancora usare una lettera per il parametro (_ non è accettato anche se impostiamo Preferenze per consentire la sottolineatura nel selettore su true).

La cosa bella è che possiamo persino eseguire il metodo, ad esempio inviare il messaggio a 1 con l'argomento 2:

1%&*+,-/<=>?@\!~|2

EDIT Finalmente in 35 caratteri senza barare

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

Appunti:

• Le preferenze consentono il trattino basso nell'abilitazione del selettore usando un parametro di blocco chiamato x_
• `è un carattere valido per il selettore binario contrariamente a quanto ho detto
• Uso anche $ 'per evitare di raddoppiare un preventivo

R: 108 caratteri

a=new(setClass("a",representation(b="list")));a@b=list(c_d=1:2);if(1!='\t'&.1%*%1^1>a@b$c[1]/1|F){`~`<-`?`}#

Chiaramente l'invio più lungo, ma per poter usare i simboli @e $in R, dobbiamo creare un oggetto che abbia degli slot (indicizzati usando @) e degli elementi nominati (indicizzati usando $).
La soluzione più breve che mi è venuta in mente è stata quella di creare una nuova classe di oggetto ( a=new(setClass("a",representation(b="list")))), che prende il suo pedaggio. Altrimenti, a parte i classici che non hanno bisogno di spiegazioni (come !=, #o 1:2),

`~`<-`?` 

crea un nuovo operatore che fa lo stesso dell'operatore ?(ovvero chiama la pagina di aiuto dell'elemento che precede).

%*%calcola il prodotto interno di due matrici (qui di 1^1e .1).
Il simbolo _non fa nulla (AFAIK) in R ma viene usato abitualmente nei nomi di variabili o funzioni, come nel caso di questo caso.

TI-Basic, 36

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