Wenn wir uns auf die druckbaren ASCII-Zeichencodes in Dezimalform beziehen, wissen wir, dass von 32 bis 126 die druckbaren Zeichen 32 (Leerzeichen) sind. Ihre Herausforderung besteht darin, ein Programm zu schreiben, das nur Zeichen von 32 bis 125 (außer 126) verwendet und bei Ausführung seinen eigenen Quellcode ausgibt, mit der Ausnahme, dass für jedes Zeichen im Quellcode der ASCII-Code um eins erhöht wird.

Zum Beispiel, wenn der Quellcode war

main(){printf("Hello World");}

seine Ausgabe wäre

nbjo)*|qsjoug)#Ifmmp!Xpsme#*<~

Folgendes ist verboten:

• Lesen / Schreiben / Verwenden externer Dateien oder Speicher (einschließlich Internet)
• Lesen / Echo Ihres eigenen Quellcodes
• Quellcodes mit weniger als 2 Zeichen (sie machen keinen Spaß). Muss größer oder gleich 2 sein.

Machen Sie es zu einem Beliebtheitswettbewerb, bei dem nach einer Wartezeit von mindestens zwei Wochen die Antwort in einer beliebigen Sprache mit den höchsten Bewertungen gewinnt, wobei die geringere Anzahl von Zeichen der Auslöser ist.

Python (27 Zeichen)

In der Python-Shell gibt das folgende Skript das gewünschte Ergebnis aus:

TzoubyFssps;!jowbmje!tzouby

Ja! es gibt aus:

SyntaxError: invalid syntax

huh? 5 Zeichen

Ntbg 

Beachten Sie, dass das 5. Zeichen ein Leerzeichen danach istNtbg . Dies ist der gleiche Trick wie in einer meiner vorherigen Antworten . Ntbgist ein ungültiger Pfad, daher gibt der Interpreter Folgendes aus Ouch!:

huh.exe Ntbg 

PHP (351)

Ich bin mir sicher, dass es einen besseren Weg gibt, dies zu tun, da ich neu im Codegolf bin, aber hier ist meine PHP-Lösung:

function q(){$q=chr(39);$a=array('function q(){$q=chr(39);$a=array(',');@$r.=$a[0];foreach($a as$b)$r.=$q.$b.$q.",";$r=substr($r,0,-1);$r.=$a[1];for($i=0;$i<strlen($r);$i++)$r{$i}=chr(ord($r{$i})+1);return $r;}');@$r.=$a[0];foreach($a as$b)$r.=$q.$b.$q.",";$r=substr($r,0,-1);$r.=$a[1];for($i=0;$i<strlen($r);$i++)$r{$i}=chr(ord($r{$i})+1);return $r;}

Ausgabe:

gvodujpo!r)*|%r>dis)4:*<%b>bssbz)(gvodujpo!r)*|%r>dis)4:*<%b>bssbz)(-(*<A%s/>%b\1^<gpsfbdi)%b!bt%c*%s/>%r/%c/%r/#-#<%s>tvctus)%s-1-.2*<%s/>%b\2^<gps)%j>1<%j=tusmfo)%s*<%j,,*%s|%j~>dis)pse)%s|%j~*,2*<sfuvso!%s<~(*<A%s/>%b\1^<gpsfbdi)%b!bt%c*%s/>%r/%c/%r/#-#<%s>tvctus)%s-1-.2*<%s/>%b\2^<gps)%j>1<%j=tusmfo)%s*<%j,,*%s|%j~>dis)pse)%s|%j~*,2*<sfuvso!%s<~

TI-BASIC, 10

Für Ihren TI-83/84 Rechner!

DQQ9RXMS@W

Ausgänge:

ERR:SYNTAX

GolfScript, 15 Zeichen

{`{)}%"/2+"}.1*

Ausgabe:

|a|*~&#03,#~/2+

Probieren Sie es online aus.

Eine ziemlich einfache Lösung, die auf der Technik basiert, die ich für meinen Einstieg in die Herausforderung "Rotierendes Quin" verwendet habe . Das knifflige Detail ist, dass das Zeichen ~(ASCII 126) von den Herausforderungsregeln nicht zugelassen wird, sodass ich es nicht zum Ausführen meines Codeblocks verwenden kann. Glücklicherweise,1* kann als Synonym dafür verwendet werden.

Erläuterung:

Der Codeblock {`{)}%"/2+"}wird vom dupliziert ., und die zweite Kopie wird von 1*(technisch gesehen eine Schleife mit einer Iteration) ausgeführt, wobei die andere Kopie auf dem Stapel verbleibt. `Stringt den Codeblock innerhalb des Codeblocks und durchläuft {)}%(die ASCII-Codes von) seinen Zeichen, wobei jeder um eins erhöht wird. Schließlich "/2+"drückt die Literalzeichenfolge /2+(die ist.1* auf den Stapel durch ein verschoben). Am Ende des Programms druckt der GolfScript-Interpreter dann automatisch alles auf den Stapel.

Ps. Ja, ich weiß, dass dies eher ein Beliebtheitswettbewerb als strenges Code-Golf ist , aber was soll ich sonst mit GolfScript - ASCII-Kunst machen? ;-)

JavaScript, 117 Zeichen

Ich weiß, dass es kein Code-Golf ist, aber ich habe es trotzdem gespielt.

function f(){alert((f+';f()').split('').map(function(x){return String.fromCharCode(x.charCodeAt()+1)}).join(''))};f()

(Ich lese meinen eigenen Quellcode nicht; ich benutze einfach die Funktion des FunctionObjekts toString.)

Java - 1331 Bytes, 618 Bytes und 504 Bytes

Hier ist es in Java. Das Coole ist, dass es ziemlich lesbar und flexibel ist. Sie können experimentieren, um die SHIFTVariable in 0 zu ändern , und es wird ein Quine sein. Sie können es auf einen beliebigen Wert ändern, einschließlich negativer Werte, und der Code wird entsprechend verschoben.

public class Quinex {

    private static final int SHIFT = 1;

    private static String next(String now, boolean mangles) {
        String sb = "";
        for (char c : now.toCharArray()) {
            if (!mangles && c == 87) {
                sb += next(String.valueOf(SHIFT), true);
            } else {
                sb += (char) ((mangles ? c : c == 94 ? 10 : c == 64 ? 34 : c) + SHIFT);
            }
        }
        return sb;
    }

    public static void main(String... args) {
        System.out.println(next(TEXT, false) + next(TEXT, true) + new String(new char[] { 34, 59, 10, 125 }));
    }

    private static final String TEXT = "public class Quinex {^^    private static final int SHIFT = W;^^    private static String next(String now, boolean mangles) {^        String sb = @@;^        for (char c : now.toCharArray()) {^            if (!mangles && c == 87) {^                sb += next(String.valueOf(SHIFT), true);^            } else {^                sb += (char) ((mangles ? c : c == 94 ? 10 : c == 64 ? 34 : c) + SHIFT);^            }^        }^        return sb;^    }^^    public static void main(String... args) {^        System.out.println(next(TEXT, false) + next(TEXT, true) + new String(new char[] { 34, 59, 10, 125 }));^    }^^    private static final String TEXT = @";
}

Der einzige Nachteil in der vorherigen Klasse sind jedoch die Zeilenumbrüche, die in der Fragenspezifikation nicht zulässig sind (außerhalb des Bereichs von 32 bis 125). Also gebe ich hier eine Golfversion, die frei von Zeilenumbrüchen ist (und frei von den Macken, mit denen sie umzugehen sind). Sie können den Wert der SVariablen bearbeiten , um die Verschiebung zu ändern. Dies hat 618 Bytes:

class Q{static String g(String p,int m){int S=1;String u="";for(char c:p.toCharArray()){if(m==0&&c==87){u+=g(String.valueOf(S),1);}else{u+=(char)((m>0?c:c==64?34:c)+S);}}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T="class Q{static String g(String p,int m){int S=W;String u=@@;for(char c:p.toCharArray()){if(m==0&&c==87){u+=g(String.valueOf(S),1);}else{u+=(char)((m>0?c:c==64?34:c)+S);}}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T=@";}

Wenn wir die Feineinstellung des Offsets verwerfen und den Wert der Verschiebung fest codieren, können wir sicherlich eine vollständig golfene Version mit 504 Bytes erstellen:

class Q{static String g(String p,int m){String u="";for(char c:p.toCharArray()){u+=(char)((m>0?c:c==64?34:c)+1);}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T="class Q{static String g(String p,int m){String u=@@;for(char c:p.toCharArray()){u+=(char)((m>0?c:c==64?34:c)+1);}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T=@";}

Perl 5, 284 Zeichen enthalten die Zeilenvorschübe

Die Nichtverwendung von ~ machte es etwas kniffliger.

#!/usr/bin/perl
$_=<<X;
#!/usr/bin/perl
Y
\$a=\$_;
s/\\\\/\\\\\\\\/g;
s/\\\$/\\\\\\\$/g;
\$b=\$_;
\$_=\$a;
s/Y/\\\$\\_\\=\\<\\<X\\;\\n\${b}X/;
s/(.)/chr(ord(\$1)+1)/ge;
print;
X
$a=$_;
s/\\/\\\\/g;
s/\$/\\\$/g;
$b=$_;
$_=$a;
s/Y/\$\_\=\<\<X\;\n${b}X/;
s/(.)/chr(ord($1)+1)/ge;
print;

Python, 99

s='import sys;sys.stdout.write("".join(chr(ord(c)+1)for c in a%(s,a)))';a='s=%r;a=%r;exec s';exec s

Ausgabe:

t>(jnqpsu!tzt<tzt/tuepvu/xsjuf)##/kpjo)dis)pse)d*,2*gps!d!jo!b&)t-b***(<b>(t>&s<b>&s<fyfd!t(<fyfd!t

Dies kann auf 75 Zeichen gekürzt werden , es wird jedoch nach der Ausgabe ein neues Zeilenzeichen gedruckt, was die Regeln technisch übertrifft:

s='print"".join(chr(ord(c)+1)for c in a%(s,a))';a='s=%r;a=%r;exec s';exec s

Stax , 16 Bytes

"{^m'#bL"{^m'#bL

Führen Sie es aus und debuggen Sie es

Anpassung der "34bL"34bLQuine. Da jetzt "wird #was nicht entkommen muss können wir es einfach in den String aufnehmen.

Lua - 192

Ziemlich einfach,

s=[[print((('s=['..'['..s..']'..']'..s):gsub('.',function(x)return string.char(x:byte()+1)end)))]]print((('s=['..'['..s..']'..'];'..s):gsub('.',function(x)return string.char(x:byte()+1)end)))

C - 156

char*f="char*f=%c%s%c,q[200];i;main(){sprintf(q,f,34,f,34);while(q[i])q[i++]++;puts(q);}",q[200];i;main(){sprintf(q,f,34,f,34);while(q[i])q[i++]++;puts(q);}

Nur die klassische C-Quine mit den erforderlichen Modifikationen

PS, ist anscheinend sprintf(f,...,f,...)ein segfault.

JavaScript (276)

Ohne zu verwenden .toString():

function q(){x=String.fromCharCode;y=x(39);a=['function q(){x=String.fromCharCode;y=x(39);a=[','];r=a[0]+y+a[0]+y+","+y+a[1]+y+a[1];q="";for(c in r)q+=x(r[c].charCodeAt(0)+1);return q;}'];r=a[0]+y+a[0]+y+","+y+a[1]+y+a[1];q="";for(c in r)q+=x(r[c].charCodeAt(0)+1);return q;}

Rubin, 63

Verdammt, ich kann hier keinen Heredoc benutzen.

s="s=%p;(s%%s).chars{|c|$><<c.succ}";(s%s).chars{|c|$><<c.succ}

Ruby hat eine native Methode .succ, die dies für ein Zeichen ausführt, und das Drucken ohne Zeilenvorschub ist kürzer als das Drucken mit. Das funktioniert also ziemlich gut.

C 153

main(a){char b[999];sprintf(b,a="main(a){char b[999];printf(a=%c%s%c,34,a,34);for(a=0;b[a];)b[a++]++;puts(b);}",34,a,34);for(a=0;b[a];)b[a++]++;puts(b);}

Eine weitere Modifikation des klassischen ...

> <>, 16 Bytes

" r:2+l?!;1+o50.

Probieren Sie es hier aus!

Dies ist mehr oder weniger nur ein Standard-Quine in> <> (ohne die gAnweisung zu verwenden). Die einzigen Unterschiede sind, dass es seinen eigenen Quellcode nicht liest und jedes Zeichen um 1 erhöht, bevor es ausgegeben wird.

Ausgänge

#!s;3,m@"<2,p61/

*> <> , 15 Bytes (nicht konkurrierend)

" r:2+Ol?!;1+ou

Probieren Sie es hier aus!

Tcl , 89 Bytes

puts [join [lmap c [split [read [open $argv0]] ""] {format %c [expr [scan $c %c]+1]}] ""]

Probieren Sie es online!

Tcl , 89 Bytes

puts [join [lmap c [split [read [open $argv0]] ""] {scan $c %c s;format %c [incr s]}] ""]

Probieren Sie es online!

Zwei Ansätze; die gleiche Bytelänge!

Haskell , 64 Bytes

main=putStr$succ<$>s++show s;s="main=putStr$succ<$>s++show s;s="

Probieren Sie es online!

Perl 5 , 55 Bytes

$_=q{print chr(1+ord)for split//,"\$_=q{$_};eval"};eval

Probieren Sie es online!

J, 42 Bytes

(>:&.(u:inv)@,quote)'(>:&.(u:inv)@,quote)'