En particulier, utilisez chacun de ces symboles au moins une fois dans votre code source:

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

Les symboles à l'intérieur des commentaires, des littéraux de chaîne, des expressions régulières (ou tout autre type de littéral, etc.) ne comptent pas (mais leurs délimiteurs tels que /**/ou ""comptent).

Le programme ne doit effectuer aucune action. Il suffit de compiler et de ne rien faire lors de son exécution.

Si, pour une raison quelconque, certains symboles ne peuvent pas être utilisés dans la langue de votre choix, expliquez-le rigoureusement (ce qui et pourquoi doivent être exclus).

Mise à jour: quelques réponses utilisaient des symboles contenant des expressions régulières. Je considérerais cela un peu problématique, c'est la même chose que de les mettre dans des chaînes de caractères ou des commentaires (c'est pourquoi je mets etc. dans cette exigence). Veuillez essayer sans cela. J'ai également mis à jour l'exigence ci-dessus.

Mise à jour: gain de code le plus court (étiqueté comme code-golf ). Comme suggéré, nous aurons probablement besoin de quelques critères de départage. Je suggère que s'il y a égalité, celle gagnante est celle dans laquelle les symboles ASCII apparaissent le plus ordonnés possible. Formellement: filtrer la première occurrence de chacun des symboles répertoriés d'un programme. Cela se traduira par une permutation sur les symboles répertoriés. Le programme avec moins de nombre d'inversion de sa permutation gagne.

Mise à jour: je serais heureux de voir des solutions / plus dans les langages ordinaires / traditionnels, tels que C (++), Java, Scala, Haskell, etc.

Brainf * ck, 32 caractères

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

Imprime un visage souriant (si votre console peut afficher le symbole ASCII 1)

Oui, une solution Branf * ck qui bat Golfscript! : P

Si vous n'insistez sur aucune sortie, échangez simplement le +et .:

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

Perl, 32 caractères

pas de masquage de symboles dans les commentaires, les littéraux de chaîne ou les expressions régulières. utilise tous les symboles avec précision une seule fois.

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

La description

j'ai essayé d'indiquer la priorité de l'opérateur avec une indentation: les expressions les plus à droite sont évaluées avant celles à leur gauche

        $`            # 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 #

Espace, 32

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

tous les caractères non blancs sont ignorés, donc c'est en fait un programme vide

Python 65

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

J'ai utilisé les caractères ?et à l' $intérieur d'un littéral de chaîne. Ces caractères ne sont pas autorisés en dehors des littéraux de chaîne ou des commentaires.

PHP, 32 caractères

Probablement un peu troll, ce programme PHP est également un QUINE , et utilise tous les symboles dans l'ordre exact où ils sont répertoriés.

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

Exécutée à partir de la ligne de commande, la sortie sera simplement le contenu du fichier, car il n'y a pas <?phpd'invoquer l'interpréteur.

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

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

Perl 6 (43 caractères)

Définissons un opérateur infixe avec un nom assez inhabituel:

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

Ce n'est ni un littéral ni un littéral dans une RE ou quoi que ce soit caché dans un commentaire. Tu ne me crois pas? L'exécution du programme suivant produira "2":

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

Mais je suis tout à fait sûr que vous, les imbéciles, élargirez encore les règles pour exclure la redéfinition du langage lui-même afin de nous rendre mécontents. :(

Haskell, 53

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

Nous pouvons faire un peu plus court

45

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

Toutefois , ce programme ne se termine pas, et utilise plus de caractères ( '!', '<', '|') dans le infix nouvellement défini.

k (33 caractères)

Très facile en k. Malheureusement, "doit être jumelé.

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

GolfScript (33 caractères)

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

"doit être jumelé. Il a fallu un peu d'essais et d'erreurs pour qu'il ne produise rien - la plupart des autres positions du :'résultat dans une sortie.

J, 33 caractères

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

' doit être doublé pour éviter les erreurs de syntaxe.

Ma première réponse manquait de symboles.

C, 48 caractères

Type de tricherie.

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

Postscript - 32 caractères

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

Il en résulte un objet sur la pile, mais n'a aucun autre effet. Postscript autorise presque tous les caractères dans un identifiant, à l'exception de ceux <>()[]{}/qui sont des formes syntaxiques spéciales et %qui introduisent un commentaire. Le programme est symbolisé comme

{                  % 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 caractères)

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

Pour autant que je sache, le caractère $ n'est pas un caractère valide en dehors des littéraux de chaîne, donc je ne l'ai pas utilisé dans ma réponse.

EDIT : Merci à Peter Taylor , j'ai raccourci le code.

PowerShell (52 caractères)

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

J'ai dû mettre le caractère ^ comme une chaîne littérale parce que pour autant que je sache, le caractère ^ n'est pas un caractère PowerShell légal en dehors des littéraux de chaîne. Corrigez-moi si je me trompe.

Le seul moyen que j'ai trouvé pour tenir dans le caractère : est d'utiliser l' opérateur :: pour appeler une méthode statique.

Schéma, 41 caractères

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

Cela profite de l'incroyable tolérance de Scheme pour les caractères dans les noms de variables. Dans ce programme, je crée une variable avec le nom! $% & * +, -. /: <=>? @ [] ^ _ `{|} ~ Que Scheme accepte avec plaisir.

Tcl 37 caractères

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

Définit une variable !#$%&'()*+,-./:<=>?@[]^\_`|~avec une chaîne vide

C: 83 56 caractères

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

Les signes at et les astuces ne font pas partie de la syntaxe C autorisée, je les ai donc mis entre guillemets.

Lisp commun, 33 caractères

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

La partie principale de ce qui précède évalue (ou plutôt, évaluerait sinon pour l' #+()avant) au symbole nommé:

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

Il #+()s'agit d'éviter la sortie. Je ne sais pas si la |foo|syntaxe des symboles compte comme un littéral, mais les symboles sont utilisés comme noms de variable / fonction dans Common Lisp, et il y a déjà quelques réponses utilisant les caractères nécessaires dans ceux-ci.

Smalltalk (dialecte Squeak 4.x) 38 caractères

Implémentez cette méthode dans Object, la syntaxe est valide si les préférences autorisent l'affectation de soulignement (qui est le paramètre par défaut)

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

déclarer Z comme var globale dans le menu local s'il est interactif

Explications:

• % & * + / <=>? @! ~ est un sélecteur binaire (un opérateur)
• y est le paramètre (l'opérande)
• "" est un commentaire vide
• ^ signifie retour
• Z est une variable globale
• _ est une mission
• () délimite une sous-expression
• [: z |] délimite un bloc de code avec un paramètre z
• {} délimite un tableau
• # '' est un littéral de symbole composé d'une chaîne vide (premier élément du tableau)
• , est un message binaire envoyé au symbole ci-dessus
• $ `est un littéral de caractère utilisé comme argument du message ci-dessus
• ; sert à enchaîner un deuxième message envoyé au même récepteur de symboles # ''
• le deuxième message est -
• y est utilisé comme deuxième argument de message
• . est pour séparer la prochaine instruction (ici c'est une dernière période)

Merde, qui a dit que Smalltalk était lisible?

Notez que je n'ai pas triché, le seul caractère non valide `est mis dans un caractère littéral. EDIT voir ci-dessous, c'était une fausse affirmation (au moins dans Squeak)

Mais nous pouvons descendre à 34 caractères avec cette astuce

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

Cette fois:

• # () délimite un tableau littéral
• qui contient 4 symboles littéraux: _; `et 1 caractère littéral $ '

À strictement parler, nous pouvons considérer cela comme de la triche ... Ce n'est pas une chaîne littérale, mais c'est toujours un littéral non vide ...

Je dois encore doubler la citation de commentaire "" (sauf si je crée un caractère littéral avec lui $ ", mais je dois ensuite doubler la citation de chaîne '')
Je dois encore utiliser une lettre pour le paramètre (_ n'est pas accepté même si nous définissons les préférences permettent de souligner dans le sélecteur sur true).

Ce qui est bien, c'est que nous pouvons même exécuter la méthode, par exemple envoyer le message à 1 avec l'argument 2:

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

EDIT Enfin en 35 caractères sans tricher

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

Remarques:

• Les préférences permettent le soulignement dans le sélecteur activation du à l'aide d'un paramètre de bloc nommé x_
• `est un caractère valide pour le sélecteur binaire contrairement à ce que j'ai dit
• J'utilise également $ 'pour éviter de doubler un devis

R: 108 caractères

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){`~`<-`?`}#

Clairement la soumission la plus longue, mais pour pouvoir utiliser des symboles @et $dans R, nous devons créer un objet qui a des emplacements (indexés en utilisant @) et des éléments nommés (indexés en utilisant $).
La solution la plus courte à laquelle j'ai pu penser a été de créer une nouvelle classe d'objet ( a=new(setClass("a",representation(b="list")))), ce qui fait des ravages. Sinon, mis à part les classiques qui n'ont pas besoin d'explications (comme !=, #ou 1:2),

`~`<-`?` 

crée un nouvel opérateur qui fait la même chose que l'opérateur ?(c'est-à-dire qu'il appelle la page d'aide de l'élément qu'il précède).

%*%calcule le produit interne de deux matrices (ici de 1^1et .1).
Le symbole _ne fait rien (AFAIK) dans R mais est couramment utilisé dans les noms de variables ou de fonctions, comme c'est le cas ici.

TI-Basic, 36

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