Escreva um programa que produza seu próprio código-fonte quando executado, e nada mais. Parece fácil, certo?

O problema é que, quando o código-fonte é revertido, seu programa deve gerar "Olá, mundo!" exatamente, sem as aspas.

Isso é código-golfe, então a contagem de bytes mais baixa vence.

Edit : Seu quine deve ser um quine adequado.

Y, 19 bytes

Upxp"!dlroW ,olleH"

Ucaptura uma sequência com Uno início até a próxima U, nesse caso, o código fonte. pimprime o item e xé um link de término. Quando invertido, isso se parece com:

"Hello, World!"pxpU

Isso captura a string e a imprime p, terminando novamente o programa com x.

Experimente aqui!

JavaScript (ES6), 42 38 bytes

f=_=>/\//g&&"f="+f||"!dlroW ,olleH">=_

Invertida

_=>"Hello, World!"||f+"=f"&&g//\/>=_=f

Explicação

Quando revertida, torna-se uma função anônima que retorna a string Hello, World!.

A regex /\//gse torna um comentário quando é revertida, o que permite que os sintaticamente inválidos >=_=fsejam comentados no código revertido.

JavaScript (ES6), 71 bytes

trela=a=>alert("trela="+trela+"\ntrela\n``")//
`!dlroW ,olleH`
trela
``

Como funciona:

A linha 1 define a função trelaque, quando executada, gera o código fonte do programa. A linha 2 é uma sequência não atribuída, não faz nada. Chamadas de linhas 3 e 4trela abuso da sintaxe da seqüência de caracteres do modelo.

Invertida:

``
alert
`Hello, World!`
//)"``n\alertn\"+alert+"=alert"(trela>=a=alert

Como funciona:

A linha 1 é uma sequência não atribuída, não faz nada. As linhas 2 e 3 abusam da sintaxe da sequência de modelo a ser impressa Hello, World!. A linha 4 é um comentário.

GolfScript, 33 bytes

Atacantes

{`".;1$~]"}"!dlroW ,olleH".;1$~]

Experimente online!

Para trás

]~$1;."Hello, World!"}"]~$1;."`{

Experimente online!

GolfScript, 29 28 bytes

"` '. ~]' # \ "! dlroW, olleH". ~]

Ele tem uma nova linha à direita. Experimente aqui.

Invertida:

] ~. "Olá, mundo!" \ # '] ~ .'` "

Experimente aqui.

RETURN , 94 bytes

"34¤¤,,,,,,,,,,,,,% 'H'e'l'l'o',' 'w'o'r'l'd'!'"34¤¤,,,,,,,,,,,,,% 'H'e'l'l'o',' 'w'o'r'l'd'!'

Invertida:

'!'d'l'r'o'w' ','o'l'l'e'H' %,,,,,,,,,,,,,¤¤43"'!'d'l'r'o'w' ','o'l'l'e'H' %,,,,,,,,,,,,,¤¤43"

Try it here.

Saídas para STDOUT. Até encontrar uma estrutura melhor para o quine, isso terá que ser feito por enquanto.

Explicação

"34¤¤,,,,,,,,,,,,,% 'H'e'l'l'o',' 'w'o'r'l'd'!'"

Contém a sequência quine. Ao contrário, isso é enviado para a pilha, mas não é emitido.

34¤¤,,,,,,,,,,,,,

Isso envia um caractere de cotação para a pilha e gera o resultado duas vezes até que não haja mais nada a ser produzido. Ao contrário, isso imprimirá os códigos de código já na pilha.

% 'H'e'l'l'o',' 'w'o'r'l'd'!'

Esse aparece o item da pilha superior (ao contrário, isso mostraria um caractere de espaço) e envia uma série de códigos para a pilha (no sentido inverso, esses códigos seriam posteriormente impressos pelas séries de ,).

Fissão 2, 42 bytes

Adaptação desavergonhada de um excelente quine por @ MartinBüttner nesta resposta

'!+O!'!d'!l'!r'!o'!W'! '!,'!o'!!l'!e'!H'R"

Experimente online

E invertido

"R'H!'e!'l!!'o!',!' !'W!'o!'r!'l!'d!'!O+!'

Experimente online

Na versão quine, o átomo começa no Rcabeçalho à direita. O "modo de impressão inicia, que passa para o próximo "(ele próprio). Isso imprime tudo, exceto o ". '!+defina o átomo para char ". Oimprime e destrói o átomo que encerra o programa.

A versão invertida inicia Rnovamente e para cada caractere no Hello, Worldconjunto do átomo e o imprime !sem destruir o átomo. Para o caractere final, !a impressão Odestrói o átomo.

Javascript ES6, 55 bytes

$=_=>`$=${$};$()//"!dlroW ,olleH"`;$()//"!dlroW ,olleH"

Muito simples, realmente.

Python 2, 131 bytes

Frente:

print(lambda x:x+repr(x)+")#'!dlroW ,olleH' tnirp")('print(lambda x:x+repr(x)+")#\'!dlroW ,olleH\' tnirp")(')#'!dlroW ,olleH' tnirp

Marcha ré:

print 'Hello, World!'#)'()"print '\Hello, World!'\#)"+)x(rper+x:x adbmal(tnirp'()"print 'Hello, World!'#)"+)x(rper+x:x adbmal(tnirp

A primeira metade é um quine de uma linha, seguido de a #para formar um comentário que separa a primeira metade da segunda metade mais simples.

C, 108 bytes

char*s="char*s=%c%s%c;main(){printf(s,34,s,34);}";main(){printf(s,34,s,34);}//};)"!dlroW ,olleH"(stup{)(niam

Python 2, 70 bytes

_='_=%r;print _%%_#"dlroW ,olleH"tnirp';print _%_#"!dlroW ,olleH"tnirp