Ihre Aufgabe ist es, ein Programm zu erstellen (das nur druckbare ASCII-Zeichen und / oder Tabulatoren und Zeilenumbrüche verwendet), das genau die Zeichen im druckbaren ASCII-Bereich ( 0x20bis 0x7e) ausgibt , die nicht im Quellcode Ihres Programms enthalten sind (in beliebiger Reihenfolge) oft du willst).

Der kürzeste Code, um dies in einer Sprache zu tun, gewinnt.

GolfScript, 15 12 Zeichen

{`),32>^.}.~

Basierend auf Jan Dvoraks Antwort mit ein paar Drehungen und auch im Stil von Peter Taylors .

Polyglot, 95

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

• Perl
• Perl 6
• Jede * nx artigen Schale ( tclsh, bash, sh, kshusw.)
• Awk (GNU / POSIX)
• Brainfuck , Brian & Chuck , andere Derivate
• Rubin
• Coffescript
• Golfscript
• Python
• R
• Julia
• Leerzeichen
• rk
• Gaot ++
• bc
• jq
• Freude
• Tcl
• 99
• V (FMota)
• Acc !!
• C - wenn nein main()benötigt wird. Dank Urogen
• Wahrscheinlich mehr.

Tut nichts.

PHP 5.2, 4

<?<<

Als Datei speichern, die NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.phpirgendwo in aufgerufen wird /home. short_open_tagmuss Onin deinem sein php.ini.

Die Ausgabe ist:

PHP Parse error:  syntax error, unexpected T_SL in /home/wherever/NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.php on line 1

JavaScript - 88

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

druckt "bcdfghijkmnpquvxyz"

Leerzeichen, 61 57 Zeichen

Es ist nicht die kürzeste, aber es hat wahrscheinlich die einfachste Logik (es ist wirklich nur eine Schleife).

Hier ist es vollständig kommentiert, wobei S Leerzeichen ist, T Tabulator ist, L Zeilenvorschub ist:

SSSTSSSSSL     # push 0x20
LSSSL          # label S
SSSTL          # push 1
TSSS           # add
SLS            # duplicate top of stack
SLS            # duplicate again
TLSS           # output ASCII character
SSSTTTTTTSL    # push 0x7E
TSST           # subtract (result - 0x7E)
LTTSL          # branch to label S if top of stack is negative
LLL            # end

Vielen Dank an @res für die Korrektur des oben genannten Problems (zusätzliches Duplikat für die Verzweigungsanweisung erforderlich) und für das Drücken kleinerer Zahlen auf den Stapel.

C 83 74 69 Zeichen

main(z) {for(;++z<96;"\33iE!vk?}GkRP8z"[z/7]&1<<z%7&&putchar(z+32));}

Ich habe wirklich versucht, es unter 80 Zeichen zu bringen, aber ich habe es einfach nicht geschafft. Ich habe mich schließlich entschlossen, das, was ich habe, zu posten, in der Annahme, dass ich (oder jemand anderes) zehn Minuten nach dem Posten eine 79-Zeichen-Lösung herausfinden werde. Okay, es waren keine zehn Minuten, aber im Prinzip hat es funktioniert.

Ich wollte wirklich eine Version veröffentlichen, die keinen freien Platz im Quellcode haben musste, sondern die auf einer seltsamen Attraktor-Umlaufbahn zwischen einer Handvoll Lösungen landete. Nachdem ich viele Minuten lang versucht hatte, einen von ihnen zu einer stabilen Lösung zu bewegen, gab ich auf und fügte den Raum hinzu.

Golfscript, 26 24 Zeichen

"126,32>''+".~\-'.~\-"'-

Nimmt ein Skript zur Bereichsgenerierung, dupliziert es, führt es aus, subtrahiert es von seinem Ergebnis und subtrahiert dann den Ergebnis-Subtraktionscode und das andere Anführungszeichen.

Fisch - 80

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

Bei Fischfehlern wird der Ausdruck "Etwas riecht fischig ..." ausgegeben. Da z eine schlechte Anweisung ist, kommt es sofort zu Fehlern

Ich weiß, dass es keine Wettbewerbe gewinnt. Ich wollte es nur in einer Sprache versuchen, die normalerweise nicht verwendet wird, nur zum Spaß.

Java - 209 195 152 140 Zeichen

class a{public static void main(String[]a){for(char c=0;;c++)System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:}".indexOf(c)<0?c:"");}}

Mit Zeilenumbrüchen und Tabulatoren

class a{
    public static void main(String[]a) {
        for(char c=0;;c++)
            System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"");
    }
}

Achtung, wenn Sie ausführen: Programm wird nicht beendet. Haha

Erläuterung

1. for(char c=0;;c++): Da a charals ein behandelt werden kann int, nutze ich das hier zu meinem Vorteil, um durch alle möglichen Werte von zu inkrementieren c. Ich lasse die Abbruchbedingung in der Schleife (die zwischen den beiden Semikolons steht) aus, um Zeichen zu sparen, da nicht angegeben wurde, dass das Programm abgebrochen werden muss. :)
2. "publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"": Leider kein sehr eleganter Ansatz, aber er erledigt die Arbeit. Listen Sie jedes im Quellcode vorhandene Zeichen manuell als StringLiteral auf und prüfen Sie dann, ob der Strom char cdarin mit vorkommt indexOf(). Wenn der indexOf()Aufruf zurückkommt -1, ist er nicht vorhanden und sollte daher gedruckt werden. Der Rest verwendet nur den ternären Operator, um Zeichen und Platz zu sparen.

Perl, 49 Zeichen

say grep/[^+-246\[-^aceghmprsy]/,map chr,041..126

Dies ist eine interessante Herausforderung - es ist eine Art Anti-Quine, und ich habe es geschafft, das Programm ein paar Mal zu verkürzen, indem ich die Anzahl der darin enthaltenen Zeichen vergrößerte .

Ruby, 81 78 68 66 62 57

(?!..?~).map{|a|$><<a if/[()ifmap{}|?!.~\/\\\[\]$><]/!~a}

Prüft einfach selbst. Doppelte Zeichen manuell entfernt.

Vielen Dank an Josh für das Speichern von 4 Zeichen und an Minitech für das Speichern von 5 Zeichen!

Befunge (48)

<|::-1,+*88:<+3*87
6<@.**85
9>"()~&"/%$ |!#';=?}

Ausgaben: {zyxwvutsrqponmlkjihgfedcba` _ ^] [ZYXWVUTSRQPONMLKJIHGFEDCBA240

Java - 126 Zeichen

minimiert:

class hjq{public static void main(String...w){for(char z='"'|0;++z!='a';)if("'()+.0;=OS".indexOf(z)==~0)System.out.print(z);}}

nicht minimiert:

class hjq {
    public static void main(String... w) { 
        for (char z = '"'|0; ++z != 'a';) {
            if ("'()+.0;=OS".indexOf(z) == ~0) {
                System.out.print(z);
            }
        }
    }
}

Dies ist ein interessantes Problem, da einzelne Token möglicherweise von ihrer längeren Form profitieren, da sie Zeichen wiederverwenden. Normalerweise String[]wäre dies beispielsweise kürzer, String...die eckigen Klammern in der bedingten Zeichenfolge sind jedoch nicht mehr erforderlich.

Ich fand den Trick darin, Zeichen am Anfang und am Ende des Bereichs zu verwenden, damit Sie sie von der Ausgabe ausschließen können, indem Sie einfach den Anfang und das Ende Ihrer Schleife ändern.

Für Java ist ein Schlüsselzeichen, das ausgeschlossen werden muss ", da das in der Zeichenfolge einen Escape-Befehl erfordert, der \zu Ihrem Programm beiträgt, und in die Zeichenfolge aufgenommen werden muss, die beiträgt \\. Durch Entfernen "aus der bedingten Zeichenfolge entfernen Sie 4 Zeichen. Dies kann erreicht werden, indem Sie sicherstellen, dass Sie und verwenden !und Ihre Schleife von starten #.

Alle Kleinbuchstaben erscheinen am Ende des Bereichs, mit nur {, |, }und ~nach ihnen kommen. Aufgrund der Ausführlichkeit von Java werden die meisten Kleinbuchstaben nur für das Boilerplate verwendet. Ebenso {und }für ein Java-Programm trivial, weil das Boilerplate sie benötigt.

|kann verwendet werden, wenn Sie eine oder-Bedingung haben, aber ich konnte keinen Weg finden, eine zu nutzen, die zu einem kürzeren Programm führt, als es nur |als bitweiser Operator zu verwenden. Das |0macht mich ein bisschen dreckig, weil es der einzige Teil ist, der ein Nopp ist, um den Charakter reinzuholen.

~0Erträge -1, was praktisch ist, weil wir das überprüfen müssen indexOf. Wenn Sie dies mit "using !=for the loop conditional" kombinieren, wird das <Zeichen insgesamt eliminiert , was bedeutet, dass es nicht in die bedingte Zeichenfolge eingefügt werden muss.

sh (47)

tr</dev/urandom -cd \[:print:]|tr -d "`cat $0`"

Verwendet den selbstreferenziellen Ansatz. Es wird davon ausgegangen, /dev/urandomdass letztendlich jedes Oktett mindestens einmal ausgegeben wird. Beendet nicht.

Wenn wir davon ausgehen, dass dies maninstalliert ist, könnten wir stattdessen die ascii(7)Manpage (und damit ein Abschlussprogramm) verwenden ( 44 Zeichen, danke @fennec).

man ascii|tr -cd \[:print:]|tr -d "`cat $0`"

BitShift , 1038 Bytes

BitShift ist eine Sprache, die nur 0und 1als Syntax unterstützt. Ich dachte, es wäre einfach, alle anderen Zeichen zu drucken, aber da es das Schleifen nicht wirklich unterstützt, endeten immer noch massive 1038 Bytes.
Ich glaube jedoch, dass es nicht wirklich möglich ist, kleiner zu werden.

101001100101011011010100110111010100100101011001101111010100100101011001000101011011010100101100110110101001001010110010001010110110101000001101010010010101100100010101101101010000010000011001010110110101000010000101011011010100110111010100100101011111100101011011010100110111010100100101011001101111010100100101011001000101011011010100000000011010100100101011001000101011011010100110010000101011011010100110111010100100101011001101001101010010010101100100010101101101010011001000010101101101010011011101010010010101111011111110010101101101010011011101010010010101100101100101011011010100010001010110110101001000010101101101010011011101010010010101110111110010101101101010011011101010010010101111111100101011011010100110111010100100101011111011110101001001010110010001010110110101001000100000101011011010100110111010100100101011111010011010100100101011001000101011011010100100000101011011010100110111010100100101011001101111010100100101011001000101011011010100010000010101101101010011011101010010010101101001101101010010010101101001101010

Druckt

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

Probieren Sie es hier aus

Auf jeden Fall die längste Lösung, aber das Codieren in Lino macht immer Spaß:

L.in.oleum -655 523 Zeichen

"libraries"/arch/cpu/base;/hmi/conout;/data/bytes;/data/string/t2s;/data/heap;/data/heap/connect/mgrab;"stockfile"a;"directors"displaystatus=engage;"injection"c=524;b<-bytes.bytesizeconvert:c;b<-heap.alloc:b;a<-heap.alloc:c;[filecommand]=readfile;[filename]=stockfile;[fileposition]=0;[fileblocksize]=c;[fileblockpointer]=b;arch.fileread;[string.psource]=b;[string.ptarget]=a;string.t2s;b<-heap.alloc:7fh;c=32;d=b;"f"[d_32]=c;+c;+d;?c<7fh>f;"w"d=[a];+a;?d=0>y;?d<32>w;?d>7eh>w;e=b;e+d;[e]=33;^w;"y"b+32;"v"conout.say:b;bye;

Keine Kommentare, liest nur die Quelle in binäre kompiliert. Speichern unter a.txtoder es wird nicht kompiliert!

Brainfuck, 133 123 114 110 Bytes

++++++++++++++++[->++++++>++>+++>++++>++<<<<<]>-->>->->+[---<.+.+<.+<.+<.+.+.+>>>>]++[-<.+.+.+<.+>>]<+.<+.<++.

Ein bisschen mehr an einer früheren Lösung herumgebastelt (bevor ich merkte, dass die unten stehende kleiner war - obwohl dies war, bevor ich einige schwere Optimierungen vorgenommen habe). Dies funktioniert, indem 4 Sätze von ASCII-Zahlen gespeichert und mit einer kniffligen Schleife ausgedruckt werden und anschließend die fehlenden Zeichen (dh solche, die zwischen ungültigen ASCII-Zahlen liegen) eingegeben werden.

Ursprüngliche Vorlage

>>+++++++++++[<+<+>>->++>+++<<]<++>>++++++>>+++++[-<<<++++++>>>]<<<+<<[->>+.<<]>>++.++<[->+.<]>++.+>[-<+.>]<++.+>>[-<<+.>>]

Es macht Folgendes:

• Erstellen Sie 4 Register mit 11. 13, 28, 33
• Erstellen Sie eine 5. mit dem Wert 31, um den Druckvorgang zu starten
• Drucke ASCII 32-42 (11)
• Drucken Sie Ascii 44
• Druck Ascii 47-59 (13)
• Drucken Sie Ascii 61
• Drucke ASCII 63-90 (28)
• Drucken Sie Ascii 92
• Druck Ascii 94-126 (33)

Haskell (70)

import Data.List
main=putStrLn$[' '..'~']\\" \\\"$'.=DLS[]aimnoprstu~"

Die langweilige Lösung für doppelte Zeichen in einem Programm in einer Zeichenfolge, die von der universellen Menge subtrahiert wird. Weit entfernt von einem Codegolfgewinner, obwohl es für seine Länge überraschend gut lesbar ist.

(Jetzt mit Listensubtraktion anstelle von filter/ notWith.)

J - 21

(u:32+i.97)-.1!:1<":5

Schreiben Sie dies in eine Datei, die 5im aktuellen Verzeichnis aufgerufen wird . Laden Sie dann das Skript mit0!:1<'5'

Oder 25 ohne den Filetrick:

(-.~".)'(":u:32+i.0-~95)'

Clojure (142, 106103)

(defn -main[](let[c"(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]((load-string c)c)))

formatiert:

(defn -main []
  (let [c "(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]
    ((load-string c) c)))

Denke, das macht es, braucht vielleicht ein paar Verbesserungen. Ausgabe:

#{@ ` ! A B b # C $ D % E & F ' G H I * J + K k , L M . N / O 0 P Q q R S 4 T 5 U V v 7 W w 8 X x 9 Y y : Z z { < | = } > ^ ? _}

führt die Zeichenfolge, die auswertbarer Clojure-Code ist, auf sich selbst aus. Die Zeichenfolge enthält am Ende einige Kommentare, um die außerhalb der Zeichenfolge verwendeten Zeichen abzurufen (Hauptmethode usw.).

Python 2, 69

for x in range(38):print chr(x+59)#!"$%&'*,-./012467bdjklmqsuvwyz{|}~

Ich verwende die längste (die ich finden kann) Folge von fortlaufenden Zeichen, die ich ausdrucken und die anderen als Kommentar nach dem Code hinzufügen kann.