Em particular, use cada um destes símbolos pelo menos uma vez no seu código-fonte:

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

Símbolos dentro de comentários, cadeias literais, regexps (ou qualquer outro tipo de literal etc.) não contam (mas seus delimitadores, como /**/ou ""contam).

O programa não deve executar nenhuma ação. Ele só precisa compilar e não fazer nada quando executado.

Se, por algum motivo, alguns dos símbolos não puderem ser usados ​​no idioma de sua escolha, explique-o rigorosamente (o que e por que deve ser excluído).

Atualização: algumas respostas usavam símbolos dentro de expressões regulares. Eu consideraria isso um pouco problemático, é a mesma coisa que colocá-los em literais de string ou comentários (é por isso que coloquei etc. nesse requisito). Por favor, tente sem isso. Também atualizei o requisito acima.

Atualização: o código mais curto vence (marcado como código-golfe ). Como sugerido, provavelmente precisaremos de alguns critérios de desempate. Sugiro que, se houver um empate, o vencedor é aquele em que os símbolos ASCII aparecem o mais ordenados possível. Formalmente: filtre a primeira ocorrência de cada um dos símbolos listados em um programa. Isso resultará em uma permutação nos símbolos listados. O programa com menor número de inversões de sua permutação vence.

Atualização: ficaria feliz em ver algumas / mais soluções em linguagens regulares / comuns, como C (++), Java, Scala, Haskell, etc.

Brainf * ck, 32 caracteres

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

Imprime um rosto sorridente (se o console puder gerar o símbolo ASCII 1)

Sim, uma solução Branf * ck que supera o Golfscript! : P

Se você insistir em nenhuma saída, basta trocar o +e .:

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

Perl, 32 caracteres

sem símbolos ocultos em comentários, literais de sequência ou expressões regulares. usa todos os símbolos precisamente uma vez.

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

Descrição

Eu tentei indicar precedência do operador com recuo: as expressões mais à direita são avaliadas antes daquelas à sua esquerda

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

Espaço em branco, 32

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

todos os caracteres que não são de espaço em branco são ignorados, então esse é realmente um programa vazio

Python 65

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

Eu usei os caracteres ?e $dentro de uma string literal. Esses caracteres não são válidos fora de literais ou comentários de string.

PHP, 32 caracteres

Provavelmente um pouco troll, este programa PHP também é um QUINE , e usa todos os símbolos na ordem exata em que estão listados.

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

Executado a partir da linha de comando, a saída será simplesmente o conteúdo do arquivo, pois não há <?phpcomo chamar o intérprete.

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

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

Perl 6 (43 caracteres)

Vamos definir um operador infix com um nome bastante incomum:

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

Não é literal nem literal em um ER ou qualquer coisa oculta em um comentário. Você não acredita em mim? A execução do seguinte programa produzirá "2":

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

Mas tenho certeza de que você vai estender ainda mais as regras para excluir a redefinição da própria linguagem, para nos tornar infelizes para os pervertidos. :(

Haskell, 53

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

Podemos tornar isso um pouco mais curto

45

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

no entanto, este programa não termina, e as utilizações mais caracteres ( '!', '<', '|') na infixa recém-definido.

k (33 caracteres)

Muito fácil em k. Infelizmente "deve ser emparelhado.

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

GolfScript (33 caracteres)

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

"tem que ser emparelhado. Foram necessárias algumas tentativas e erros para não produzir nada - a maioria das outras posições do :'resultado em alguma saída.

J, 33 caracteres

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

' precisa ser dobrado para evitar erros de sintaxe.

Minha primeira resposta estava faltando alguns símbolos.

C, 48 caracteres

Tipo de trapaça.

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

Postscript - 32 caracteres

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

Resulta em um objeto na pilha, mas, caso contrário, não tem efeitos. O Postscript permite quase qualquer caractere em um identificador, exceto pelos <>()[]{}/formulários especiais de sintaxe e %que introduzem um comentário. O programa é tokenizado como

{                  % 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 caracteres)

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

Até onde eu sei, o caractere $ não é um caractere válido fora dos literais da string, portanto não o usei na minha resposta.

EDIT : Graças a Peter Taylor , reduzi o código.

PowerShell (52 caracteres)

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

Eu tive que colocar o caractere ^ como uma string literal, porque, até onde eu sei, o caractere ^ não é um caractere legal do PowerShell fora dos literais da string. Corrija-me se eu estiver errada.

A única maneira que encontrei para caber no caractere : é usar o operador :: para fazer uma chamada para um método estático.

Esquema, 41 caracteres

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

Isso tira proveito da incrível tolerância do Scheme para caracteres em nomes de variáveis. Neste programa, crio uma variável com o nome! $% & * +, -. /: <=>? @ [] ^ _ `{|} ~ Que Scheme aceita alegremente.

Tcl 37 chars

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

Define uma variável !#$%&'()*+,-./:<=>?@[]^\_`|~com uma sequência vazia

C: 83 56 caracteres

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

Os sinais de arroba e as reticências não fazem parte da sintaxe C permitida, então eu os coloquei entre aspas.

Lisp comum, 33 caracteres

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

A parte principal do item acima avalia (ou melhor, avaliaria se não fosse o que está #+()na frente dele) com o símbolo chamado:

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

O #+()é para evitar a saída. Não tenho certeza se a |foo|sintaxe dos símbolos conta como literal, mas os símbolos são usados ​​como nomes de variáveis ​​/ funções no Common Lisp, e já existem algumas respostas usando os caracteres necessários.

Smalltalk (Squeak 4.x dialeto) 38 caracteres

Implemente esse método em Object, a sintaxe será válida se Preferências permitir atribuição de sublinhado (que é a configuração padrão)

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

declare Z como var global no menu pop-up se interativo

Explicações:

• % & * + / <=>? @! ~ é um seletor binário (um operador)
• y é o parâmetro (o operando)
• "" é um comentário vazio
• ^ significa retorno
• Z é uma variável global
• _ é uma tarefa
• () delimita uma subexpressão
• [: z |] delimita um bloco de código com um parâmetro z
• {} delimita uma matriz
• # '' é um literal de símbolo feito de uma string vazia (primeiro elemento da matriz)
• , é uma mensagem binária enviada para o símbolo acima
• $ `é um literal de caractere usado como argumento da mensagem acima
• ; é para encadear uma segunda mensagem enviada para o mesmo receptor de símbolo # ''
• a segunda mensagem é -
• y é usado como o argumento da segunda mensagem
• . é para separar a próxima instrução (aqui é um período final)

Porra, quem disse que Smalltalk era legível?

Note que eu não trapaceie, o único caractere não válido `é colocado em um caractere literal. EDIT veja abaixo, esta foi uma afirmação falsa (pelo menos no Squeak)

Mas podemos reduzir para 34 caracteres com esse truque

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

Desta vez:

• # () delimita uma matriz literal
• que contém 4 símbolos literais: _; `e 1 caractere literal $ '

A rigor, podemos considerar isso como trapaça ... Não é uma String literal, mas ainda é uma literal não vazia ...

Ainda tenho que dobrar a citação de comentário "" (a menos que eu faça um caractere literal com $ ", mas preciso dobrar a citação de String '')
. Ainda preciso usar uma letra para o parâmetro (_ não é aceito, mesmo que definimos Preferências para permitir sublinhado no seletor como true).

O bom é que podemos até executar o método, por exemplo, envie a mensagem para 1 com o argumento 2:

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

EDIT Finalmente em 35 caracteres sem fazer batota

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

Notas:

• As preferências permitem sublinhado na ativação do seletor usando um parâmetro de bloco chamado x_
• `é um caractere válido para o seletor binário, ao contrário do que eu disse
• Também uso $ 'para evitar duplicar uma cotação

R: 108 caracteres

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

Claramente, o envio mais longo, mas para poder usar símbolos @e $em R, precisamos criar um objeto que tenha slots (indexados usando @) e elementos nomeados (indexados usando $).
A solução mais curta que pude pensar foi criar uma nova classe de object ( a=new(setClass("a",representation(b="list")))), que cobra seu preço. Caso contrário, separe dos clássicos que não precisam de explicações (como !=, #ou 1:2),

`~`<-`?` 

cria um novo operador que faz o mesmo que o operador ?(ou seja, chama a página de ajuda do elemento que antecede).

%*%calcula o produto interno de duas matrizes (aqui de 1^1e .1).
O símbolo _não faz nada (AFAIK) em R, mas é usado rotineiramente em nomes de variáveis ​​ou funções, como é o caso aqui.

TI-Basic, 36

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