La perspectiva de este desafío es:

• Si su programa se ejecuta normalmente, se "debe imprimir todo el código en las marcas de voz ( - comillas dobles).
• Si su programa está entre comillas dobles (invirtiendo las marcas de voz), se debe imprimir el código que normalmente no está entre comillas.

P.ej:

Digamos que tiene el siguiente código:

fancyStuff("myCode"); "I like".isGreat();

Si lo ejecuto, esperaría una salida de:

myCode
I like

Sin embargo, si lo envuelvo entre comillas, obtendría:

"fancyStuff("myCode"); "I like".isGreat();"

Cuando se ejecuta este código, el resultado esperado sería:

fancyStuff(
); 
.isGreat();

Obviamente, el ejemplo anterior no es una respuesta funcional en ningún idioma. Su trabajo es escribir el código que se realiza de esta manera.

Reglas

• Se aplican lagunas estándar.
• Los valores impresos, tanto en forma de comillas como sin comillas, no deben estar vacíos o deben consistir únicamente en espacios en blanco. Esto también significa que todos los programas deben incluir al menos un conjunto de comillas.
• Sin embargo, se permite el espacio en blanco al final / anterior.
• Sin mirar su propio código, nombres de archivo requeridos, etc.
• Las citas sin igual no están permitidas
• Si hay varias cadenas, pueden imprimirse como nuevas líneas (como en el ejemplo) o de alguna otra manera legible para los humanos , sin matrices ni objetos
• Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Python 2 , 20 bytes

print";print'print'"

-7 bytes gracias a tsh

Pruébalo en línea!

Vieja respuesta:

Python 2 , 27 bytes

'';print";print 2*"'';print

Pruébalo en línea!

Tren de pensamiento detrás de esta respuesta:

Comience con una impresión simple, porque necesitamos imprimir algo .

print"a"

También necesitamos imprimir algo en el caso invertido, es decir. tener una impresión entre comillas.

print"print"

El caso no invertido es bastante bueno en este punto. Centrémonos en el caso invertido. Ahora comenzamos con la cadena print, que no puede ser seguida inmediatamente por una declaración de impresión. Arreglemos esto con un punto y coma.

print";print"

Buen material. Excepto que el código invertido en realidad no imprime nada. Necesitaremos imprimir el printal principio, porque termina entre comillas, pero también imprime lo que viene después de la segunda cita, porque también termina entre comillas. La forma obvia de evitar esto es agregar printy multiplicar la última cadena por 2.

print";print 2*"print

Ahora el código invertido funciona bien, aunque debemos tener cuidado con el hecho de que la sección antes de la primera cita y la sección después de la segunda cita deben mantenerse igual a lo largo de los cambios futuros. En cuanto al código no invertido, arroja un error de sintaxis; una vez más, necesitamos introducir un punto y coma para separar las expresiones.

;print";print 2*";print

A Python realmente no le gusta el aspecto de ese punto y coma solitario, por lo que debemos satisfacer el hambre de la serpiente con dos de la misma expresión no operativa, insertadas antes del primer punto y coma y el último punto y coma. La mayoría de las expresiones funcionarán bien en el primer caso, pero en el segundo caso debe seguir print";print 2*"el código no invertido sin romper nada. Podemos usar '', que simplemente se concatena con la cadena anterior.

'';print";print 2*"'';print

CSS, 66 bytes

body:after{content:"{}body:after{content:'body:after{content:}'}"}

"body:after{content:"{}body:after{content:'body:after{content:}'}"}"

CSS no puede resolver tantas preguntas ...

HQ9 + ^{[ver notas a continuación]} , 1016 bytes

"Hola Mundo""""""""""""""""""""""""""""""""""""""""""""""" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """"""""""""""""""""""""""""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """""""""""""""""""""""""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """""""""""""""""""""""""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """"""""""""""""""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """"""""""""""""""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """"""""""""""""""""""""""""""""""""""Hola Mundo"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " """"""""""""""""""""""""""""""""""""""Hola Mundo"""""""""""""""""""""""""""""""""""Hola Mundo"""""""""""""""""""""""""""""""""""Hola Mundo

Use la implementación en https://esolangs.org/w/index.php?title=HQ9%2B&oldid=59995 y compile el intérprete con MinGW GCC 5.3.0 en Windows. No estoy seguro de si funciona con otra versión del compilador, ya que se requiere un comportamiento indefinido de C para terminar el programa. El búfer tiene 1000 bytes de longitud. Y el código fuente mayor de 1000 bytes hace el truco. No estoy seguro de cómo sucedió esto.

05AB1E , 4 bytes

"A"§

Salidas concatenadas sin separador.

Pruébelo en línea o inténtelo en línea con citas circundantes .

Explicación:

        # Program without surrounding quotes will output string "A"
"A"     # Push "A" to the stack
   §    # Cast it to a string
        # (output the top of the stack implicitly as result)

        # Program with surrounding quotes will output string "§"
""      # Push an empty string to the stack
  A     # Push the alphabet to the stack: "abcdefghijklmnopqrstuvwxyz"
   "§"  # Push "§" to the stack
        # (output the top of the stack implicitly as result)

Japt , 4 bytes

"P"s

Pruébalo sin comillas o con comillas

Pes la variable Japt para la cadena vacía y el smétodo corta una cadena; sin ningún argumento, no hace nada.

O, aunque sea un poco menos trivial:

"+"u

Pruébalo sin comillas o con comillas

El primero en mayúsculas +y el segundo se agrega ua una cadena vacía.

C # (compilador interactivo de Visual C #) , 113 112 107 70 64 bytes

Write(".f();static void f(this string s){Write(s+')'+';');}//");

Guardado 5 bytes gracias a @negative seven

No citado y citado

Después de un tiempo, me di cuenta de que mi solución era demasiado complicada. El programa más nuevo que se muestra aquí simplemente oculta el resto del programa en un comentario para evitar errores cuando se envuelve entre comillas.

Cuando se envuelve entre comillas, Write(se pasa a un método de extensión, que lo imprime junto con );.

Perl 6 , 11 bytes

say ".say~"

Pruébalo en línea!

Imprime .say~con una nueva línea final. Parece muy fácil ¿Me estoy perdiendo de algo?

Cuando se envuelve entre comillas , produce saycon un espacio y una nueva línea final.

Foo , 4 bytes

"P"s

Pruébalo en línea! También funciona en Japt.

5 bytes (UTF-8)

"A"§

Pruébalo en línea! También funciona en 05AB1E.

9 bytes

"!""$;"$;

Pruébalo en línea! También funciona en encantamientos rúnicos.

11 bytes

say ".say~"

Pruébalo en línea! También funciona en Perl 6.

20 bytes

print";print'print'"

Pruébalo en línea! También funciona en Python 2.

69 bytes

body::after{content:"{}body::after{content:'body::after{content:}'}"}

Pruébalo en línea! También funciona en CSS.

Hmm ... Foo es un lenguaje altamente adaptable.

> <> , 18 9 bytes

"|o<"r>o|

-9 bytes gracias a Jo King

Pruébalo en línea! ( citado )

Explicación

"|o<"r>o|
"|o<"     Pushes the quoted characters onto the stack
     r    Reverses the stack
      >o| Outputs all characters on stack & errors

""|o<"r>o|"
""          No-op
  |         Reverses the IP direction
     "r>o|" Pushes the quoted characters onto the stack (backwards)
  |o<       Outputs all characters on stack & errors

Befunge-98 (FBBI) , 12 bytes

<@,k4"<@,k4"

No citado Citado

Ambos casos se imprimen <@,k4. Cualquiera (o ambos) de los @s pueden ser reemplazados en su qlugar.

Encantamientos rúnicos , 9 bytes

"!""$;"$;

Pruébalo en línea! y""!""$;"$;"

De Kevin Cruijssen, quien esencialmente arregló mi primer intento utilizando lo que hice en mi segundo.

Bajando por la regla de "fungoides nunca tienen comillas incomparables", hay algo en esto que no debería estar bien ", aludido en mi propio comentario:

7 bytes

0".""$;

Pruébalo en línea! y"0".""$;"

En circunstancias normales, este programa se ejecuta como 0".""$;0".""$;empujar un número entero 0, luego la cadena ., concatena $;0, NOP, concatena una cadena vacía, imprime la parte superior de la pila (la cadena .$;0) y termina. Envolverlo entre comillas produce lo "0".""$;"que empuja una cadena 0, NOP, concatena una cadena vacía, imprime la parte superior de la pila y termina (representando el entero previamente no impreso 0en forma de cadena). El último no "se ejecuta (y no forma parte del programa original de todos modos).

Los fungoides no tienen literales de cadena, tienen un comando que alterna el modo "leer la propia fuente como una cadena" y alguna forma de "puntero de instrucción ha alcanzado la regla del límite de la fuente" (generalmente ajuste de borde), por lo que el mismo código fuente -positional-byte actúa como instrucción de "inicio de cadena" y "final de cadena", creando un literal de cadena de toda la fila / columna (excluyendo la "propia).

Haskell, 31 bytes

putStr"#1;(#)=const<$>putStr--"

Pruébalo en línea! O entre comillas: ¡ Pruébelo en línea!

MathGolf , 4 bytes

";"q

Pruébalo en línea!

El ;y qse puede intercambiar por muchos comandos diferentes, incluidos los no operativos.

Rubí , 8 bytes.

p";p'p'"

Pruébalo en línea!

Envuelve la salida entre comillas, lo que puede ser ilegal.

Rubí , 17 bytes

puts";puts'puts'"

Pruébalo en línea!

JavaScript (SpiderMonkey) , 25 bytes

print("-print`print()`-")

Pruébalo en línea!

"print("-print`print()`-")"

Pruébalo en línea!

Trivial pero funcional.

Japt , 4 bytes

"P"u

Sin comillas, convierte la cadena Pa mayúsculas. Citado, se imprime u.

Intentalo

Japt , 4 bytes

"P"w

Sin comillas, invierte la cadena P. Citado, se imprime w.

Intentalo

R, 16 bytes

 ";print(";");" 

Tenga en cuenta que el código anterior no se incluye entre comillas adicionales y tiene espacios iniciales y finales.

Pruébelo (versión no envuelta)

AppleScript, 9 bytes

return"&"

Explicado:

return"&"    -- returns "&"

Citado:

"return"&""  -- implied return of the string "return" concatenated with ""