Considere uma pergunta escrita em inglês comum cuja resposta envolva duas palavras ou frases razoavelmente precisas (mas potencialmente inteligentes) que podem ser separadas pela palavra 'e':

P: Quais são os dois lados de uma moeda? A: cara e coroa

P: Quais são as melhores maneiras de viajar? A: avião e jetpack

P: Por que um corvo é como uma escrivaninha? A: porque existe um 'b' em ambos e um 'n' em nenhum

Objetivo

Escreva um programa que, quando executado normalmente, produz essa pergunta.

Quando todos os outros caracteres são removidos do programa começando com o segundo caractere e o resultado é executado novamente, a saída deve ser o que estiver à esquerda do 'e' na resposta.

Quando todos os outros caracteres são removidos do programa começando com o primeiro caractere e o resultado é reexecutado, a saída deve estar à direita do 'e' na resposta.

(O 'e' em si não é produzido.)

Exemplo

Se o programa for

A1B2C3D4E5F6G7H8I9

e sua saída é

What are the two sides of a coin?

Então a saída de ABCDEFGHIdeveria ser headse a saída de 123456789deveria ser tails.

Regras sobre perguntas e respostas

• Você pode usar minhas perguntas de exemplo, mas eu recomendo que você faça as suas.
• A pergunta e as duas partes da resposta:
  • todos devem ser distintos
  • deve ser um inglês gramatical significativo e comum
  • pode conter apenas ASCII imprimível (hex 20 a 7E)
• Idealmente, a pergunta será maiúscula e pontuada (mas as respostas não precisam ser).
• A pergunta deve ter pelo menos 30 caracteres e ter entropia acima ou igual a 3,5. (Digite a string, pressione calcular , procure o último H (X) .)
• As duas partes da resposta (sem incluir o [space]and[space] entre elas) devem ter pelo menos 5 caracteres com entropia acima ou igual a 2.
• A palavra 'e' pode aparecer em qualquer parte da resposta.

Regras sobre código

• Nenhum dos três trechos de código pode:
  • conter comentários ou qualquer outra coisa tradicionalmente ignorada pelo compilador / intérprete (não se preocupe em colocar um ponto e vírgula extra ou dois, mas se você acha que é um comentário, provavelmente é)
  • sair do programa no meio da execução
• O código pode conter qualquer caractere, incluindo Unicode e ASCII não imprimível.
• Pode ter um número ímpar ou par de caracteres.
• A saída vai para stdout ou um arquivo ou o que parecer razoável. Não há entrada.

Pontuação

Como eu não quero incentivar respostas para o golfe, mas quero incentivar ainda mais respostas inteligentes, a pontuação será algo entre o código-golfe e o concurso de popularidade:

Pontuação = (upvotes - downvotes) - floor((bytes in code that outputs question) / 3)

A pontuação mais alta vence.

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

Javascript (148 bytes)

Cria alguns literais sem sentido, com o efeito colateral de criar um alerta * para a pergunta. (as divisões estão fazendo o mesmo, mas criando alertas * para cada uma das respostas).

"';"+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 "

Divisões:

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

e

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

Questão: What is the ideal breakfast???

Respostas: baconescrambled eggs

Brainfuck (437 caracteres)

Eu tenho que confessar que este é o meu primeiro programa de foda cerebral que realmente faz algo significativo. O programa é altamente otimizado para sistemas com pouca memória, pois utiliza apenas 4 locais de memória.

Questão: What are the two main groups of trees?

Respostas: conifersebroadleafs

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

Laço principal

O programa consiste em loop principal (que não é realmente um loop, pois todos os blocos [] são executados apenas uma vez) e duas seções.

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

Se você deseja testar as seções de forma independente, deve levar em consideração o loop principal. O local 0 contém -1 na resposta par, 1 na resposta ímpar e 2 na seção de pergunta.

Seção de resposta

Resposta par (instruções ímpares removidas):

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

Resposta impar (mesmo as instruções removidas):

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

Seção de perguntas

Decidi armazenar espaço para separar a localização, pois seu valor difere drasticamente de outros caracteres. Isso permite que o espaço seja impresso simplesmente com <.>.

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

Atualização final

Na minha atualização final, otimizei multiplicações para que instruções mínimas sejam usadas. Também incluir 'l' para o segundo grupo de caracteres na seção de respostas ímpares provou ser uma grande melhoria. A economia de um caractere na resposta ímpar significa basicamente dois caracteres de todo o programa, pois também reduz o preenchimento da resposta par. Também removi algumas instruções desnecessárias daqui e de lá e acho que não posso otimizar ainda mais o código.

Lote - 84

Muito orgulhoso deste

Programa completo: Quais são os dois lados de uma moeda? (console)

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

Apenas pares: cabeças (arquivo 'c')

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

Apenas probabilidades: caudas (arquivo 'x')

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

Funciona redirecionando a saída de erro para um arquivo nos dois casos.

Python - 104 96 (golfed: 76)

My solution is rather simple (and somehow readable):

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

Output:

What is the color of a zebra?
black
white

Honestly, I found the idea for the first line in bitpwner's answer.

Even more readable alternative: - 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 '"

Even shorter alternative: - 86 76

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

Rebmu: 79 chars OR (37 + length(p1) + 2 * max(length(p2), length(p3)))

First I'll give a 79 character solution that asks Which languages must you learn? (entropy 4.0, 30 letters not including ?) and offers you the suggestions of Rebol and [Red]:

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

A unique tactic available here that isn't in other languages comes from taking advantage of the fact that curly braces are an asymmetric string delimiter, that can nest legally:

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

That let me produce a generalized solution, that can work effortlessly on any program that doesn't use escape sequences. The 79 character version was simple enough to shortcut, but to properly contain arbitrary program source for programs p2 and p3 you'd need the full template. Had we used that, it would have been 87 characters:

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

The pattern for using this general form is that if you have three source texts of sequential characters of variable lengths (let's use an example like AAA, BBBBB, CCCCCCC) you can encode them as something along the lines of:

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

(Note: Although this pattern won't work without tweaking on programs that use escape characters, this is not a fatal flaw. Getting an unmatched left brace in a string delimited by braces requires something like {Foo ^{ Bar}...but you could easily rewrite that using the alternative string notation "Foo { Bar", and combined cases can be managed with gluing together a mixture of unescaped strings.)

So...how about an example? Once the general form was available, this 573 character program was assembled in only a couple of minutes from 3 prior code golf solutions:

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{{BrdSz [fcebC[sn[{N sbeo[tIt0l1eV}0e5gXN1 01L{5s0}C{1}0{0 Do5f0 0bMe1e0r0}0]]]tMw9C9 Numz Jl[paN+[KperlCJBn[[ba sWS{B noJn Nt0h0e] jw]aJlnl]}aCd{K,j } b P { . } l f E Z - - n [ N m { G o t o t h e s t o r e a n d b u y s o m e m o r e } ] { T a k e o n e d o w n a n d p a s s i t a r o u n d } c B w P l f ] ] }}

• If you don't modify the program, it is the Hourglass Solution.

• If you take only the odd characters and run it, then it will print out the 99 bottles of beer poem

• Only the even characters will do a little Roman Numeral Conversion for you.

If anyone wants to try writing that program in their language of choice, and thinks they can beat 573, let me know. I will bounty you a heavy amount of reputation if you do--assuming your language of choice is not Rebmu, because I know those programs aren't minimal. :-)

That "wasteful" spacing you get at the end is what happens when p2 and p3 are of imbalanced lengths. But all 3 programs are different sizes in this case so there isn't a particular good pairing to pick for p2/p3. (I picked these because there was no external data as input, such as a maze or whatever, not that they were of similar lengths. While I could have written new programs that were more optimal, I've spent enough time and the point was you don't have to write new programs...)

How it works

(Note: I started with a more "creative" approach that was not as streamlined but more interesting-looking. I moved it to an entry on my blog as describing this approach is already long.)

A key here is the "eval code as a string" trickery like some other entries, it just has the trump card of the asymmetric string delimiter. I'll start by explaining the workings of the 80 character case.

Here's the "whole" program, adjusting the whitespace for this case's readability:

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

Aqui, definimos DD como sinônimo de DO (também conhecido como "eval"). Mas o truque é que, quando os programas cortados pela metade são executados, eles acabam executando código cujo único efeito é definir D para o literal inofensivo 1.

Aqui está o que o código de caracteres ímpares cria, o espaço em branco ajustado novamente:

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"

E aqui está o 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]"

Na verdade, é o caso de que, para o programa não dividido pela metade, dd {dd {(arbitrary code)qt}}ele executará o código que você desejar. No entanto, existem duas chamadas para avaliar em vez de apenas uma. Isso ocorre porque, enquanto os aparelhos aninhados funcionam muito bem no código intercalado, eles atrapalham o comportamento de avaliação do DO. Porque:

do {{print "Hello"}}

Carregará a string como um programa, mas esse programa acaba sendo apenas a constante da string {print "Hello"}. Portanto, o truque que uso aqui é pegar meu DD (mantendo o mesmo valor de função que DO) e executá-lo duas vezes. As metades mastigam as diferentes partes da cadeia, mas não as duas se a par / ímpar for correta para o conteúdo, e porque o que resta fora da cadeia após a divisão pela metade é apenas a constante integrald elas são inofensivas.

Com esse padrão, não há nenhum desafio em escrever o comportamento do programa quando ele não é cortado pela metade - você pode colocar qualquer coisa, desde que o comprimento do caractere do código seja par (estranho se você estiver contando o QT, que é QUIT). Se você precisar obter o número par de um número ímpar, jogue um espaço (para que haja um +1 na minha fórmula acima na p1 para comprimentos ímpares do programa de p1) . O truque parece escrever esse código intercalado posteriormente, que deve passar o analisador se for dividido pela metade. (Não será executado por causa do QT, mas precisa ser CARREGADO antes de ser executado.)

Este caso é trivial; ppcarrega bem como um símbolo, mesmo indefinido, e é dividido ppara impressão em cada meio programa. Mas podemos fazer outro truque usando uma string literal novamente. Os programas cortados pela metade ainda têm DO definido normalmente, então também poderíamos ter dito:

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

Tendo a única parte escolhida pelo analisador no caso todo, seja a palavra simbólica ddooe uma literal de cadeia, podemos então intercalar quaisquer dois programas que desejamos dentro dessa literal de cadeia e não irritar o analisador. As versões reduzidas ao meio dirão apenas:

do{p{Rebol}}

..e...

do{p{[Red]}}

Como eu disse, esta parte parece familiar para outras soluções que tratam programas como seqüências de caracteres e os avaliam. Mas, no caso da competição, quando os programas que você está embalando contêm seqüências aninhadas, isso é uma chave para eles. Aqui, as únicas coisas que o colocam em problemas são o uso de escapes por sinal de intercalação ( ^) ... que podem ser facilmente contornados.

(Pequena nota 'trapaça': eu adicionei QT para "QUIT" em resposta a esse problema. Na verdade, eu havia removido propositalmente a abreviação de desistir antes ... porque, de alguma forma, achei que era bom apenas para o uso do console e apenas ocupar o espaço de duas letras se não estivesse em um REPL. Estou adicionando porque vejo que estava errado, não o adicionando para este caso em particular. No entanto, antes dessa alteração, seriam 2 caracteres a mais. quando publiquei a solução pela primeira vez, havia um bug no Rebmu que a impedia de funcionar, mesmo que devesse ter ... agora 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 ")

Quais são as melhores coisas da vida?

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

esmagar seus inimigos

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

ouvir as lamentações de suas mulheres

Usando respostas menos longas:

Perl 79 72

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

What are my preferred weapons?(30Byte, H (X) = 3,76) swords(H (X) = 2,25) e 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?-> UnicornseRainbows

Teste:

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+""

Versão antiga:

# 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

Having to work with Haskell's functional paradigm means that everything has to be assigned to a variable or commented out with line -- or block {- -} comments; having nonsense functions run without assignment is out. So, to keep myself sane, I kept the question and answers as short as the rules allow.

Question: What can I not have enough of?

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

-----}

"Shoes" and "cakes":

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

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

N.B. The appearance of crank under "What can I not have enough of?" should not be viewed as meaningful.

Lisp (76 characters)

31-character question, 6 characters in each answer ⟹ length - payload = 33

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

I wanted to use “What is your favorite color?”, but even stretched to British spelling, it only just reached the 30-character minimum for the question length, and I needed an odd-length question to balance the double quotes.

They say Common Lisp is verbose, but you wouldn't think so going by this one-liner. It's not even very obfuscated, you only need to insert a bit of whitespace to see what's getting quoted and what's getting executed.

Many Lisp implementations will shout out the colors, because they warp symbols to uppercase. If that bothers you, change ''fmuacghesnitaa to ""fmuacghesnitaa"".

STATA 295

Question: What are the best desserts to bake right now? Answer: brownies and cookies.

Explanation: Commands in STATA are delimited by new lines.
While "//" is a comment in STATA, "///" tells the compiler to continue to the next line and include its contents in the current command.

Commands in STATA can often be abbreviated to the point where they are considered unique enough to be differentiable (so "generate" becomes "g", "global" becomes "gl" or "glo", "capture" becomes "cap", "display" becomes "di", etc.). The display command displays text to the screen. The capture command captures all errors (including syntax errors), which is why this program compiles properly.

I guess if you want to get picky, any additional "/" after the first 3 consecutive ones in a line are ignored by the compiler. Also, in the "brownies" program, technically +" " is a comment. But I claim that it still counts because the capture command would still have made it irrelevant even if it wasn't a comment.

Thanks for reading my really long explanation. Now for the code:

"What are the best desserts to bake right now?"

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"

"cookies"

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

Ksh (82 characters)

35-character question, 5 characters in each answer ⟹ length - payload = 37

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

I abuse the function definition syntax beyond POSIX. Dash and bash can't take it but ksh (public domain or ATT) can.

Nothing remarkable going on, just a bit of echo. Waste not, want not.

PowerShell 88

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

${XsXwXoXrXdX};;;${XsXhXiXeXlXdX}

What is my favorite equipment? (30 chars, H(X) = 4.0314)

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

sword (5 chars, H(X) = 2.32193)

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

shield (5 chars, H(X) = 2.58496)

On the full program it redirects empty strings to a nonexistent variable ${x} (the quotes for those empty strings are used to form a nonsense string that gets redirected either to an empty block {} or nonexistent variable $x on the even/odd versions), then prints the question and declares 2 unused variables (which are printed and placed next to another unused variable $XXXXXX or $XXXXXXX on the different cases).

GolfScript, 51 bytes

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

Output

Which are the sides of a coin? 

How it works

.; duplicates the string and deletes the copy. "" pushes an empty string. thaeialdss is undefined, so it does nothing.

Odd chars

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

Output

heads

How it works

; deletes the first string from the stack.

Even chars

Wihaetesdso  on ."tails"

Output

tails

How it works

Wihaetesdso and on are noops. . duplicates the empty string on the stack.