Escriba una función o programa que tome dos palabras como variantes de entrada y salida del popular trabalenguas inglés "¿Cuánta madera arrojaría una marmota si una marmota pudiera arrojar madera?".

La salida usará la primera palabra cuatro veces

• ¿Cuánto woodcostaría un woodmandril si un woodmandril pudiera arrojarse wood?

y la segunda palabra cuatro veces

• ¿Cuánta madera tendría una madera chuck chucksi una madera chuckpudiera chuckmadera?

con el resto de la salida siendo el mismo para cualquier entrada.

• How muchmadera would amarmota Chuck if amarmota couldChuck madera?

La entrada y la salida pueden estar en cualquier formato que su idioma reconozca razonablemente que trata con cadenas de texto. El resultado debe estar exactamente en el formato indicado, incluyendo mayúsculas, espacios y falta de ellos, y el signo de interrogación final. Una nueva línea final opcional es aceptable.

Idealmente, su código manejará entradas que contengan caracteres ASCII imprimibles. Sin embargo, está permitido restringir la entrada a subconjuntos razonables de ASCII imprimible; solo indica esto en tu respuesta. Por supuesto, manejar conjuntos de caracteres más grandes está bien.

Ejemplo de pares de entrada-salida:

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

Este es el código de golf , por lo que gana menos bytes. Las respuestas son bienvenidas en todos los idiomas, incluso si algún otro idioma puede hacerlo en menos bytes.

(Inspirado por este meme , que usa un par de entrada mejor que este patrón rígido ...)

Python 3 , 70 67 bytes

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

Pruébalo en línea!

Quiero decir, si el zapato te queda ...

Gracias a manatwork por atrapar un error tipográfico

Gracias a Remco Haszing por la excelente idea de -3 bytes

Estoy huyendo de la suposición de que esto todavía sería una presentación válida (porque, hombre, es demasiado genial para no intentarlo). Si OP pudiera aclarar si esto es aceptable (porque no he escrito una función, per se), eso sería apreciado.

Actualización: Bendición recibida, todo es bueno :)

Versión previa:

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

T-SQL, 82 bytes

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

La entrada se toma de la tabla existente con las columnas y , según nuestras reglas de IO .$t$$w$$c$

Un byte más, pero por alguna razón un poco más agradable:

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

Esta versión funciona en un subconjunto de entradas que no incluyen el número 2en la primera palabra .$w$

Como estoy en SQL, puedo precargar todos los ejemplos en la tabla y ejecutarlos todos a la vez:

Bash , 50 bytes

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

Pruébalo en línea!

-5 bytes debido a la ayuda de los comentarios a continuación.

Stax , 33 31 30 29 bytes

-1 gracias a recursivo !

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

¡Ejecútelo y depúrelo en staxlang.xyz!

Empuja cada componente a la pila en orden inverso, luego une todos los espacios.

Desempaquetado (35 bytes) y explicación:

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

Todo entre `` es un literal de cadena comprimido. Esa coma es vital. La última vez que leí de la pila de entrada, debo hacer estallar en lugar de mirar para evitar una "tirada" adicional al final de mi salida.

Notarás que pongo ambas entradas en la misma línea para algunos casos de prueba, y que están en orden inverso. Esto es necesario para tomar cadenas vacías o cadenas de espacios como entrada.

27 26 bytes con restricciones de entrada

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

¡Ejecútelo y depúrelo en staxlang.xyz!

Al igual que SOGL de @ dzaima , esto fallará si la primera entrada contiene la letra minúscula 'y'. Empuja la cadena "¿Cuánto b a a y si a by podría yb?", Luego realiza un par de reemplazos.

JavaScript, 70 bytes

¡Aburrido!

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

Pruébalo en línea!

¡Un poco menos aburrido!

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

Pruébalo en línea!

SOGL , 32 30 bytes

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

Pruébalo aquí!

La primera entrada no puede contener la letra y, que parece dejar un subconjunto razonable de ASCII (y unicode) a la izquierda.

½ouiīZģ9Ο|ΧyΚ⅞ō÷Jeq(‚7‘es una cadena comprimida de "how much b would a by y if a by could y b?"(caracteres elegidos para que las palabras requeridas estén todas en las 512 palabras superiores del diccionario que se comprimen mejor), luego bse reemplaza con la primera entrada y ycon la segunda.

R , 90 77 76 bytes

-13 gracias a Sumner18
-1 gracias a Giuseppe

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

Pruébalo en línea!

PHP , 72 bytes

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

Pruébalo en línea!

O:

PHP , 72 bytes

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

Pruébalo en línea!

Entrada de línea de comando, salida a STDOUT.

JavaScript (V8) , 72 bytes

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

Pruébalo en línea!

La asignación de variables en realidad ahorra 0 bytes, pero pensé que la mantendría solo para hacer esto un poco único.

ZX Spectrum Basic, 87 bytes

Solo para completar, implementación sencilla:

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

Al usar la IFpalabra clave (1 byte) se reduce en 3 bytes, pero se rompe la condición de "misma capitalización":

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

Óxido , 75 bytes

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

Pruébalo en línea!

Usando este truco , que le permite omitir el índice de formato una vez por elemento para formatear.

También se usa print!(), porque es un byte más corto que construir una cadena format!()y devolverla.

05AB1E , 37 35 31 30 bytes

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

-5 bytes gracias a @Grimy .

Toma una lista de dos elementos: woodcomo primer valor y chuckcomo segundo.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué “Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“es "How much1 would a ÿ0 if a ÿ could01?".

Applesoft BASIC, 77 76 bytes

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

Lo anterior puede no parecer BASIC adecuado, pero Applesoft permite algunos atajos cuando se usa la PRINTdeclaración:

• Uso de ?en lugar de PRINTal ingresar la declaración
• Los caracteres de concatenación (ya sea ;o +) pueden omitirse
• Si la declaración termina en una cadena entre comillas, la cita final puede omitirse ¡ Gracias, Mark !

Se requiere el número de línea, o la INPUTdeclaración causará un?ILLEGAL DIRECT ERROR

33 , 78 bytes

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

Pruébalo en línea!

Toma la entrada como argumentos de línea de comandos.

Bonus: 91 bytes

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

Pruébalo en línea!

Da una salida que se parece a sí misma cuando se le dan entradas 1bztpy2bztp

Kotlin , 59 bytes

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

Pruébalo en línea!

PowerShell , 65 bytes

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

Pruébalo en línea!

Lo único que debe tener en cuenta es que debe escapar del signo de interrogación porque pueden ser partes válidas de un identificador de PowerShell

VBA, 107 bytes

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

También debería ejecutarse como VBScript, utilicé dos accesos directos: "ould" se repite y "chuck" nunca aparece sin un espacio adicional.

C # , 165 148 133 bytes

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]);}}

¡Gracias a Andrew Baumher por contarme sobre cadenas interpoladas!
EDITAR: La clase completa ahora agregó
EDITAR: Gracias a Kenneth K. por darme algunos consejos para acortarlo
EDITAR: Gracias a Andrew nuevamente por decirme que usar una cadena interpolada es en realidad más largo en este escenario.

Haskell , 76 bytes

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

Pruébalo en línea!

Primer intento, así que espero no haber roto ninguna regla.

Jalea , 39 bytes

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

Un programa completo que acepta una lista de dos cadenas.

Pruébalo en línea!

... O (también un programa completo que acepta una lista de dos cadenas)

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

Pruébalo en línea!

Python 3 , 80 bytes

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

Pruébalo en línea!

cuando estés en roma, usa el formato str.

Editado con el truco del calamar.

C # (compilador interactivo de Visual C #) , 66 65 bytes

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

Pruébalo en línea!

igual que todos los demás, excepto C #. -1 byte usando curt strat a => b => c en lugar de (a, b) => c

R , 95 bytes

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

Pruébalo en línea!

APL (Dyalog Unicode) , 56 59 bytes

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

Pruébalo en línea!

Bastante sencillo dfn. Guarda un byte cortando ∊si se nos permite devolver una matriz de cadenas en lugar de una sola cadena.

Se agregaron 3 bytes porque olvidé agregar el signo de interrogación.

Wolfram Language (Mathematica) , 68 bytes

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

Pruébalo en línea!

Jalea , 41 37 bytes

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

Pruébalo en línea!

Un programa completo que toma un par de cadenas como argumento e imprime la cadena procesada. Se podría formar un enlace monádico agregando un Fal final (gracias a @JonathanAllan por señalar esto).

Ahora he cambiado a usar "b" y "e" como marcadores de posición, inspirados por la respuesta SOGL de @ dzaima, ¡ así que asegúrese de votar esa también! Esto significa que la primera palabra no puede incluir la letra e.

Japt -S , 44 39 bytes

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

Intentalo

Adelante (gforth) , 116 bytes

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

Pruébalo en línea!

Explicación del Código

\ 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 bytes

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

Pruébalo en línea!

Programa completo, tome la entrada como argumentos.

Nada especial aquí. Espero que haya una versión más corta, pero no hay formas obvias de acortar esto a primera vista.

Bash , 58 bytes

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

Toma datos como argumentos de línea de comando. Pruébalo en línea!