Escriba un programa completo que tome una entrada entera booleana o no negativa. Debería:

• Emite su propio código fuente si el valor de entrada es falso
• Emite su propio código fuente en reversa si el valor de entrada es verdadero

Su programa no puede ser palindrómico, ni puede leer su propio código fuente de ninguna manera.

Este es el código de golf: el código más corto en bytes gana.

Gol> <> , 9 bytes

'rd3*I?rH

Me siento un poco incómodo al publicar esto, ya que tenemos respuestas> <>, Vitsy y Minkolang. Las únicas adiciones al quine estándar son I(leer entrada entera), ?(ejecutar luego si es verdadero) y r(apilar inversa).

Pruébalo en línea .

CJam, 17 16 bytes

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

Pruébalo aquí.

Una modificación bastante directa del quine estándar. Otras soluciones para 17 bytes:

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

Si puedo suponer que la entrada es solo 0 o 1 (como sustituto de un booleano, para el que no hay un tipo dedicado en CJam), obtengo 15 omitiendo g:

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

Explicación

{`"_~"+  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.
}_~

Pyth, 17 bytes

_WQjN*2]"_WQjN*2]

Una modificación directa del estándar Pyth quine.

> <>, 17 bytes

Requiere el indicador -v (+1 byte) para insertar la entrada en la pila (o para que pueda poner la entrada en la pila de antemano en el intérprete en línea).

'rd3*$?rol?!;70.

Puede hacer lo siguiente para la misma cantidad de bytes (sin el indicador) si solo se permitieran entradas enteras (es decir, 0 para falsedad, 1 para verdad).

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

Pruébalo en línea

Verdad / falsedad para> <> son cualquier cosa que no sea 0 y 0, respectivamente.

Vitsy , 15 bytes

... Estoy ... estoy ganando a CJam! (grita) ¡Mamá! Mira, ma, lo hice.

'rd3 * i86 * -) rl \ O

Explicación:

'rd3 * i86 * - (rl \ O
Quine estándar, pero con un giro:

'Capture el código fuente como una cadena
 rd3 * Crear el 'carácter en ASCII
     i86 *: obtiene el carácter de entrada como ASCII y luego resta 48 de él. 
                    Si es cero, la instrucción if omitirá la siguiente instrucción.
          (r Si el elemento superior de la pila es cero, no haga el siguiente elemento.
                    El siguiente elemento aquí es inverso.
            l \ O imprimir la pila.

Nueva versión de Vitsy , 11 bytes

v'rd3 *} v) rZ
v Capture la entrada como una variable.
 'Captura la fuente hasta encontrar a otra'
  r Invierta la pila.
   d3 * Empuje 'a la pila.
      } Gire la pila hacia la derecha.
       v) Empuje la variable (entrada) a la pila y pruebe si no es cero.
         r Si es así, invierta la pila.
          Z Salida de todo en la pila.

Javascript (ES6), 42 bytes

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

Esta es una modificación de mi Bling Quine . También es el doble de largo.

Burlesque, 40 bytes

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

Explicación:

Burlesque cuenta con funciones avanzadas de manipulación de código y pila. De hecho, no puede acceder al código fuente del programa, pero puede acceder al código restante que se ejecutará en el futuro. Esto significa #Qque devolverá todo el código que le sigue, por lo que tenemos que agregar todo #Qa ese código, que es con lo que estamos haciendo ri#Q.

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

++1 2es un código técnicamente ilegal ya que está basado en pila. Pero podemos manipular el código para que se ejecute como 1 2++:

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

Trabajar con estos elementos integrados es increíblemente complicado y nadie los ha utilizado para nada productivo, excepto para cosas relacionadas con quine. Si inviertes ++1 2, obtienes 2 1++lo que produciría 21y no 12. La razón que produce el código anterior 12es porque #Qtambién incluye el<- lo que al final terminamos ejecutando mucho más que solo 2 1++: p. Terminamos ejecutando lo 2 1++#q<-que produce 12.

En realidad, podemos reemplazar cosas en nuestro código, por ejemplo, este código reemplaza todas las ocurrencias de ?+ sí mismo con?*

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 0o 1como entrada.

Minkolang 0.10 , 13 bytes

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

Pruébalo aquí

Esto es exactamente igual que el quine estándar a excepción de estas cuatro caracteres: n,?r. ntoma un número entero de la entrada, lo ,invierte, por lo que ?omite rsi la entrada es verdadera. De lo contrario, rinvierte la pila para que salga en orden inverso.

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

Pruébalo en línea.

Java 10 (como función 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;}

Pruébalo en línea.

Explicación:

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

explicación quine :

• El var scontiene el código fuente sin formato
• %s se utiliza para poner esta cadena en sí misma con s.format(...)
• %c, %1$cy 34se utilizan para formatear las comillas dobles
• s.format(s,34,s) lo pone todo junto

Y luego new StringBuffer(s).reverse()se usa para revertir la cadena de quine si es necesario en función de la entrada booleana.

05AB1E , 21 bytes

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

Pruébalo en línea.

La modificación de la forma predeterminada quine 0"D34çý"D34çý añadiendo ‚sè.

Explicación:

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)

PD: Imprime automáticamente una nueva línea final. Si esto también se invierte, son 23 bytes en su lugar:

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

Pruébalo en línea. ( ?es una impresión explícita sin nueva línea )