En particular, use cada uno de estos símbolos al menos una vez en su código fuente:

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

Los símbolos dentro de comentarios, literales de cadena, expresiones regulares (o cualquier otro tipo de literales, etc.) no cuentan (pero sus delimitadores como /**/ o ""sí cuentan).

El programa no debe realizar ninguna acción. Solo tiene que compilar y no hacer nada cuando se ejecuta.

Si por alguna razón algunos de los símbolos no se pueden usar en el idioma de su elección, explíquelos rigurosamente (qué y por qué deben excluirse).

Actualización: algunas respuestas usaron símbolos con expresiones regulares. Consideraría esto un poco problemático, es lo mismo que ponerlos en literales de cadena o comentarios (es por eso que puse etc. en ese requisito). Por favor intente sin esto. También actualicé el requisito anterior.

Actualización: el código más corto gana (etiquetado como code-golf ). Como se sugirió, lo más probable es que necesitemos algunos criterios de desempate. Sugiero que si hay un empate, el ganador es aquel en el que los símbolos ASCII aparecen lo más ordenados posible. Formalmente: filtre la primera aparición de cada uno de los símbolos enumerados de un programa. Esto dará como resultado una permutación en los símbolos enumerados. El programa con menos número de inversión de su permutación gana.

Actualización: me encantaría ver algunas / más soluciones en lenguajes regulares / convencionales, como C (++), Java, Scala, Haskell, etc.

Brainf * ck, 32 caracteres

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

Imprime una cara sonriente (si su consola puede mostrar el símbolo ASCII 1)

¡Sí, una solución Branf * ck que supera a Golfscript! :PAG

Si insiste en que no hay salida, simplemente cambie el +y .:

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

Perl, 32 caracteres

sin símbolos ocultos en comentarios, literales de cadena o expresiones regulares. usa todos los símbolos con precisión una vez.

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

Descripción

He intentado indicar la precedencia del operador con sangría: las expresiones de la derecha se evalúan antes que las de la izquierda

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

Espacio en blanco, 32

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

todos los caracteres que no son espacios en blanco se ignoran, por lo que este es realmente un programa vacío

Python 65

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

Usé los caracteres ?y $dentro de una cadena literal. Estos caracteres no son legales fuera de los literales de cadena o comentarios.

PHP, 32 caracteres

Probablemente un poco troll, este programa PHP también es un QUINE , y utiliza todos los símbolos en el orden exacto en que se enumeran.

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

Ejecutado desde la línea de comando, la salida será simplemente el contenido del archivo, ya que no hay <?phpque invocar al intérprete.

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

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

Perl 6 (43 caracteres)

Definamos un operador infijo con un nombre bastante inusual:

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

No es un literal ni un literal en un RE ni nada oculto en un comentario. ¿No me crees? Ejecutar el siguiente programa generará "2":

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

Pero estoy bastante seguro de que ustedes, nitpickers, extenderán aún más las reglas para excluir la redefinición del lenguaje en sí mismo para hacernos perl lubbers infelices. :(

Haskell, 53

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

Podemos hacer esto un poco más corto

45

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

sin embargo, este programa no finaliza, y utiliza más caracteres ( '!', '<', '|') en el infija recién definida.

k (33 caracteres)

Muy fácil en k. Lamentablemente "debe ser emparejado.

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

GolfScript (33 caracteres)

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

"tiene que ser emparejado Tomó un poco de prueba y error lograr que no produjera nada, la mayoría de las otras posiciones del :'resultado en alguna salida.

J, 33 caracteres

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

' debe duplicarse para evitar errores de sintaxis.

A mi primera respuesta le faltaban algunos símbolos.

C, 48 caracteres

Tipo de trampa.

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

Posdata - 32 caracteres

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

Da como resultado un objeto en la pila, pero por lo demás no tiene efectos. Postscript permite casi cualquier carácter en un identificador, excepto aquellos <>()[]{}/que son formas de sintaxis especiales y %que introduce un comentario. El programa se tokeniza 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';}}

Hasta donde sé, el carácter $ no es un carácter válido fuera de los literales de cadena, por lo que no lo usé en mi respuesta.

EDITAR : Gracias a Peter Taylor , acorté el código.

PowerShell (52 caracteres)

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

Tuve que poner el ^ carácter como un literal de cadena porque, hasta donde yo sé, el carácter ^ no es un carácter legal de PowerShell fuera de los literales de cadena. Corrígeme si estoy equivocado.

La única forma en que he encontrado que cabe en el carácter : es usar el operador :: para hacer una llamada a un método estático.

Esquema, 41 caracteres

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

Esto aprovecha la increíble tolerancia de Scheme para los caracteres en nombres variables. En este programa, creo una variable con el nombre! $% & * +, -. /: <=>? @ [] ^ _ `{|} ~ Que Scheme acepta felizmente.

Tcl 37 caracteres

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

Define una variable !#$%&'()*+,-./:<=>?@[]^\_`|~con una cadena vacía

C: 83 56 caracteres

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

Los signos at y backticks no son parte de la sintaxis C permitida, por lo que los puse entre comillas.

Lisp común, 33 caracteres

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

La parte principal de lo anterior evalúa (o más bien, evaluaría si no fuera por el #+()frente) al símbolo llamado:

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

El #+()es para evitar la salida. No estoy seguro de si la |foo|sintaxis de los símbolos cuenta como un literal, pero los símbolos se usan como nombres de variables / funciones en Common Lisp, y ya hay algunas respuestas que usan los caracteres necesarios en esos.

Smalltalk (Squeak 4.x dialecto) 38 caracteres

Implemente este método en Object, la sintaxis es válida si las Preferencias permiten la asignación de subrayado (que es la configuración predeterminada)

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

declarar Z como var global en el menú emergente si es interactivo

Explicaciones:

• % & * + / <=>? @! ~ es un selector binario (un operador)
• y es el parámetro (el operando)
• "" es un comentario vacío
• ^ significa retorno
• Z es una variable global
• _ es una tarea
• () delimita una subexpresión
• [: z |] delimita un bloque de código con un parámetro z
• {} delimita una matriz
• # '' es un símbolo literal hecho de una cadena vacía (primer elemento de la matriz)
• , es un mensaje binario enviado al símbolo anterior
• $ `es un carácter literal utilizado como argumento del mensaje anterior
• ; es para encadenar un segundo mensaje enviado al mismo receptor de símbolos # ''
• el segundo mensaje es -
• y se usa como el segundo argumento del mensaje
• . es para separar la siguiente instrucción (aquí es un período final)

Maldición, ¿quién dijo que Smalltalk era legible?

Tenga en cuenta que no hice trampa, el único carácter no válido `se pone en un carácter literal. EDITAR ver a continuación, esta fue una afirmación falsa (al menos en Squeak)

Pero podemos reducirlo a 34 caracteres con este truco

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

Esta vez:

• # () delimita una matriz literal
• que contiene 4 símbolos literales: _; `y 1 carácter literal $ '

Hablando estrictamente, podemos considerar esto como trampa ... No es una cadena literal, pero sigue siendo un literal no vacío ...

Todavía tengo que hacer doble comentario entre comillas "" (a menos que haga un carácter literal con $ ", pero luego necesito duplicar la comilla de cadena '')
Todavía tengo que usar una letra para el parámetro (_ no se acepta incluso si establecemos Preferencias permitir subrayado en selector en verdadero).

Lo bueno es que incluso podemos ejecutar el método, por ejemplo, enviar el mensaje a 1 con el argumento 2:

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

EDITAR Finalmente en 35 caracteres sin hacer trampa

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

Notas:

• Las preferencias permiten el subrayado en la habilitación del selector utilizando un parámetro de bloque llamado x_
• `es un carácter válido para el selector binario al contrario de lo que dije
• También uso $ 'para evitar duplicar una cotización

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, el envío más largo, pero para poder usar símbolos @y $en R, necesitamos crear un objeto que tenga ranuras (indexado usando @) y elementos nombrados (indexado usando $).
La solución más corta que se me ocurrió fue crear una nueva clase de objeto ( a=new(setClass("a",representation(b="list")))), que tiene su costo. De lo contrario, aparte de los clásicos que no necesitan explicaciones (como !=, #o 1:2),

`~`<-`?` 

crea un nuevo operador que hace lo mismo que el operador ?(es decir, llama a la página de ayuda del elemento que precede).

%*%calcula el producto interno de dos matrices (aquí de 1^1y .1).
El símbolo _no hace nada (AFAIK) en R, pero se usa habitualmente en nombres de variables o funciones, como es el caso aquí.

TI-Basic, 36

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