Escreva um programa completo que aceite uma entrada inteira booleana ou não negativa. Deve:

• Emita seu próprio código-fonte se o valor de entrada for falso
• Emita seu próprio código-fonte ao contrário, se o valor de entrada for verdadeiro

Seu programa não pode ser palindrômico, nem pode ler seu próprio código-fonte por qualquer meio.

Este é o código golf - o código mais curto em bytes ganha.

Gol> <> , 9 bytes

'rd3*I?rH

Sinto-me um pouco estranho ao postar isso, já que já temos> <> respostas de Vitsy e Minkolang. As únicas adições ao quine padrão são I(ler a entrada inteira), ?(executar a seguir se for verdade) e r(pilha reversa).

Experimente online .

CJam, 17 16 bytes

{`"_~"+Wq~g#%}_~

Teste aqui.

Uma modificação bastante direta do quine padrão. Outras soluções para 17 bytes:

{`"_~"+q~{W%}&}_~
{`"_~"+q~!2*(%}_~

Se eu puder assumir que a entrada é apenas 0 ou 1 (como substituto de um booleano, para o qual não há tipo dedicado no CJam), obtive 15 omitindo o g:

{`"_~"+Wq~#%}_~

Explicação

{`"_~"+  e# Standard generalised quine framework. Leaves the source code on the stack. 
  W      e# Push a -1.
  q~     e# Read and evaluate input.
  g      e# signum, turning truthy values into 1 (leaving 0 unchanged).
  #      e# Power. -1^0 == 1, -1^1 == -1.
  %      e# Select every Nth element: a no-op for 1 and reverses the string for -1.
}_~

Pitão, 17 bytes

_WQjN*2]"_WQjN*2]

Uma modificação direta do padrão Pyth quine.

> <>, 17 bytes

Requer o sinalizador -v (+1 byte) para inserir entrada na pilha (ou para você inserir entrada na pilha com antecedência no intérprete on-line).

'rd3*$?rol?!;70.

Você pode fazer o seguinte para a mesma quantidade de bytes (sem o sinalizador) se apenas entradas inteiras forem permitidas (por exemplo, 0 para falsy, 1 para verdade).

'rd3*ic%?rol?!;80.

Experimente online

Verdade / falsidade para> <> não são 0 e 0, respectivamente.

Vitsy , 15 bytes

... eu estou ... eu estou batendo CJam! (grita) Mãe! Olha, mãe, eu fiz isso!

'rd3 * i86 * -) rl \ O

Explicação:

'rd3 * i86 * - (rl \ O
Quine padrão, mas com um toque:

'Capture o código fonte como uma string
 rd3 * Crie o caractere 'em ASCII
     i86 * - Obtenha o caractere de entrada como ASCII e subtraia 48 dele. 
                    Se for zero, a instrução if pulará a próxima instrução.
          (r Se o item superior da pilha for zero, não execute o próximo item.
                    O próximo item aqui é o contrário.
            l Imprima a pilha.

Versão mais recente do Vitsy , 11 bytes

v'rd3 *} v) rZ
v Capture a entrada como uma variável.
 'Capture a fonte até encontrar outra'
  r Inverta a pilha.
   d3 * Pressione 'para a pilha.
      } Gire a pilha para a direita.
       v) Empurre a variável (entrada) para a pilha e teste se não é zero.
         r Se sim, inverta a pilha.
          Z Imprima tudo na pilha.

Javascript (ES6), 42 bytes

$=_=>'$='+(_?$:[...''+$].reverse().join``)

Esta é uma modificação do meu Bling Quine . Também é o dobro do tempo.

Burlesco, 40 bytes

ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

Explicação:

Burlesque possui built-ins avançados de manipulação de pilha e código. De fato, você não pode acessar o código fonte do programa, mas pode acessar o código restante que será executado no futuro. Isso significa #Qque retornará todo o código a seguir, e é por isso que precisamos adicionar tudo #Qao código com o qual estamos fazendo ri#Q.

blsq ) #Q1 2++
12 -- this is the result of 1 2++
{1 2 ++} -- this is the result of #Q

++1 2é um código tecnicamente ilegal, pois é baseado em pilha. Mas podemos manipular o código para executá-lo como 1 2++:

blsq ) #Q<-#q++1 2 
12

Trabalhar com esses built-ins é incrivelmente complicado e ninguém ainda os usou para qualquer coisa produtiva, exceto por questões relacionadas a quine. Se você inverter, ++1 2obtém o 2 1++que produziria 21e não 12. A razão pela qual o código acima produz 12é porque #Qtambém inclui o <-modo. No final, acabamos executando muito mais do que apenas 2 1++: p. Acabamos executando o 2 1++#q<-que produz 12.

Na verdade, podemos substituir coisas em nosso código, por exemplo, esse código substitui todas as ocorrências ?+por si só por?*

blsq ) #Q(?+)(?*)r~5.-#q5 5?+
25

Uso:

$ echo "1" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
hs fi sp "-<" j +. /\ "Q#ir" -~ HS 2Q#ir
$ echo "0" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

Haskell, 126 118 108 bytes

main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="

Espera 0ou 1como entrada.

Minkolang 0.10 , 13 bytes

"66*2-n,?r$O.

Experimente aqui.

Este é exatamente como o Quine padrão, exceto para estes quatro personagens: n,?r. npega um número inteiro da entrada, ,inverte-o, então ?pula rse a entrada é verdadeira. Caso contrário, rinverte a pilha para que ela seja impressa na ordem inversa.

Python 2, 51 bytes

s="print('s=%r;exec s'%s)[::1-2*0**input()]";exec s

Java 10 (programa completo), 282 bytes

interface N{static void main(String[]a){var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}

Experimente online.

Java 10 (como função lambda), 154 bytes

b->{var s="b->{var s=%c%s%1$c;s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}";s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}

Experimente online.

Explicação:

interface N{                          // Class
  static void main(String[]a){        //  Mandatory main-method
    var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";
                                      //   Unformatted source code
    s=s.format(s,34,s);               //   Format the source code (the quine-String)
    System.out.print(                 //   Print:
      new Boolean(a[0])?              //    If the input is true:
       new StringBuffer(s).reverse()  //     Print the quine-String reversed
      :                               //    Else:
       s);}}                          //     Print the quine-String as is

explicação quine :

• O var scontém o código fonte não formatado
• %s é usado para colocar essa String em si mesma com s.format(...)
• %c,, %1$ce 34são usados ​​para formatar aspas duplas
• s.format(s,34,s) coloca tudo junto

E então new StringBuffer(s).reverse()é usado para reverter o quine-String, se necessário, com base no input-boolean.

05AB1E , 21 bytes

0"D34çý‚sè"D34çý‚sè

Experimente online.

Modificação do quine padrão 0"D34çý"D34çýadicionando ‚sè.

Explicação:

0                        # Push 0 to the stack
                         #  STACK: [0]
 "D34çý‚sè"             # Push the string 'D34çý‚sè' to the stack
                         #  STACK: [0, 'D34çý‚sè']
            D            # Duplicate this string
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè']
             34ç         # Push '"' to the stack
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè', '"']
                ý        # Join the stack with '"' delimiter
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè']
                 Â       # Bifurcate (short for Duplicate & Reverse)
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè', 'ès‚Âýç43D"ès‚Âýç43D"0']
                  ‚      # Pair them up:
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0']]
                   s     # Swap to get the boolean input (0 or 1)
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0'], 1]
                    è    # Index the input into the list
                         #  STACK: ['ès‚Âýç43D"ès‚Âýç43D"0']
                         # (Output the top of the stack implicitly)

PS: Imprime automaticamente uma nova linha à direita. Se isso também deve ser revertido, são 23 bytes:

0"D34çý‚sè?"D34çý‚sè?

Experimente online. ( ?é uma impressão explícita sem nova linha )