Considere una pregunta escrita en inglés simple cuya respuesta involucra dos palabras o frases razonablemente precisas (pero potencialmente inteligentes) que pueden separarse por la palabra 'y':

P: ¿Cuáles son las dos caras de una moneda? A: cabezas y colas

P: ¿Cuáles son las mejores formas de viajar? A: avión y jetpack

P: ¿Por qué un cuervo es como un escritorio? A: porque hay una 'b' en ambos y una 'n' en ninguno

Gol

Escriba un programa que, cuando se ejecuta normalmente, genera dicha pregunta.

Cuando todos los demás caracteres se eliminan del programa comenzando con el segundo carácter y el resultado se vuelve a ejecutar, la salida debe ser lo que esté a la izquierda de 'y' en la respuesta.

Cuando todos los demás caracteres se eliminan del programa comenzando con el primer carácter y el resultado se vuelve a ejecutar, la salida debe ser lo que esté a la derecha de 'y' en la respuesta.

(El 'y' en sí mismo no se emite).

Ejemplo

Si el programa es

A1B2C3D4E5F6G7H8I9

y su salida es

What are the two sides of a coin?

Entonces la salida de ABCDEFGHIdebería ser heads, y la salida de 123456789debería ser tails.

Reglas sobre preguntas y respuestas

• Puede usar mis preguntas de ejemplo, pero le animo a que haga las suyas.
• La pregunta y las dos partes de respuesta:
  • todos deben ser distintos
  • debe ser inglés gramatical común y significativo
  • solo puede contener ASCII imprimible (hex 20 a 7E)
• Idealmente, la pregunta se escribirá con mayúscula y puntuada (pero las respuestas no tienen por qué serlo).
• La pregunta debe tener al menos 30 caracteres y tener una entropía superior o igual a 3.5. (Escriba una cadena, presione calcular , busque la última H (X)) .
• Las dos partes de la respuesta (sin incluir la [space]and[space]entre ellas) deben tener al menos 5 caracteres con una entropía superior o igual a 2.
• La palabra 'y' puede aparecer en cualquier parte de la respuesta.

Reglas sobre el código

• Ninguno de los 3 fragmentos de código puede:
  • contener comentarios o cualquier otra cosa que el compilador / intérprete ignora tradicionalmente (no se preocupe por poner un punto y coma adicional o dos, pero si cree que es un comentario, probablemente lo sea)
  • salir del programa a mitad de ejecución
• El código puede contener caracteres, incluidos Unicode y ASCII no imprimible.
• Puede tener un número par o impar de caracteres.
• La salida va a stdout o un archivo o lo que parezca razonable. No hay entrada

Tanteo

Dado que no quiero alentar las respuestas de golf pero quiero alentar aún más las respuestas inteligentes, la puntuación será algo entre el código de golf y el concurso de popularidad:

Puntuación = (upvotes - downvotes) - floor((bytes in code that outputs question) / 3)

El puntaje más alto gana.

(Utilice http://mothereff.in/byte-counter como contador de bytes).

Javascript (148 bytes)

Crea algunos literales sin sentido, con el efecto secundario de crear una alerta * para la pregunta. (las divisiones hacen algo similar, pero crean alertas * para cada una de las respuestas).

"';"+alert( 'What is the ideal breakfast???')+/ " ;apl=e"rbta(k"esnc"r.armebplleadc ee g g s(" ) + " \/)k;e"/+ ",t'hceo 'c)a;kye= ailse rat (lpi)e "

Splits:

";+lr('hti h da rafs??)/";p="baken".replace   (    /ke/ ,'co');y=alert(p) 

y

'"aet Wa steielbekat?'+  alert("scrambled eggs")+"\);"+"the cake is a lie"

Pregunta: What is the ideal breakfast???

Respuestas: baconyscrambled eggs

Brainfuck (437 caracteres)

Tengo que confesar que este es mi primer programa de brainfuck que realmente hace algo significativo. El programa está altamente optimizado para sistemas con poca memoria ya que usa solo 4 ubicaciones de memoria.

Pregunta: What are the two main groups of trees?

Respuestas: conifersybroadleafs

-+[[++++++++++++++++++++++[+>++++++[+>++++++++++++<>-+]+>+-+.++++++<+<+-+]+>+++++.+>++.+-..------.-<--..-+-+-+..->.-+-+-+.+<+++.+-+-+-+-+.++++.+++.+<.+>-+++-+++-+++-++.->]]++-+[[+-+-[[+++++++++++++++[>++>+++++>+++++++<<<-]>-->>---<++.+++++++++++++++++.-------.>.<<.>.>--.<++++.<.>>++.<+++.---.<.>>.+++.<++++++++++.<.>--.------------.++++++++.+++++.<.>-------.>-----.<++++++++.>+++.<+.>--.<<.>-.---------.<.>>+.--.<-..>+.<<[<++>-]<-.<]]]]

Bucle principal

El programa consta de un bucle principal (que no es realmente un bucle ya que todos los bloques [] se ejecutan solo una vez) y dos secciones.

-+[[        // let answers enter
            * SNIP interleaved answer sections *
]]
++-+[[      // let odd answer and question enter
    +-+-[[  // let question enter
            * SNIP question section *
    ]]
]]

Si desea probar secciones de forma independiente, debe tener en cuenta el bucle principal. La ubicación 0 contiene -1 en respuesta par, 1 en respuesta impar y 2 en la sección de preguntas.

Sección de respuestas

Respuesta par (instrucciones extrañas eliminadas)

// location 0 contains minus 1 from main
// set location 1 = 10 * 10 minus 1 = 99 (c)
+++++++++++[>++++++++++<-]>-. // c
++++++++++++.-.     // on
-----.---.          // if
-.+++++++++++++.+.  // ers
<                   // goto 0 (which contains 0)
+-+-+-+-+-          // padding to match length of odd answer

Respuesta impar (incluso las instrucciones eliminadas):

// location 0 contains 1 from main
// set location 1 = 16 * 6 plus 2 = 98 (b)  location used for characters below 'l'
// set location 2 = 16 * 7 plus 2 = 114 (r) location used for 'l' and above
+++++++++++++++[>++++++>+++++++<<-]>++.>++. // br
---.<               // o
-.+++.              // ad
>---.<              // l
+.----.+++++.       // eaf
>+++++++.           // s
>                   // goto 3 (which contains 0)

Sección de preguntas

Decidí almacenar espacio para separar la ubicación porque su valor difiere drásticamente de otros personajes. Esto permite que el espacio se imprima simplemente con <.>.

// location 0 contains 2 from main
// set location 1 = 17 * 2 minus 2 = 32 (space)
// set location 2 = 17 * 5 plus 2 = 87 (W)   location used for characters below 'r'
// set location 3 = 17 * 7 minus 3 = 116 (t) location used for 'r' and above
+++++++++++++++[>++>+++++>+++++++<<<-]>-->>---<++. // W
+++++++++++++++++.  // h
-------.>.<         // at
<.>                 // (space)
.>--.<++++.         // are
<.>                 // (space)
>++.<+++.---.       // the
<.>                 // (space)
>.+++.<++++++++++.  // two
<.>                 // (space)
--.------------.    // ma
++++++++.+++++.     // in
<.>                 // (space)
-------.>-----.     // gr
<++++++++.>+++.     // ou
<+.>--.<            // ps
<.>                 // (space)
-.---------.        // of
<.>                 // (space)
>+.--.<-..>+.       // trees
<<[<++>-]<-.<       // ? (value_of_space * 2 minus 1)

Actualización final

En mi actualización final, optimicé las multiplicaciones para que se usen instrucciones mínimas. También incluir 'l' al segundo grupo de personajes en la sección de respuestas impares demostró ser una gran mejora. El ahorro de un solo carácter en respuesta impar básicamente significa dos caracteres de todo el programa, ya que también reduce el relleno de la respuesta par. También eliminé un par de instrucciones innecesarias de aquí y de allá y no creo que pueda optimizar el código más.

Lote - 84

Bastante orgulloso de este

Programa completo: ¿Cuáles son las dos caras de una moneda? (consola)

echo What are two sides of a coin?  2>>xx  2>>cc&&eecchhoo  hteaaidlss  2>>xx  2>>cc

Evens only: heads (archivo 'c')

eh htaetosdso  on 2>x >c&echo heads 2>x >c

Solo probabilidades: colas (archivo 'x')

coWa r w ie faci? >x 2>c&echo tails >x 2>c

Funciona redirigiendo la salida del error a un archivo en ambos casos.

Python - 104 96 (golfizado: 76)

Mi solución es bastante simple (y de alguna manera legible):

"";print 'What is the color of a zebra?' ;""
paraianat= "' b l a c k '"
aparaianat="'w h i t e'"

Salida:

What is the color of a zebra?
black
white

Honestamente, encontré la idea de la primera línea en la respuesta de Bitpwner.

Alternativa aún más legible: 113 105 97

"";print 'What is the color of a zebra?' ;""
"p r i n t ' b l a c k '" ;"p r i n t ' w h i t e '"

Alternativa aún más corta: - 86 76

"";print'What is the color of a zebra?';""
"""";;pprriinntt''bwlhaictke''"""

Rebmu : 79 caracteres O (37 + longitud (p1) + 2 * max (longitud (p2), longitud (p3)))

Primero daré una solución de 79 caracteres que pregunta ¿Qué idiomas debes aprender? (entropía 4.0, 30 letras no incluidas ?) y le ofrece las sugerencias de Rebol y [Rojo] :

DD  11  DD :do dd {dd  {p{Which languages must you learn?}qt}} pp{{[RReebdo]l}}

Una táctica única disponible aquí que no está en otros idiomas proviene de aprovechar el hecho de que las llaves son un delimitador de cadenas asimétrico, que puede anidar legalmente:

my-string: {"It's cool," said {Dr. Rebmu}, "for MANY reasons--like less escaping."}

Eso me permite producir una solución generalizada, que puede funcionar sin esfuerzo en cualquier programa que no use secuencias de escape. La versión de 79 caracteres era lo suficientemente simple como para un acceso directo, pero para contener adecuadamente la fuente de programa arbitraria para los programas p2 y p3 necesitaría la plantilla completa. Si hubiéramos usado eso, habrían sido 87 caracteres:

DD  11  DD :do dd {dd  {p{Which languages must you learn?}qt}} ddoo{{pp{{[RReebdo]l}}}}

El patrón para utilizar esta forma general es que si tiene tres textos fuente de caracteres secuenciales de longitud variable (Usemos un ejemplo como AAA, BBBBB, CCCCCCC) se puede codificar como algo a lo largo de las líneas de:

DD  11  DD :do dd {dd  {AAAqt}} ddoo{{BCBCBCBCBC C C}}

(Nota: aunque este patrón no funcionará sin modificar los programas que usan caracteres de escape, esto no es un defecto fatal. Obtener un paréntesis izquierdo sin igual en una cadena delimitada por llaves requiere algo como {Foo ^{ Bar}... pero podría reescribirlo fácilmente usando la notación de cadena alternativa "Foo { Bar", y los casos combinados se pueden manejar pegando una mezcla de cadenas sin escape).

Entonces ... ¿qué tal un ejemplo? Una vez que el formulario general estuvo disponible, este programa de 573 caracteres se ensambló en solo un par de minutos a partir de 3 soluciones de golf de código anteriores:

DD 11 DD: do dd {dd {rJ N 0% rN Wa1m2j S {\ x /} D00 Hc & [u [Ze? Wa Qs ~ rpKw [isEL00c [skQd2k] [eEV? KQ [tlQ]] pcSeg - b00 [ eZ 1 5] 3] prRJ [si ~ dSPscSqFHs] eZ 1 [s + dCa + wM2cNO]]] Va | [mpAp2j] prSI ~ w { } Ls2w Wl h01tiVsb01n -1 chRVs { } hLceVn01qt}} ddoo {{BrdCz [{BrbCz [ [sn [{N sbeo [tIt0l1eV} 0e5gXN1 01L {5s0} C {1} 0 {0 Do5f0 0bMe1e0r0} 0]]] tMw9C9 Numz Jl [paN + [KperlCJBn [[ba sWS {B noJn Nt0hJl jl jl)] {K, j} b P {. } lf EZ - - n [N m {G otothtoreandbuysome more}] {T akeonedowna and passitar ound} c B w P lf]]}}

• Si no modifica el programa, es la solución de reloj de arena .

• Si toma solo los caracteres extraños y lo ejecuta, imprimirá las 99 botellas de poema de cerveza

• Solo los personajes pares harán una pequeña conversión de números romanos por ti.

Si alguien quiere intentar escribir ese programa en el idioma de su elección y cree que puede vencer a 573, avíseme. Si lo haces, te recompensaré con una gran cantidad de reputación, suponiendo que tu idioma de elección no sea Rebmu, porque sé que esos programas no son mínimos. :-)

Ese espaciado "derrochador" que obtienes al final es lo que sucede cuando p2 y p3 tienen longitudes desequilibradas. Pero los 3 programas son de diferentes tamaños en este caso, por lo que no hay un buen emparejamiento particular para elegir para p2 / p3. (Los elegí porque no había datos externos como entrada, como un laberinto o lo que sea, no es que fueran de longitudes similares. Si bien podría haber escrito nuevos programas que fueran más óptimos, he pasado suficiente tiempo y el punto era usted no tiene que escribir nuevos programas ...)

Cómo funciona

(Nota: comencé con un enfoque más "creativo" que no era tan simple pero de aspecto más interesante. Lo moví a una entrada en mi blog, ya que describir este enfoque ya es largo).

Una clave aquí es el truco de "evaluar el código como una cadena" como algunas otras entradas, solo tiene la carta de triunfo del delimitador de cadena asimétrica. Comenzaré explicando el funcionamiento del caso de 80 caracteres.

Aquí está el programa "completo", ajustando el espacio en blanco para la legibilidad de este caso:

DD 11                    ; assign 11 to dd (about to overwrite again)
DD :do                   ; make dd a synonym for DO (a.k.a. "eval")

; eval a string as source code that ends with QUIT (QT)
dd {dd  {p{Which languages must you learn?}qt}}

; we'll never get here, but whatever's here must be legally parseable
pp{{[RReebdo]l}}

Aquí terminamos configurando DD como sinónimo de DO (también conocido como "eval"). Pero el truco es que cuando se ejecutan los programas reducidos a la mitad, terminan ejecutando código cuyo único efecto es definir D en el inofensivo literal 1.

Esto es lo que hace el código de caracteres impares, el espacio en blanco nuevamente ajustado:

D 1                      ; assign 1 to d
D d                      ; assign d to itself, so it's still 1
d                        ; evaluates to integer, no side effect
{d pWihlnugsms o er?q}   ; string literal, no side effect
p {Rebol}                ; print "Rebol"

Y aquí está el código de caracteres pares:

D 1                      ; assign 1 to d
D:od                     ; URL-literal (foo:...), no side effect
d                        ; evaluates to integer, no side effect
{{hc agae utyulan}t}     ; string literal (well-formed!), no side effect
p {[Red]}                ; print "[Red]"

Es realmente el caso de que para el programa no reducido a la mitad, dd {dd {(arbitrary code)qt}}ejecutará el código que desee. Sin embargo, hay dos llamadas para evaluar en lugar de solo una. Esto se debe a que, si bien las llaves anidadas funcionan muy bien en el código intercalado, arruinan el comportamiento de evaluación de DO. Porque:

do {{print "Hello"}}

Cargará la cadena como un programa, pero ese programa termina siendo solo la constante de la cadena {print "Hello"}. Por lo tanto, el truco que uso aquí es tomar mi DD (que tiene el mismo valor de función que DO) y ejecutarlo dos veces. Las mitades mastican las diferentes partes de la cadena, pero no mastican ambas si la par / impar es correcta para el contenido, y porque lo que queda fuera de la cadena después de la mitad es solo la constante integral d, son inofensivas.

Con este patrón no hay ningún desafío en escribir el comportamiento del programa cuando no se reduce a la mitad: puede poner cualquier cosa siempre que la longitud del código sea uniforme (impar si cuenta el QT, que es QUIT). Si necesita obtener el número par de uno impar, agregue un espacio (por lo que en realidad hay un +1 en mi fórmula anterior en p1 para longitudes impares de programa de p1) . El truco parecería escribir ese código intercalado después, que debe pasar el analizador si no se reduce a la mitad. (No se ejecutará debido al QT, pero debe CARGARSE antes de ejecutarse).

Este caso es trivial; ppse carga bien como símbolo aunque no esté definido, y se divide en ppara imprimir en cada medio programa. Pero podemos hacer otro truco simplemente usando una cadena literal nuevamente. Los programas a la mitad todavía tienen DO definido normalmente, por lo que también podríamos haber dicho:

ddoo{{pp{{[RReebdo]l}}}}

Al hacer que la única parte recogida por el analizador en todo el caso sea la palabra simbólica ddooy un literal de cadena, podemos intercalar cualquiera de los dos programas que deseamos dentro de ese literal de cadena y no enojar al analizador. Las versiones reducidas a la mitad solo dirán:

do{p{Rebol}}

..y...

do{p{[Red]}}

Como digo, esta parte parece familiar a otras soluciones que tratan los programas como cadenas y los evalúan. Pero en el caso de la competencia, cuando los programas que está empaquetando contienen cadenas anidadas, eso les arroja llaves. Aquí, las únicas cosas que lo meterán en problemas son el uso de escapar a través de carets ( ^) ... que puede solucionarse fácilmente.

(Pequeña nota de 'trampa': agregué QT para "QUIT" en respuesta a este problema. En realidad, había eliminado a propósito la abreviatura para dejar de fumar antes ... porque de alguna manera pensé que solo era bueno para el uso de la consola y simplemente retomando el espacio de dos letras si no estaba en un REPL. Lo agrego porque veo que estaba equivocado, no lo agregué para este caso en particular. Sin embargo, antes de ese cambio, habría sido 2 caracteres más. Además, cuando publiqué la solución por primera vez, había un error en Rebmu que impedía que funcionara aunque debería haberlo hecho ... ahora funciona).

Perl 186 139 135

"";print'What are the best things in life?';""&&pprriinntt("'hceraurs ht hyeo ulra meennetmaiteiso'n s   o f   t h e i r   w o m e n ")

¿Cuáles son las mejores cosas de la vida?

"pitWa r h ettig nlf?;"&print('crush your enemies'                 )

aplastar a tus enemigos

";rn'htaetebs hnsi ie'"&print"hear the lamentations of their women"

escuchar las lamentaciones de sus mujeres

Usando respuestas menos largas:

Perl 79 72

"";print'What are my preferred weapons?';""&&pprriinntt("'smwaocredss'")

What are my preferred weapons?(30 Byte, H (X) = 3.76) swords(H (X) = 2,25) y maces(H (X) = 2,32)

Python - 139 103

"";print'What are the ingredients for success?';""; ";" ;id=='"RUaniincboorwnss'";;pprriinntt  id++"'"'

What are the ingredients for success?-> UnicornsyRainbows

Prueba:

c="\"\";print\'What are the ingredients for success?\';\"\"; \";\" ;id==\'\"RUaniincboorwnss\'\";;pprriinntt  id++\"\'\"\'"
exec c        # What are the ingredients for success?
exec c[::2]   # Unicorns
exec c[1::2]  # Rainbows
print 
print c[::2]  # ";rn'htaeteigeinsfrsces'";"";d="Unicorns";print d+''
print c[1::2] # "pitWa r h nrdet o ucs?;" ; i='Rainbows';print i+""

Versión antigua:

# What are the ingredients for success?
"";print(('What are the ingredients for success?'));""; ";" ;"pHrEiRnEt (C'OUMnEiSc oZrAnLsG'O)"; ";" ; "p,r iTnOtN(Y' RTaHiEn bPoOwNsY'.)"
# Unicorns
";rn('htaeteigeinsfrsces')";"";print('Unicorns');"";", TONY THE PONY."
# Rainbows
"pit(Wa r h nrdet o ucs?);" ; "HERE COMES ZALGO" ;  print('Rainbows')

Haskell, 117

Tener que trabajar con el paradigma funcional de Haskell significa que todo tiene que asignarse a una variable o comentarse con comentarios de línea --o bloque {- -}; tener funciones sin sentido ejecutadas sin asignación está fuera. Entonces, para mantenerme cuerdo, mantuve la pregunta y las respuestas tan cortas como lo permitieron las reglas.

Pregunta: ¿De qué no puedo tener suficiente?

main=putStrLn{---}"What can I not have enough of?"{- }
=u"Scrank=e"sS"h
omeasi"n
=mpauitnS=tpru taSntprt tmLi

-----}

"Zapatos" y "pasteles":

mi=uSrn--"htcnInthv nuho?{ 
uSrn="Shoes"
main=putStr mi
--}

anpttL{-}Wa a  o aeeog f"-}="cakes"
main=putStr anpttL
---

NB La aparición de crankdebajo de "¿De qué no puedo tener suficiente?" no debe ser visto como significativo.

Lisp (76 caracteres)

Pregunta de 31 caracteres, 6 caracteres en cada respuesta ⟹ longitud - carga útil = 33

'(: (pprriinncc''fmuacghesnitaa))':(princ "What is your favorite pink hue?")

Quería usar "¿Cuál es tu color favorito?", Pero incluso se extendió a la ortografía británica, solo alcanzó el mínimo de 30 caracteres para la longitud de la pregunta, y necesitaba una pregunta de longitud impar para equilibrar las comillas dobles.

Dicen que Common Lisp es detallado, pero no pensarías que lo harías de esta manera. Ni siquiera está muy ofuscado, solo necesita insertar un poco de espacio en blanco para ver qué se cotiza y qué se ejecuta.

Muchas implementaciones de Lisp gritarán los colores, porque deforman los símbolos en mayúsculas. Si eso te molesta, cambia ''fmuacghesnitaaa ""fmuacghesnitaa"".

STATA 295

Pregunta: ¿Cuáles son los mejores postres para hornear en este momento? Respuesta: brownies y galletas.

Explicación: Los comandos en STATA están delimitados por nuevas líneas.
Mientras que "//" es un comentario en STATA, "///" le dice al compilador que continúe a la siguiente línea e incluya su contenido en el comando actual.

Los comandos en STATA a menudo se pueden abreviar hasta el punto en que se consideran lo suficientemente únicos como para ser diferenciables (por lo que "generar" se convierte en "g", "global" se convierte en "gl" o "glo", "captura" se convierte en "cap", " mostrar "se convierte en" di ", etc.). El comando de visualización muestra texto en la pantalla. El comando de captura captura todos los errores (incluidos los errores de sintaxis), por lo que este programa se compila correctamente.

Supongo que si quieres ser exigente, el compilador ignora cualquier "/" adicional después de los primeros 3 consecutivos en una línea. Además, en el programa "brownies", técnicamente + "" es un comentario. Pero afirmo que todavía cuenta porque el comando de captura aún lo habría hecho irrelevante incluso si no fuera un comentario.

Gracias por leer mi larga explicación. Ahora para el código:

"¿Cuáles son los mejores postres para hornear en este momento?"

g   a = "g   q   /b/a/" 
g l= "b = ""b r o w n i e s "
g   c = "g   /b/a/" 
g lpo= "d = ""c o o k i e s "
g   e = "c a p  "  /////
 +  "d i ""$ b "
g   f = "c a p  "  /////
 +  "d i ""$ d "
g   g = "c a p  "  /////
 + "c a p   / / /  "+ "/ / /"
di "What are the best desserts to bake right now?"

"Brownies"

g a="    ba"
gl b="brownies"
    g /// 
 p="  "       
g e="   " //
 di "$b"
    cap ///
+" "  
g g="   " //
  cap ///   +"  "
i"htaetebs esrst aergtnw"

"galletas"

    g q /// 
 ="  "        
g c="  ba"
glo d="cookies"
    cap ///
+" "  
g f="   " //
 di "$d"
    cap  ///
+ "       " ///
d Wa r h etdset obk ih o?

Ksh (82 caracteres)

Pregunta de 35 caracteres, 5 caracteres en cada respuesta ⟹ longitud - carga útil = 37

ec=\'o'(;)eehc(h)oe cChroi m$e1;; '\'
echo  What\'s the  country\'s worst problem?

Abuso de la sintaxis de definición de función más allá de POSIX. Dash y bash no pueden soportarlo, pero ksh (dominio público o ATT) sí.

No pasa nada notable, solo un poco de eco. No desperdicies, no quieras.

PowerShell 88

"" > $x;{What is my favorite equipment?};"" >> ${x}

${XsXwXoXrXdX};;;${XsXhXiXeXlXdX}

¿Cuál es mi equipo favorito? (30 caracteres, H (X) = 4.0314)

"  x{hti yfvrt qimn?;"> {}
{sword};$XXXXXXX

espada (5 caracteres, H (X) = 2.32193)

">$;Wa sm aoieeupet}" >$x
$XXXXXX;;{shield}

escudo (5 caracteres, H (X) = 2.58496)

En el programa completo, redirige las cadenas vacías a una variable inexistente ${x}(las comillas para esas cadenas vacías se utilizan para formar una cadena sin sentido que se redirige a un bloque vacío o a una {}variable inexistente $xen las versiones pares / impares), luego imprime la pregunta y declara 2 variables no utilizadas (que se imprimen y colocan al lado de otra variable no utilizada $XXXXXXo $XXXXXXXen los diferentes casos).

GolfScript, 51 bytes

"Which are the sides of a coin? ".;""thaeialdss""

Salida

Which are the sides of a coin? 

Cómo funciona

.;duplica la cadena y elimina la copia. ""empuja una cuerda vacía. thaeialdssno está definido, por lo que no hace nada.

Caracteres extraños

"hc r h ie faci?";"heads"

Salida

heads

Cómo funciona

; elimina la primera cadena de la pila.

Incluso caracteres

Wihaetesdso  on ."tails"

Salida

tails

Cómo funciona

Wihaetesdsoy onson noops. .duplica la cadena vacía en la pila.