Ecrivez une fonction ou un programme qui utilise deux mots en entrée et en sortie comme variantes du très populaire slogan anglais "Quelle quantité de bois un mandrin de Woodchuck produirait-il si un Woodchuck pouvait chuck de bois?".

La sortie utilisera le premier mot quatre fois

• Combien woodserait un woodmandrin si un woodmandrin pouvait chuck wood?

et le deuxième mot quatre fois

• Combien de bois serait un bois chuck chucksi un bois chuckpouvait chuckbois?

le reste de la sortie étant identique pour toutes les entrées.

• How muchbois would amarmotte mandrin if amarmotte couldchuck bois?

L'entrée et la sortie peuvent être dans n'importe quel format que votre langue reconnaît raisonnablement comme traitant des chaînes de texte. La sortie doit être exactement dans le format indiqué, y compris la capitalisation, les espaces et leur absence, et le point d'interrogation final. Un retour à la ligne optionnel est acceptable.

Idéalement, votre code gérera les entrées contenant des caractères ASCII imprimables. Cependant, il est permis de limiter l'entrée à des sous-ensembles raisonnables d'ASCII imprimables; indiquez-le simplement dans votre réponse. Manipuler des jeux de caractères plus importants est bien sûr correct

Exemple de paires entrée-sortie:

"wood", "chuck"
"How much wood would a woodchuck chuck if a woodchuck could chuck wood?"

"ground", "hog"
"How much ground would a groundhog hog if a groundhog could hog ground?"

"bar", "keep"
"How much bar would a barkeep keep if a barkeep could keep bar?"

"money", "belt"
"How much money would a moneybelt belt if a moneybelt could belt money?"

"rain", "fall"
"How much rain would a rainfall fall if a rainfall could fall rain?"

"hair", "cut"
"How much hair would a haircut cut if a haircut could cut hair?"

"green", "house"
"How much green would a greenhouse house if a greenhouse could house green?"

"jabber", "wock"
"How much jabber would a jabberwock wock if a jabberwock could wock jabber?"

"pine", "apple"
"How much pine would a pineapple apple if a pineapple could apple pine?"

"Rob", "Lowe"
"How much Rob would a RobLowe Lowe if a RobLowe could Lowe Rob?"

"code", "golf"
"How much code would a codegolf golf if a codegolf could golf code?"

"fish", ""
"How much fish would a fish  if a fish could  fish?"

"", "fish"
"How much  would a fish fish if a fish could fish ?"

"", ""
"How much  would a   if a  could  ?"

"  ", "     "
"How much    would a               if a         could         ?"

"would a", "how much"
"How much would a would a would ahow much how much if a would ahow much could how much would a?"

C'est du code-golf , donc le moins d'octets gagne. Les réponses sont les bienvenues dans toutes les langues, même si une autre langue peut le faire avec moins d'octets.

(Inspiré par ce meme , qui utilise une paire d’entrée mieux que ce modèle rigide ne le fait ....)

Python 3 , 70 67 octets

"How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?".format

Essayez-le en ligne!

Je veux dire, si la chaussure va bien ..

Merci à manatwork d' avoir attrapé une faute de frappe

Merci à Remco Haszing pour l'excellente idée de -3 octets

Je pars de l'hypothèse que ce serait toujours une soumission valide (parce que c'est trop cool de ne pas essayer). Si OP pouvait clarifier si cela est acceptable (parce que je n'ai pas écrit de fonction en tant que telle), ce serait apprécié.

Mise à jour: Bénédiction reçue, tout va bien :)

La version précédente:

lambda a,b:f"How much {a} would a {a+b} {b} if a {a+b} could {b} {a}?"

T-SQL, 82 octets

SELECT'How much '+w+' would a '+w+c+' '+c+' if a '+w+c+' could '+c+' '+w+'?'FROM t

La saisie provient du tableau préexistant avec les colonnes et , conformément à nos règles IO .$t$$w$$c$

Un octet de plus, mais pour une raison un peu plus agréable:

SELECT REPLACE(REPLACE('How much 1 would a 12 2 if a 12 could 2 1?',1,w),2,c)FROM t

Cette version fonctionne sur un sous-ensemble d'entrées n'incluant pas le chiffre 2dans le premier mot .$w$

Comme je suis en SQL, je peux pré-charger tous les exemples dans la table et les exécuter tous en même temps:

Bash , 50 octets

echo How much $2 {would,$1\ if}\ a\ $2$1 could $@?

Essayez-le en ligne!

-5 octets grâce aux commentaires ci-dessous.

Stax , 33 31 30 29 octets

-1 grâce à récursif !

¢èO∩sP↑å♥|1╧ì}ò♂xb■δå«█Γ╨╦►Q²

Exécutez et déboguez-le sur staxlang.xyz!

Poussez chaque composant dans la pile dans l'ordre inverse, puis associez-le à tous avec des espaces.

Décompressé (35 octets) et explication:

X'?+;`IM'`x;+Y`~^$`,y`75\`x`Q)("`LJ
X                                      Set register X to the first word
                                       "wood"
 '?+                                   Append a question mark, popping from the input stack
                                       "wood?"
    ;                                  Peek from input stack and push to main stack
                                       "chuck" "wood?"
     `IM'`                             Literal "could"
                                       "could" "chuck" "wood?"
          x;+Y                         Peek register x. Peek input. Concatenate. Set register Y.
                                       "woodchuck" "could" "chuck" "wood?"
              et cetera, ad nauseam
                                  LJ   Listify the stack and join with spaces
                                       Implicit print

Tout ce qui est compris entre `` est un littéral de chaîne compressé. Cette virgule est essentielle. La dernière fois que j'ai lu dans la pile d'entrées, je dois faire un saut plutôt que de jeter un coup d'œil pour éviter un "chuck" supplémentaire à la fin de ma sortie.

Vous remarquerez que j'ai mis les deux entrées sur la même ligne pour quelques cas de test, et qu'elles sont dans l'ordre inverse. Cela est nécessaire pour prendre en entrée des chaînes vides ou des chaînes d'espaces.

27 26 octets avec des restrictions d'entrée

å▓Zf╢7)╪♪²p╞8ó╪l▼]<¡REïSèΣ

Exécutez et déboguez-le sur staxlang.xyz!

Tout comme le SOGL de @ dzaima , cela échouera si la première entrée contient la lettre minuscule «y». Pousse la chaîne "Combien b aurait a par y si a par y pouvait yb?", Fait alors une paire de remplacements.

JavaScript, 70 octets

Ennuyeuse!

a=>b=>`How much ${a} would a ${a+b} ${b} if a ${a+b} could ${b} ${a}?`

Essayez-le en ligne!

Légèrement moins ennuyeux!

a=>"How much 0 would a 01 1 if a 01 could 1 0?".replace(/\d/g,x=>a[x])

Essayez-le en ligne!

SOGL , 32 à 30 octets

^.](9V;⅜‛°@Ε¬tπs%.½Ω‘⁽ b,ŗ y,ŗ

Essayez-le ici!

La première entrée ne peut pas contenir la lettre y, ce qui semble laisser un sous-ensemble raisonnable d'ASCII (et d'unicode).

½ouiīZģ9Ο|ΧyΚ⅞ō÷Jeq(‚7‘est une chaîne compressée de "how much b would a by y if a by could y b?"(caractères choisis de manière à ce que les mots requis figurent tous dans les 512 premiers mots du dictionnaire qui compressent le mieux), puis bsont remplacés par la première entrée et ypar le deuxième.

R , 90 77 76 octets

-13 grâce à Sumner18
-1 grâce à Giuseppe

function(x,y,`[`=gsub)2[y,1[x,"How much 1 would a 12 2 if a 12 could 2 1?"]]

Essayez-le en ligne!

PHP , 72 octets

[,$a,$b]=$argv;echo"How much $a would a $a$b $b if a $a$b could $b $a?";

Essayez-le en ligne!

Ou:

PHP , 72 octets

How much <?=![,$a,$b]=$argv,"$a would a $a$b $b if a $a$b could $b $a?";

Essayez-le en ligne!

Entrée depuis la ligne de commande, sortie vers STDOUT.

JavaScript (V8) , 72 octets

(a,b)=>['How much',a,'would a',c=a+b,b,'if a',c,'could',b,a+'?'].join` `

Essayez-le en ligne!

En fait, l’affectation de variable permet d’économiser 0 octet, mais j’ai pensé que je la garderais juste pour que cela soit légèrement unique.

ZX Spectrum Basic, 87 octets

Juste pour être complet, une mise en œuvre simple:

INPUT a$,b$: PRINT "How much ";a$;" would a ";a$;b$;"  ";b$;" if a ";a$;b$;" could ";b$;" ";a$;"?"

En utilisant le IFmot clé (1 octet), la golfe par 3 octets, mais rompt la condition de "même capitalisation":

INPUT a$,b$: PRINT "How much ";a$;" would a ";a$;b$;"  ";b$;" IF a ";a$;b$;" could ";b$;" ";a$;"?"

Rouille , 75 octets

|a,b|print!("How much {} would a {0}{} {1} if a {0}{1} could {1} {0}?",a,b)

Essayez-le en ligne!

En utilisant cette astuce , qui vous permettent de sauter l'index est mise en forme une fois par article au format.

Nous utilisons aussi print!(), parce que c'est un octet plus court que de construire format!()et de renvoyer une chaîne .

05AB1E , 37 35 31 30 octets

“Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“T$ú‡

-5 octets grâce à @Grimy .

Prend une liste de deux éléments: en woodtant que première valeur et en chucktant que deuxième.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

“Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“
      # Push dictionary string "How much1 would a ÿ0 if a ÿ could01?",
      # where the `ÿ` are automatically filled with the (implicit) input-list,
      # implicitly joined together to a single string
      #  i.e. ["wood","chuck"] → "How much1 would a woodchuck0 if a woodchuck could01?"
T     # Push 10
 $    # Push the input-list and 1
  ù   # Pad the strings in the input-list with this 1 amount of leading spaces
      #  ["wood","chuck"] → [" wood"," chuck"]
   ‡  # Transliterate the 10 ([1,0]) to these strings in the sentence
      #  → "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
      # (after which the result is output implicitly)

Voir cette astuce de la mine de 05AB1E (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi “Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“est "How much1 would a ÿ0 if a ÿ could01?".

Applesoft BASIC, 77 76 octets

1INPUTA$,B$:?"How much "A$" would a "A$B$" "B$" if a "A$B$" could "B$" "A$"?

Ce qui précède ne ressemble peut-être pas à la norme BASIC, mais Applesoft autorise quelques raccourcis lors de l'utilisation de l' PRINTinstruction:

• Utilisation de ?à la place de PRINTlors de la saisie de la déclaration
• Les caractères de concaténation (ou ;ou +) peuvent être omis
• Si l'instruction se termine par une chaîne entre guillemets, la citation finale peut être omise Merci, Mark !

Le numéro de ligne est obligatoire ou la INPUTdéclaration provoquera un?ILLEGAL DIRECT ERROR

33 , 78 octets

"How much "p1btpt" would a "ptpz2btp" "ptbtp" if a "ptpbtp" could "ptbtp" "ptp

Essayez-le en ligne!

Prend l'entrée en tant qu'argument de ligne de commande.

Bonus: 91 octets

"How much "p1bztp" would a "p1bztp2bztp" "p2bztp" if a "p1bztp2bztp" could "p2bztp" "p1bztp

Essayez-le en ligne!

Donne une sortie qui se ressemble quand on donne des entrées 1bztpet2bztp

Kotlin , 59 octets

{i,j->"How much $i would a $i$j $j if a $i$j could $j $i?"}

Essayez-le en ligne!

PowerShell , 65 octets

param($a,$b)"How much $a would a $a$b $b if a $a$b could $b $a`?"

Essayez-le en ligne!

La seule chose à noter est que vous devez échapper au point d'interrogation car il peut s'agir de parties valides d'un identifiant PowerShell.

VBA, 107 octets

Function q(a,b)
b=b&" "
c="ould "
q="How much "&a&" w"&c&"a "&a&b&b&"if a "&a&b&"c"&c&b&a&"?"
End Function

Devrait aussi fonctionner en VBScript, j’ai utilisé deux raccourcis: "ould" se répète et "chuck" n’apparaît jamais sans espace supplémentaire.

C # , 165 148 133 octets

class P{static void Main(string[]a){System.Console.Write("How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?\n",a[0],a[1]);}}

Merci à Andrew Baumher de m'avoir parlé de chaînes interpolées !!
EDIT: La classe complète est maintenant ajoutée
EDIT: Merci à Kenneth K. de m'avoir donné quelques astuces pour le raccourcir
EDIT: merci encore à Andrew de m'avoir dit que l'utilisation de chaîne interpolée est en réalité plus longue dans ce scénario.

Haskell , 76 octets

a?b=a++" "++b
a!b="How much"?a?"would a"?a++b?b?"if a"?a++b?"could"?b?a++"?"

Essayez-le en ligne!

D'abord, j'espère n'avoir enfreint aucune règle.

Gelée , 39 octets

ŒPKŒP“µkþ¿µ‘ị“þ>Æƈ)taJṖ;ạʂ\4S%dñl»Ỵ¤ż”?

Un programme complet acceptant une liste de deux chaînes.

Essayez-le en ligne!

... Ou (également un programme complet acceptant une liste de deux chaînes)

⁽4ṀDBịs€2ṭ€€⁶“þ>Æƈ)taJṖ;ạʂ\4S%dñl»Ỵ¤ż”?

Essayez-le en ligne!

Python 3 , 80 octets

lambda n:'How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?'.format(*n)

Essayez-le en ligne!

à Rome, utilisez le format str.

Edité en utilisant le truc du calmar.

C # (compilateur interactif Visual C #) , 66 à 65 octets

x=>y=>$"How much {x} would a {x+y} {y} if a {x+y} could {y} {x}?"

Essayez-le en ligne!

comme tout le monde, sauf C #. -1 octet en utilisant la stratégie de curry a => b => c au lieu de (a, b) => c

R , 95 octets

function(a,b)cat("How much ",a," would a ",a,b," ",b," if a ",a,b," could ",b," ",a,"?",sep='')

Essayez-le en ligne!

APL (Dyalog Unicode) , 56 59 octets

{∊'How much '⍺' would a '⍺⍵' '⍵' if a '⍺⍵' could '⍵' '⍺'?'}

Essayez-le en ligne!

Assez simple dfn. Enregistre un octet en coupant ∊si nous sommes autorisés à renvoyer un tableau de chaînes au lieu d'une seule chaîne.

3 octets ajoutés car j'avais oublié d'ajouter le point d'interrogation.

Wolfram Language (Mathematica) , 68 octets

StringRiffle@{How,much,#,would,a,c=#<>#2,#2,if,a,c,could,#2,#<>"?"}&

Essayez-le en ligne!

Gelée , 41 à 37 octets

⁾be,y“Ø[gœıJ9°m.OṚuHlh3Ƥ⁾$ɲ0øḲʂṇHẎṆȥ»

Essayez-le en ligne!

Un programme complet prenant une paire de chaînes comme argument et imprimant la chaîne traitée. Un lien monadique pourrait être formé en ajoutant un Fà la fin (merci à @JonathanAllan pour l'avoir signalé).

Je suis maintenant passé à l'utilisation de "b" et "e" comme espaces réservés, inspirés par la réponse SOGL de @ dzaima, alors assurez-vous de passer également à celle-ci! Cela signifie que le premier mot ne peut pas inclure la lettre e.

Japt -S , 44 39 octets

[`How Û2`U`Ùd a`N=¬V`if a`N`Öd`VU+'?]

L'essayer

Forth (gforth) , 116 octets

: x 2over type ; : y 2dup type ; : f ." How much "x ."  would a "x y ."  "y ."  if a "x y ."  could "y ."  "x ." ?";

Essayez-le en ligne!

Explication du code

\ x = output the first word
: x               \ start a new word definition
  2over type      \ copy the "first" word to the top of the stack and print it
;                 \ end word definition

\ y = output the second word
: y               \ start a new word definition
  2dup type       \ copy the "second" word to the top of the stack and print it
;                 \ end word definition

: f               \ start a new word definition
  ." How much "x  \ print "How much " followed by the first word   
  ."  would a "x  \ print " would a " followed by the first word
  y ."  if a "x   \ print the second word followed by " if a " and then the first word
  y ."  could "y  \ print the second word, then " could " then the second word again
  ."  "x ." ?"    \ print a space followed by the first word, followed by "?"
;                 \ end word definition

Lua , 82 octets

a,b=...print((('How much x would a xy y if a xy could y x?'):gsub('.',{x=a,y=b})))

Essayez-le en ligne!

Programme complet, prenez les arguments comme arguments.

Rien de spécial ici. J'espère qu'il existe une version plus courte, mais aucun moyen évident de le réduire à première vue.

Bash , 58 octets

echo "How much $1 could a $1$2 $2 if a $1$2 could $2 $1?"

Prend les entrées en tant qu'arguments de ligne de commande. Essayez-le en ligne!