Considérez une question rédigée dans un anglais simple et dont la réponse implique deux mots ou expressions raisonnablement précis (mais potentiellement intelligents) pouvant être séparés par le mot 'et':

Q: Quels sont les deux côtés d'une pièce? A: têtes et queues

Q: Quels sont les meilleurs moyens de voyager? A: avion et jetpack

Q: Pourquoi un corbeau est-il comme un bureau? A: parce qu'il y a un 'b' dans les deux et un 'n' dans les deux

Objectif

Ecrivez un programme qui, lorsqu'il est exécuté normalement, pose une telle question.

Lorsque tous les autres caractères sont supprimés du programme en commençant par le deuxième caractère et que le résultat est réexécuté, la sortie doit être celle qui se trouve à gauche des 'et' dans la réponse.

Lorsque tous les autres caractères du programme sont supprimés en commençant par le premier caractère et que le résultat est ré-exécuté, la sortie doit être celle qui se trouve à droite des 'et' dans la réponse.

(Le 'et' n'est pas sorti.)

Exemple

Si le programme est

A1B2C3D4E5F6G7H8I9

et sa sortie est

What are the two sides of a coin?

Ensuite, le résultat de ABCDEFGHIdevrait être heads, et le résultat de 123456789devrait être tails.

Règles concernant les questions et réponses

• Vous pouvez utiliser mes exemples de questions mais je vous encourage à composer les vôtres.
• La question et les deux parties de la réponse:
  • doivent tous être distincts
  • devrait être commun anglais grammatical signifiant
  • ne peut contenir que de l' ASCII imprimable (hex 20 à 7E)
• Idéalement, la question sera mise en majuscule et ponctuée (mais les réponses ne doivent pas nécessairement l'être).
• La question doit comporter au moins 30 caractères et avoir une entropie supérieure ou égale à 3,5. (Tapez la chaîne, cliquez sur calculer , recherchez le dernier H (X) .)
• Les deux parties de la réponse (excluant l’ [space]and[space]entre les deux) doivent comporter au moins 5 caractères avec une entropie supérieure ou égale à 2.
• Le mot 'et' peut apparaître dans les deux réponses.

Règles concernant le code

• Aucun des 3 extraits de code ne peut:
  • contient des commentaires ou tout autre élément traditionnellement ignoré par le compilateur / interprète (ne vous inquiétez pas pour ajouter un point-virgule supplémentaire ou deux, mais si vous pensez que c'est un commentaire, c'est probablement le cas)
  • quitter le programme en cours d'exécution
• Le code peut contenir n’importe quel caractère, y compris Unicode et ASCII non imprimable.
• Il peut avoir un nombre pair ou impair de caractères.
• La sortie passe à stdout ou dans un fichier ou quoi que ce soit qui semble raisonnable. Il n'y a pas d'entrée.

Notation

Puisque je ne veux pas encourager les réponses au golf mais que je veux encourager encore plus les réponses intelligentes, la notation sera quelque chose entre le concours de code-golf et la popularité:

Score = (upvotes - downvotes) - floor((bytes in code that outputs question) / 3)

Le score le plus élevé gagne.

(Utilisez http://mothereff.in/byte-counter comme compteur d'octets.)

Javascript (148 octets)

Crée des littéraux dépourvus de sens, avec comme effet secondaire de créer une alerte * pour la question. (les divisions se ressemblent, mais créent des alertes * pour chacune des réponses).

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

et

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

Question: What is the ideal breakfast???

Réponses: baconetscrambled eggs

Brainfuck (437 caractères)

Je dois avouer que c'est mon premier programme de brainfuck qui fait quelque chose de significatif. Le programme est hautement optimisé pour les systèmes à faible mémoire puisqu'il n'utilise que 4 emplacements de mémoire.

Question: What are the two main groups of trees?

Réponses: conifersetbroadleafs

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

Boucle principale

Le programme consiste en une boucle principale (qui n'est pas vraiment une boucle car tous les blocs [] ne sont exécutés qu'une seule fois) et deux sections.

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

Si vous souhaitez tester des sections indépendamment, vous devez prendre en compte la boucle principale. L'emplacement 0 contient -1 en réponse paire, 1 en réponse impaire et 2 en section de question.

Section de réponse

Même réponse (instructions impaires supprimées):

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

Réponse impaire (même les instructions ont été supprimées):

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

Section de questions

J'ai décidé de stocker de l'espace pour séparer l'emplacement car sa valeur diffère radicalement des autres personnages. Cela permet d’imprimer simplement de l’espace <.>.

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

Mise à jour finale

Dans ma dernière mise à jour, j'ai optimisé les multiplications afin que les instructions minimales soient utilisées. Inclure également 'l' au deuxième groupe de caractères dans la section des réponses impaires s'est avéré être une énorme amélioration. L'économie d'un seul caractère dans les réponses impaires signifiait fondamentalement deux caractères de l'ensemble du programme, car elle réduit également le remplissage de la réponse paire. J'ai également supprimé quelques instructions inutiles d'ici et là et je ne pense pas pouvoir optimiser davantage le code.

Lot - 84

Assez fier de celui-ci

Programme complet: Quels sont les deux côtés d'une pièce? (console)

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

Uniquement en tête: têtes (fichier 'c')

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

Cotes seulement: queues (fichier 'x')

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

Fonctionne en redirigeant la sortie d'erreur vers un fichier dans les deux cas.

Python - 104 96 (golfé: 76)

Ma solution est plutôt simple (et en quelque sorte lisible):

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

Sortie:

What is the color of a zebra?
black
white

Honnêtement, j'ai trouvé l'idée de la première ligne dans la réponse de bitpwner.

Alternative encore plus lisible: - 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 '"

Alternative encore plus courte: - 86 76

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

Rebmu : 79 caractères OU (37 + longueur (p1) + 2 * max (longueur (p2), longueur (p3)))

Je vais d'abord donner une solution à 79 caractères qui demande quelles langues devez-vous apprendre? (entropie 4.0, 30 lettres non comprises ?) et vous propose les suggestions de Rebol et [Rouge] :

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

Une tactique unique disponible ici, qui ne figure pas dans d'autres langues, consiste à tirer parti du fait que les accolades sont un délimiteur de chaîne asymétrique, qui peut s'emboîter légalement:

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

Cela me permet de produire une solution généralisée, qui peut fonctionner sans effort sur n'importe quel programme qui n'utilise pas de séquences d'échappement. La version à 79 caractères était assez simple pour être raccourcie, mais pour contenir correctement une source de programme arbitraire pour les programmes p2 et p3, vous auriez besoin du modèle complet. Si nous avions utilisé cela, cela aurait été 87 caractères:

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

Le schéma d'utilisation de cette forme générale est que si vous avez trois textes sources de caractères séquentiels de longueurs variables (Utilisons un exemple comme AAA, BBBBB, CCCCCCC) vous pouvez les coder comme quelque chose le long des lignes de:

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

(Remarque: bien que ce modèle ne fonctionne pas sans des modifications sur les programmes qui utilisent des caractères d'échappement, ce n'est pas une faille fatale. Obtenir une accolade gauche incomparable dans une chaîne délimitée par des accolades nécessite quelque chose comme {Foo ^{ Bar}... mais vous pouvez facilement réécrire cela en utilisant la notation de chaîne alternative "Foo { Bar"et les cas combinés peuvent être gérés en collant un mélange de chaînes non échappées.)

Alors ... que diriez-vous d'un exemple? Une fois la forme générale disponible, ce programme de 573 caractères a été assemblé en seulement quelques minutes à partir de 3 solutions de golf de code antérieures:

DD 11 DD: dd {dd {rJN 0% rW Wa1m2j S {\ x /} D00 Hc & [u [Q [Q? Q Qs ~ rpKw [isEL00c [skQd2k] [eEV? KQ [tlQ]] pSeg - b00 [ eZ 1 5] 3] prRJ [si ~ dSPscSqFHs] eZ 1 [s + dCa + wM2cNO]]] Va | [mpAp2j] prSI ~ w { } Ls2w Wl h01tiVsb01n -1 chRVs { } hLceVn}} ddoo {d. [sn [{N sbeo [tIt0l1eV} 0e5gXN1 01L {5s0} C {1} 0 {0 Do5f0 0bMe1e0r0} 0]] tMw9C9 Numz Jl [paN + [KperlCJBn [[ba sWS {B noJn N ° {K, j} b P {. } lf EZ - - n [N m {G otothestoreandebubuysome more}]] {T akeonedownandpassitar ound} c B w P lf]]}}

• Si vous ne modifiez pas le programme, c'est la solution du sablier .

• Si vous ne prenez que les caractères impairs et que vous le lancez, il imprimera les 99 bouteilles de poème de bière

• Seuls les personnages pairs feront une petite conversion en chiffres romains pour vous.

Si quelqu'un veut essayer d'écrire ce programme dans la langue de son choix et pense pouvoir battre 573, faites le moi savoir. Si vous le faites, je vous récompenserai énormément - en supposant que votre langue de choix n'est pas Rebmu, car je sais que ces programmes ne sont pas minimes. :-)

Ce "gaspillage" espacement que vous obtenez à la fin est ce qui se produit lorsque p2 et p3 sont de longueurs déséquilibrées. Mais tous les 3 programmes ont des tailles différentes dans ce cas, il n’ya donc pas de bonne paire à choisir pour p2 / p3. (Je les ai choisis parce qu’il n’y avait pas de données externes en entrée, comme un labyrinthe ou autre, mais pas parce qu’elles avaient la même longueur. Bien que j’aurais pu écrire de nouveaux programmes plus optimaux, j’ai passé assez de temps et le but était: vous n'êtes pas obligé d'écrire de nouveaux programmes ...)

Comment ça marche

(Remarque: j'ai commencé avec une approche plus "créative" qui n'était pas aussi simple, mais plus intéressante. Je l'ai déplacée dans une entrée de mon blog car la description de cette approche est déjà longue.)

Une clé ici est la "ruse" du code eval en tant que chaîne "comme d’autres entrées, elle a juste la carte maîtresse du délimiteur de chaîne asymétrique. Je commencerai par expliquer le fonctionnement du cas des 80 caractères.

Voici le programme "entier", ajustant les espaces pour la lisibilité de cette affaire:

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

Nous définissons ici DD comme synonyme de DO (alias "eval"). Mais le truc, c'est que lorsque les programmes divisés par deux sont exécutés, ils finissent par exécuter du code dont le seul effet est de définir D comme littéral inoffensif 1.

Voici ce que le code de caractères impairs crée, l'espace à nouveau ajusté:

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"

Et voici le code des caractères pairs:

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

En fait, pour le programme non divisé par deux, le dd {dd {(arbitrary code)qt}}programme exécutera le code que vous voulez. Cependant, il existe deux appels à évaluer au lieu d'un seul. En effet, bien que les accolades imbriquées fonctionnent parfaitement dans le code entrelacé, elles gâchent le comportement eval de DO. Car:

do {{print "Hello"}}

Charge la chaîne en tant que programme, mais ce programme n'est finalement que la constante de chaîne {print "Hello"}. Donc, l’astuce que j’utilise ici est de prendre mon DD (en gardant la même valeur de fonction que DO) et de l’exécuter deux fois. Les deux moitiés mâchent les différentes parties de la chaîne, mais ils ne mâchent pas les deux si la régularité / la bizarrerie est correcte pour le contenu et parce que ce qui reste en dehors de la chaîne après la réduction de moitié est juste la constante intégrale, dil est inoffensif.

Avec ce modèle, il n’est pas difficile d’écrire le comportement du programme s’il n’est pas divisé en deux: vous pouvez entrer n'importe quoi tant que la longueur du code est paire (impair si vous comptez le QT, qui est QUIT). Si vous devez obtenir le nombre pair d'un nombre impair, insérez un espace (il y a donc un +1 dans la formule ci-dessus sur p1 pour les longueurs de programme impaires de p1) . L'astuce semblerait écrire ce code entrelacé par la suite, qui doit passer à l'analyseur s'il n'est pas divisé par deux. (Il ne sera pas exécuté à cause de QT, mais il doit être chargé avant d'être exécuté.)

Cette affaire est triviale; ppcharge bien comme symbole même s'il n'est pas défini et est divisé en pimpression dans chaque demi-programme. Mais nous pouvons faire une autre astuce en utilisant à nouveau un littéral de chaîne. Les programmes divisés en deux ont toujours DO défini normalement, alors nous aurions aussi pu dire:

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

En faisant en sorte que la seule partie de l’analyseur, dans l’ensemble du cas, soit le mot symbolique ddooet un littéral de chaîne, nous pouvons alors entrelacer deux programmes que nous souhaitons à l’intérieur de ce littéral de chaîne et ne pas irriter l’analyseur. Les versions divisées en deux diront simplement:

do{p{Rebol}}

..et...

do{p{[Red]}}

Comme je le disais, cette partie semble familière aux autres solutions qui traitent les programmes comme des chaînes et les évaluent. Mais dans le cas de la concurrence, lorsque les programmes que vous packagez contiennent des chaînes imbriquées, cela crée des clés pour eux. Ici, les seules choses qui vous poseront des problèmes sont les échappements via des carets ( ^) ... faciles à contourner.

(Petite note de "triche": j'ai ajouté QT pour "QUIT" en réponse à ce problème. En fait, j'avais volontairement supprimé l'abréviation pour quitter avant ... parce que je pensais que c'était seulement bon pour une utilisation en console Un espace de deux lettres s'il n'était pas dans une REPL. Je l'ajoute parce que je me suis trompé, mais je ne l'ai pas ajouté pour ce cas en particulier. Néanmoins, avant ce changement, il aurait fallu 2 caractères de plus. Quand j'ai posté la solution pour la première fois, il y avait un bogue dans Rebmu qui l'empêchait de fonctionner même s'il aurait dû le faire ... maintenant, cela fonctionne.)

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

Quelles sont les meilleures choses dans la vie?

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

écrase tes ennemis

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

entendre les lamentations de leurs femmes

En utilisant des réponses moins longues:

Perl 79 72

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

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

Tester:

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

Ancienne version:

# 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

Travailler avec le paradigme fonctionnel de Haskell signifie que tout doit être affecté à une variable ou commenté avec des commentaires de ligne --ou de bloc {- -}; le fait d'exécuter des fonctions non-sens sans affectation est épuisé. Donc, pour rester saine d'esprit, j'ai gardé la question et les réponses aussi courtes que le permettaient les règles.

Question: De quoi ne puis-je pas en avoir assez?

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

-----}

"Chaussures" et "gâteaux":

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

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

NB: l'apparition de crank"Que puis-je ne pas en avoir assez?" ne devrait pas être considéré comme significatif.

Lisp (76 caractères)

Question à 31 caractères, 6 caractères dans chaque réponse ⟹ longueur - charge utile = 33

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

Je voulais utiliser «Quelle est votre couleur préférée?», Mais même avec une orthographe britannique, il n’atteignait que le minimum de 30 caractères pour la longueur de la question, et j’avais besoin d’une question de longueur impaire pour équilibrer les guillemets.

Ils disent que Common Lisp est prolixe, mais vous ne le croiriez pas. Ce n'est même pas très obscur, il suffit d'insérer un peu d'espace pour voir ce qui est cité et ce qui est exécuté.

De nombreuses implémentations Lisp vont crier les couleurs, car elles déforment les symboles en majuscules. Si cela vous dérange, changez ''fmuacghesnitaaen ""fmuacghesnitaa"".

STATA 295

Question: Quels sont les meilleurs desserts à cuire en ce moment? Réponse: brownies et biscuits.

Explication: Les commandes dans STATA sont délimitées par de nouvelles lignes.
Alors que "//" est un commentaire dans STATA, "///" indique au compilateur de continuer à la ligne suivante et d'inclure son contenu dans la commande en cours.

Les commandes de STATA peuvent souvent être abrégées au point où elles sont considérées comme suffisamment uniques pour pouvoir être différenciées (ainsi, "generate" devient "g", "global" devient "gl" ou "glo", "capture" devient "cap", " display "devient" di ", etc.). La commande d'affichage affiche le texte à l'écran. La commande de capture capture toutes les erreurs (y compris les erreurs de syntaxe), raison pour laquelle ce programme est compilé correctement.

Je suppose que si vous voulez être pointilleux, les "/" supplémentaires après les 3 premiers consécutifs d'une ligne sont ignorés par le compilateur. En outre, dans le programme "Brownies", techniquement "" est un commentaire. Mais je prétends que cela compte toujours parce que la commande de capture l'aurait toujours rendue inutile même si ce n'était pas un commentaire.

Merci d'avoir lu ma très longue explication. Passons maintenant au code:

"Quels sont les meilleurs desserts à cuire en ce moment?"

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"

"biscuits"

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

Ksh (82 caractères)

Question à 35 caractères, 5 caractères dans chaque réponse ⟹ longueur - charge utile = 37

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

J'abuse de la syntaxe de définition de fonction au-delà de POSIX. Dash et bash ne peuvent pas le prendre mais ksh (domaine public ou ATT) le peut.

Rien d'extraordinaire, juste un peu d'écho. Ne gaspille pas, ne veux pas.

PowerShell 88

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

${XsXwXoXrXdX};;;${XsXhXiXeXlXdX}

Quel est mon équipement préféré? (30 caractères, H (X) = 4.0314)

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

épée (5 caractères, H (X) = 2.32193)

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

bouclier (5 caractères, H (X) = 2.58496)

Sur le programme complet, il redirige les chaînes vides vers une variable non existante ${x}(les guillemets de ces chaînes vides sont utilisés pour former une chaîne non-sens qui est redirigée vers un bloc vide {}ou une variable non existante $xsur les versions paires / impaires), puis affiche la question et déclare 2 variables inutilisées (qui sont imprimées et placées à côté d’une autre variable inutilisée $XXXXXXou $XXXXXXXsur les différents cas).

GolfScript, 51 octets

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

Sortie

Which are the sides of a coin? 

Comment ça marche

.;duplique la chaîne et supprime la copie. ""pousse une chaîne vide. thaeialdssest indéfini, donc il ne fait rien.

Odd chars

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

Sortie

heads

Comment ça marche

; supprime la première chaîne de la pile.

Même les caractères

Wihaetesdso  on ."tails"

Sortie

tails

Comment ça marche

Wihaetesdsoet onsont noops. .duplique la chaîne vide sur la pile.