Referindo-se aos códigos de caracteres ASCII imprimíveis em decimal, sabemos que de 32 a 126 temos os caracteres imprimíveis com 32 sendo (espaço). Seu desafio é escrever um programa usando apenas caracteres de 32 a 125 (excluindo 126) que, quando executado, imprime seu próprio código-fonte, exceto que cada caractere no código-fonte tem seu código ASCII aumentado em um.

Por exemplo, se o código fonte foi

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

sua saída seria

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

São proibidos os seguintes:

• Leitura / gravação / uso de arquivos ou armazenamento externo (incluindo a Internet)
• Lendo / ecoando seu próprio código fonte
• Códigos-fonte com menos de 2 caracteres (eles não são divertidos). Deve ser maior ou igual a 2.

Tornando-o um concurso de popularidade, onde, depois de esperar pelo menos duas semanas, a resposta, em qualquer idioma, com as maiores votações positivas ganha, com a menor contagem de caracteres sendo o desempate.

Python (27 caracteres)

No shell do Python, o seguinte script produzirá o resultado desejado:

TzoubyFssps;!jowbmje!tzouby

Sim! produz:

SyntaxError: invalid syntax

Hã? 5 caracteres

Ntbg 

Observe que o quinto caractere é um espaço depoisNtbg . Esse é o mesmo truque que em uma das minhas respostas anteriores . Ntbgé um caminho inválido, portanto o intérprete produzirá Ouch!Você deve executá-lo assim:

huh.exe Ntbg 

PHP (351)

Tenho certeza de que há uma maneira melhor de fazer isso, pois sou novo no codegolfing, mas aqui está minha solução 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;}

Resultado:

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

Para a sua calculadora TI-83/84!

DQQ9RXMS@W

Saídas:

ERR:SYNTAX

GolfScript, 15 caracteres

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

Resultado:

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

Experimente online.

Uma solução bastante direta, baseada na técnica que usei para entrar no desafio "rotating quine" . O único detalhe complicado é que o personagem~ (ASCII 126) não é permitido pelas regras de desafio, portanto não posso usá-lo para executar meu bloco de código. Felizmente, 1*pode ser usado como sinônimo disso.

Explicação:

O bloco de código {`{)}%"/2+"}é duplicado pelo .e a segunda cópia é executada por 1*(tecnicamente, um loop de uma iteração), deixando a outra cópia na pilha. Dentro do bloco de código, `especifica o bloco de código e {)}%passa sobre (os códigos ASCII de) seus caracteres, incrementando cada um por um. Por fim, "/2+"empurra a string literal /2+(que é.1* deslocada por um) na pilha. No final do programa, o intérprete GolfScript imprime automaticamente tudo na pilha.

Ps. Sim, eu sei que este é um concurso de popularidade e não um código-golfe estrito , mas o que mais eu vou fazer com o GolfScript - arte ASCII? ;-)

JavaScript, 117 caracteres

Eu sei que não é código de golfe, mas eu joguei de qualquer maneira.

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

(Não estou lendo meu próprio código-fonte; estou simplesmente usando a função Functiondo objeto toString.)

Java - 1331 bytes, 618 bytes e 504 bytes

Aqui está em java. O legal é que é bastante legível e flexível. Você pode experimentar alterar a SHIFTvariável para 0 e será uma solução. Você pode alterá-lo para o valor que desejar, incluindo valores negativos, e o código será alterado de acordo.

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

No entanto, a única desvantagem da classe anterior são as quebras de linha, que não são permitidas na especificação da pergunta (estão fora do intervalo de 32 a 125). Então, eu dou aqui uma versão para golfe que é livre de quebras de linha (e livre de peculiaridades para lidar com elas). Você pode editar o valor da Svariável para alterar o turno. Isso tem 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=@";}

Certamente, se abandonarmos o ajuste fino do deslocamento e codificarmos o valor do turno, poderemos fazer uma versão completa com 504 bytes:

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 caracteres incluem os feeds de linha

Não ter permissão para usar o ~ tornou um pouco mais complicado.

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

Resultado:

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

Isso pode ser reduzido para 75 caracteres , mas imprimirá um novo caractere de linha após a saída, quebrando tecnicamente as regras:

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

Execute e depure

Adaptação do "34bL"34bLquine. Como agora "se torna o #que não precisa ser escapado, podemos apenas incluí-lo na string.

Lua - 192

Bem direto,

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

Apenas o clássico C quine com as modificações necessárias

PS, aparentemente, sprintf(f,...,f,...)é um segfault.

JavaScript (276)

Sem usar .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;}

Ruby, 63

Droga, não posso usar um heredoc neste.

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

O Ruby tem um método nativo .succque faz isso em um caractere, e a impressão sem uma nova linha é mais curta do que a impressão, portanto, isso funciona muito bem.

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

Outra modificação do quine clássico em c ...

> <>, 16 bytes

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

Experimente aqui!

Isso é mais ou menos apenas um quine padrão em> <> (sem usar o g instrução). As únicas diferenças são que ele não lê seu próprio código-fonte e incrementa cada caractere por 1 antes de produzi-lo.

Saídas

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

*> <> , 15 bytes (não concorrente)

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

Experimente aqui!

Tcl , 89 bytes

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

Experimente online!

Tcl , 89 bytes

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

Experimente online!

Duas abordagens; o mesmo comprimento de bytes!

Haskell , 64 bytes

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

Experimente online!

Perl 5 , 55 bytes

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

Experimente online!

J, 42 bytes

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