Cotizaciones inversas

29

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 , por lo que la respuesta más corta en bytes gana.
Geza Kerecsenyi
fuente
¿Se permiten citas sin igual y, de ser así, cómo se deben manejar?
negativo siete
3
@GezaKerecsenyi Entonces, ¿se requiere un separador, o podemos simplemente concatenar las cadenas?
Erik the Outgolfer
9
¿Cómo es que una matriz no es un formato legible por humanos?
Wheat Wizard
44
¿Deben enviarse las cadenas en el mismo orden en que aparecen en nuestro código?
Shaggy
1
Creo que esto habría sido un poco más complejo si tuvieras que imprimir lo que no estaba en las citas
Jo King

Respuestas:

28

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
siete negativo
fuente
55
print(";print('print()');")también es de 27 bytes, y también Python 3.
tsh
2
@tsh Este código revela una solución Python 2 de 20 bytes que debería haber sido obvia en retrospectiva, ¡muy agradable!
negativo siete
19

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 ...

tsh
fuente
Parece que body:aftertambién funciona en algunas implementaciones?
Shieru Asakoto
@ShieruAsakoto Tienes razón. :afterestá disponible en la mayoría de los navegadores por razones de compatibilidad con versiones anteriores
tsh
@Shaggy Pero es difícil definir cómo funciona "ajustar el código fuente con comillas" cuando se proporcionan tanto HTML como CSS.
tsh
@tsh Está bien: no especifiqué sobre varios archivos en las reglas, ¡ya que no esperaba una respuesta tan única!
Geza Kerecsenyi
10

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.

tsh
fuente
77
Quizás esta sea la respuesta HQ9 + más larga en este sitio. (?)
tsh
1
"Se requiere un comportamiento indefinido de C para terminar el programa" El comportamiento indefinido es indefinido : puede hacer cualquier cosa.
Solomon Ucko
De acuerdo con la página 4 del estándar C18 : "El posible comportamiento indefinido varía desde ignorar la situación por completo con resultados impredecibles, hasta comportarse durante la traducción o la ejecución del programa de una manera documentada característica del entorno (con o sin la emisión de un mensaje de diagnóstico) ), para finalizar una traducción o ejecución (con la emisión de un mensaje de diagnóstico) ".
Solomon Ucko
@SolomonUcko Pero definimos un lenguaje por su compilador / intérprete en este sitio. Y la respuesta está bien siempre que al menos un compilador / intérprete pueda producir el resultado correcto.
tsh
9

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)
Kevin Cruijssen
fuente
Desafortunadamente, esto viola la regla # 2. Si bien está bien tener algunas comillas vacías en su código, debe haber al menos una que no esté vacía, tanto en forma con y sin forma.
Geza Kerecsenyi
@GezaKerecsenyi Vaya, lea más allá de la parte " en forma de comillas y sin comillas ". Debería arreglarse ahora.
Kevin Cruijssen
6

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.

Lanudo
fuente
3
Tenga en cuenta que 4 es el puntaje mínimo para esta pregunta, ya que menos viola las restricciones.
Jo King
5

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

Encarnación de la ignorancia
fuente
Split()-> Trim(), y var a->_
negativo siete
1
@negativeseven ¡Gracias, nunca hubiera pensado en usar un descarte!
Encarnación de la ignorancia
1
@negativeseven En realidad, mi solución ni siquiera tenía que ser tan complicada, mira mi última edición
Encarnación de la ignorancia
64 bytes utilizando un método de extensión. Bastante sorprendido de que esto haya funcionado tan bien.
negativo siete
1
@negativeseven ¡Gracias! Y usted me dio una idea para la segunda parte del desafío: Estaba capturando el exterior en una variable y luego usando Removey Inserten él, ya que sólo puede utilizar un método de extensión!
Encarnación de la ignorancia
4

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.

Jo King
fuente
2
No lo creo. Es solo que p6 le permite decir (ha) decir $ foo y $ foo.say lo que lo hace mucho más fácil.
user0721090601
4

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.

jimmy23013
fuente
" Hmm ... Foo es un lenguaje altamente adaptable " . Para cualquiera que no conozca Foo: todo lo que se encuentra entre comillas dobles se emite y todo lo demás (excepto algunos otros caracteres incorporados) son no-ops. " El lenguaje perfecto para el trabajo " es un eufemismo aquí. ;)
Kevin Cruijssen
2
Entonces, básicamente, ¿simplemente estafar cualquier otra solución para este desafío?
Shaggy
@Shaggy El idioma es Foo. Casi todo con al menos un par de citas y ambos resultados esperados no vacíos funciona en Foo en este desafío. Así "a"b 1"2"también funciona en Foo. La única respuesta en este desafío que no es un políglota de Foo hasta ahora es en HQ9 +, porque el intérprete de Foo también tiene el problema desbordado.
jimmy23013
4

> <> , 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
tjjfvi
fuente
55
¡Bienvenido a Code Golf!
Stephen
@Stephen Gracias!
tjjfvi
2

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).

Draco18s
fuente
¡Respuesta súper rápida! Me pregunto si entendí mal algo acerca de su presentación, pero para mí no se imprime $;al final en la versión citada.
Geza Kerecsenyi
Me di cuenta de eso al volver a leer y estoy tratando de descifrar si Runic puede ejecutar ese bit. Comenzando a investigar citas "no emparejadas" ahora; por ejemplo, "$;y ""$;"(citas rúnicas envolventes emparejándose con ellos mismos).
Draco18s
@GezaKerecsenyi Avíseme si mi programa actualizado viola alguna regla.
Draco18s
Umm .. ¿Cómo es esto válido? Su programa sin cotizaciones de salida !.(que es correcto), pero ¿no debería su programa con cotizaciones de salida 0$;? PD: No conozco en absoluto los encantamientos rúnicos, pero una solución potencial basada en su diseño actual que creo que es válida sería 0"!""$;"$;(que sale!$; como está o sale0$; si está entre comillas). EDITAR: En realidad, creo que puede soltar el 0y la salida !$;y $;.
Kevin Cruijssen
1
@KevinCruijssen $es "imprimir la parte superior de la pila" y ;finaliza. Pero esencialmente tienes una respuesta válida.
Draco18s
0

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

Encarnación de la ignorancia
fuente
¡Ejem!
Shaggy
@Shaggy Nuestras soluciones son un poco diferentes, hay muchas soluciones diferentes para este desafío
Encarnación de la ignorancia
Uso en Qlugar de P, es más meta! ;)
Shaggy
0

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)

James Otto
fuente
Es posible que desee agregar una nota de que el programa vinculado es la versión no ajustada.
Jonathan Frech
También agregaría una nota sobre los espacios iniciales y finales. Es difícil notarlos de otra manera.
mbomb007
Editado, gracias por las sugerencias!
James Otto
0

AppleScript, 9 bytes

return"&"

Explicado:

return"&"    -- returns "&"

Citado:

"return"&""  -- implied return of the string "return" concatenated with ""
un arácnido de piedra
fuente