En se référant aux codes de caractères ASCII imprimables en décimal, nous savons que de 32 à 126, nous avons les caractères imprimables avec 32 étant (espace). Votre défi est d'écrire un programme utilisant uniquement des caractères de 32 à 125 (à l'exception de 126) qui, une fois exécuté, imprime son propre code source, sauf que chaque caractère du code source a son code ASCII augmenté d'une unité.

Par exemple, si le code source était

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

sa sortie serait

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

Sont interdits:

• Lecture / écriture / utilisation de tout fichier ou stockage externe (y compris Internet)
• Lecture / écho de votre propre code source
• Codes source avec moins de 2 caractères (ils ne sont pas amusants). Doit être supérieur ou égal à 2.

Ce qui en fait un concours de popularité où après avoir attendu pendant au moins deux semaines, la réponse, dans n'importe quelle langue, avec les votes positifs les plus élevés gagne avec le plus petit nombre de caractères étant le bris d'égalité.

Python (27 caractères)

Dans le shell Python, le script suivant affichera le résultat souhaité:

TzoubyFssps;!jowbmje!tzouby

Oui! il génère:

SyntaxError: invalid syntax

hein? , 5 caractères

Ntbg 

Notez que le 5ème caractère est un espace aprèsNtbg . C'est la même astuce que dans l' une de mes réponses précédentes . Ntbgest un chemin non valide, donc l'interpréteur affichera Ouch!Vous devriez l'exécuter comme ceci:

huh.exe Ntbg 

PHP (351)

Je suis sûr qu'il existe une meilleure façon de le faire, car je suis nouveau dans le golf de code, mais voici ma solution PHP:

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;}

Production:

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

Pour votre calculatrice TI-83/84!

DQQ9RXMS@W

Les sorties:

ERR:SYNTAX

GolfScript, 15 caractères

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

Production:

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

Essayez-le en ligne.

Une solution assez simple basée sur la technique que j'ai utilisée pour mon entrée au défi "rotation quine" . Le seul détail délicat est que le caractère ~(ASCII 126) est interdit par les règles de défi, donc je ne peux pas l'utiliser pour exécuter mon bloc de code. Heureusement, 1*peut être utilisé comme synonyme de celui-ci.

Explication:

Le bloc de code {`{)}%"/2+"}est dupliqué par le ., et la deuxième copie exécutée par 1*(techniquement, une boucle d'une itération), laissant l'autre copie sur la pile. À l'intérieur du bloc de code, `stringifie le bloc de code et {)}%boucle (les codes ASCII de) ses caractères, en les incrémentant chacun d'un. Enfin, "/2+"pousse la chaîne littérale /2+(qui est .1*décalée d'une unité) sur la pile. À la fin du programme, l'interpréteur GolfScript imprime alors automatiquement tout sur la pile.

Ps. Oui, je sais qu'il s'agit d'un concours de popularité plutôt que d'un code-golf strict , mais que vais-je faire d'autre avec GolfScript - l'art ASCII? ;-)

JavaScript, 117 caractères

Je sais que ce n'est pas du golf codé, mais je l'ai quand même joué au golf.

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

(Je ne lis pas mon propre code source; j'utilise simplement la fonction de l' Functionobjet toString.)

Java - 1331 octets, 618 octets et 504 octets

Le voici en java. Ce qui est cool, c'est qu'il est assez lisible et flexible. Vous pouvez expérimenter pour changer la SHIFTvariable à 0 et ce sera une quine. Vous pouvez le changer à la valeur que vous voulez, y compris les valeurs négatives et il décalera le code en conséquence.

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 = @";
}

Cependant, le seul inconvénient de la classe précédente sont les sauts de ligne, qui ne sont pas autorisés dans la spécification de question (sont en dehors de la plage 32 à 125). Je donne donc ici une version golfée qui est exempte de sauts de ligne (et libre des bizarreries pour les gérer). Vous pouvez modifier la valeur de la Svariable pour modifier le décalage. Cela a 618 octets:

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=@";}

Certes, si nous abandonnons le réglage fin de l'offset et codons en dur la valeur du décalage, nous pouvons faire une version complètement golfée avec 504 octets:

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 caractères incluent les sauts de ligne

Ne pas être autorisé à utiliser ~ l'a rendu un peu plus délicat.

#!/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

Production:

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

Cela peut être raccourci à 75 caractères , mais cela imprimera un nouveau caractère de ligne après la sortie, ce qui enfreindra techniquement les règles:

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

Stax , 16 octets

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

Exécuter et déboguer

Adaptation du "34bL"34bLquine. Puisque "devient maintenant #ce qui n'a pas besoin d'être échappé, nous pouvons simplement l'inclure dans la chaîne.

Lua - 192

Assez simple,

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);}

Juste le quine C classique avec les modifications requises

PS, sprintf(f,...,f,...)est apparemment une faute de segmentation.

JavaScript (276)

Sans utiliser .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;}

Rubis, 63

Bon sang, je ne peux pas utiliser un hérédoc sur celui-ci.

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

Ruby a une méthode native .succqui le fait sur un caractère, et l'impression sans nouvelle ligne est plus courte que l'impression avec, donc cela fonctionne assez bien.

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);}

Une autre modification de la quine classique en c ...

> <>, 16 octets

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

Essayez-le ici!

Il s'agit plus ou moins d'une quine standard dans> <> (sans utiliser l' ginstruction). Les seules différences sont qu'il ne lit pas son propre code source et incrémente chaque caractère de 1 avant de le sortir.

Les sorties

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

*> <> , 15 octets (non concurrents)

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

Essayez-le ici!

Tcl , 89 octets

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

Essayez-le en ligne!

Tcl , 89 octets

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

Essayez-le en ligne!

Deux approches; la même longueur d'octet!

Haskell , 64 octets

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

Essayez-le en ligne!

Perl 5 , 55 octets

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

Essayez-le en ligne!

J, 42 octets

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