Özellikle, bu sembollerin her birini kaynak kodunuzda en az bir kez kullanın:

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

Yorumların içindeki simgeler, dize değişmez değerleri, normal ifadeler (veya başka tür değişmez değerler vb.) Sayılmaz (ancak bunların ayırıcıları /**/ veya"" ).

Program herhangi bir işlem yapmamalıdır. Sadece koşmak derlemek ve hiçbir şey yapmak zorunda.

Herhangi bir nedenle bazı semboller seçtiğiniz dilde kullanılamıyorsa, bunu titizlikle açıklayın (neyin ve niçin hariç tutulması gerekir).

Güncelleme: Birkaç cevap, düzenli ifadelere sahip semboller kullandı. Bunu biraz sorunlu olarak değerlendiririm, bunları dize değişmezlerine veya yorumlarına koymakla aynı şeydir (bu yüzden bu gereksinime vb . Koydum). Lütfen bu olmadan deneyin. Yukarıdaki gereksinimi de güncelledim.

Güncelleme: En kısa kod kazanır ( code-golf olarak etiketlenir ). Önerildiği gibi, büyük olasılıkla bazı kravat kırıcı kriterlerine ihtiyacımız olacak. Beraberlik olursa, kazanan olanın ASCII sembollerinin mümkün olduğunca düzenli göründüğünü öneririm. Resmi olarak: Listelenen sembollerin her birinin ilk oluşumunu bir programdan filtreleyin. Bu, listelenen sembollerde permütasyona neden olacaktır. Daha az programPermütasyon oranının ters çevrildiği kazanır.

Güncelleme: C (++), Java, Scala, Haskell, vb.Gibi normal / ana dilde bazı / daha fazla çözüm görmekten memnuniyet duyarım.

Brainf * ck, 32 karakter

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

Gülen bir yüz yazdırır (konsolunuz ASCII sembolü 1 çıktısı alabiliyorsa)

Yay, Golfscript'i yenen bir Branf * ck çözümü! : P

Çıktı olmaması konusunda ısrar ediyorsanız +ve öğesini değiştirin .:

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

Perl, 32 karakter

yorumlarda, dizgi değişmezlerinde veya normal ifadelerde gizleme simgesi yok. tüm sembolleri tam olarak bir kez kullanır.

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

Açıklama

girinti ile operatörün önceliğini göstermeye çalıştım: en sağdaki ifadeler sollarındakilerden önce değerlendirilir

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

Boşluk, 32

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

boşluk olmayan tüm karakterler yok sayılır, dolayısıyla bu aslında boş bir programdır

Python 65

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

Karakterleri kullandım ?ve $bir dize değişmezinin içinde. Bu karakterler dize değişmezleri veya yorumları dışında yasal değildir .

PHP, 32 karakter

Muhtemelen bir trol biraz, bu PHP programı da bir QUINE ve tüm simgeleri tam olarak listelendikleri sırayla kullanır.

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

Komut satırından <?phpyürütüldüğünde, yorumlayıcıyı çağırmaya gerek olmadığından çıktı yalnızca dosyanın içeriği olacaktır .

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

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

Perl 6 (43 chars)

Let's define a infix operator with a rather unusual name:

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

It's not a literal nor a literal in a RE or anything hidden in a comment. You don't believe me? Running the following program will output "2":

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

Ama eminim nitpickers, bizi perl yağlayıcılarını mutsuz etmek için dilin yeniden tanımlanmasını dışlamak için kuralları daha da genişletecektir. :(

Haskell, 53

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

Bunu biraz daha kısaltabiliriz

45

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

Bununla birlikte, bu program, sona erdirme ve kullanımları daha fazla karakter (değildir '!', '<', '|') yeniden tanımlanmış Infix içinde.

k (33 karakter)

Very easy in k. Unfortunately " must be paired.

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

GolfScript (33 chars)

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

" has to be paired. It took a bit of trial and error to get it to output nothing - most other positions of the :' result in some output.

J, 33 characters

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

' needs to be doubled to avoid syntax errors.

My first answer was missing some symbols.

C, 48 chars

Kind of cheating.

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

Postscript - 32 chars

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

Results in an object on the stack, but otherwise has no effects. Postscript allows almost any char in an identifier except for <>()[]{}/ which are special syntax forms and % which introduces a comment. The program is tokenized as

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

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

As far as I know, The $ character is not a valid character outside string literals, so I didn't use it in my answer.

EDIT : Thanks to Peter Taylor, I shortened the code.

PowerShell (52 characters)

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

I had to put the ^ character as a string literal because as far as I know, the ^ character is not a legal PowerShell character outside string literals. Correct me if I am wrong.

The only way I have found to fit in the : character is to use the :: operator to make a call to a static method.

Scheme, 41 characters

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

This takes advantage of Scheme's incredible tolerance for characters in variable names. In this program I create a variable with the name !$%&*+,-./:<=>?@[]^_`{|}~ which Scheme happily accepts.

Tcl 37 chars

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

Defines a variable !#$%&'()*+,-./:<=>?@[]^\_`|~ with an empty string

C: 83 56 characters

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

At-signs and backticks are not a part of the allowed C-syntax, so I have put them between quotation marks.

Common Lisp, 33 characters

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

The main part of the above evaluates (or rather, would evaluate if not for the #+() in front of it) to the symbol named:

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

The #+() is to avoid output. I'm not sure if the |foo| syntax for symbols counts as a literal, but symbols are used as variable/function names in Common Lisp, and there are a few answers already using the necessary characters in those.

Smalltalk (Squeak 4.x dialect) 38 chars

Implement this method in Object, the syntax is valid if Preferences Allow underscore assignment (which is the default setting)

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

declare Z as global var in pop-up menu if interactive

Explanations:

• %&*+/<=>?@!~ is a binary selector (an operator)
• y is the parameter (the operand)
• "" is an empty comment
• ^ means return
• Z is a global variable
• _ is an assignment
• () delimits a sub-expression
• [:z|] delimits a block of code with one parameter z
• {} delimits an Array
• #'' is a Symbol literal made of an empty String (first element of the Array)
• , is a binary message sent to above Symbol
• $` is a Character literal used as argument of above message
• ; is for chaining a second message sent to the same Symbol receiver #''
• the second message is -
• y is used as the second message argument
• . is for separating next instruction (here it's a final period)

Damn, who said Smalltalk was readable?

Note that I didn't cheat, the only non valid character ` is put into a literal Character. EDIT see below, this was a false assertion (at least in Squeak)

But we can make it down to 34 chars with this trick

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

This time:

• #() delimits a literal Array
• which contains 4 literal Symbols : _ ; ` and 1 literal Character $'

Strictly speaking, we can consider this as cheating... It's not a literal String, but it is still a non empty literal...

I still have to double comment quote "" (unless I make a literal Character with it $", but then I need to double the String quote '')
I still have to use a letter for the parameter (_ is not accepted even if we set Preferences allow underscore in selector to true).

What is nice is that we can even run the method, for example send the message to 1 with argument 2:

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

EDIT Finally in 35 chars without cheating

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

Notes:

• Preferences allow underscore in selector enable using a block parameter named x_
• ` is a valid character for binary selector contrarily to what I said
• I also use $' to avoid doubling a quote

R: 108 characters

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

Clearly the longest submission, but to be able to use symbols @ and $ in R, we need to create an object that has slots (indexed using @) and named elements (indexed using $).
The shortest solution I could think of was to create a new class of object (a=new(setClass("a",representation(b="list")))), which takes its toll. Otherwise, appart from the classics that don't need explanations (such as !=, # or 1:2),

`~`<-`?` 

creates a new operator that does the same as operator ? (i. e. it calls the help page of the element it precedes).

%*% computes the inner product of two matrices (here of 1^1 and .1).
Symbol _ does nothing (AFAIK) in R but is routinely used in variable or function names, as it is the case here.

TI-Basic, 36

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