Escreva uma função ou programa que use duas palavras como variantes de entrada e saída do popular trava-língua inglês "Quanta madeira uma marmota manda se uma marmota pode manda madeira?".

A saída usará a primeira palavra quatro vezes

• Quanto woodcustaria um woodmandril se um woodmandril pudesse manda-la wood?

e a segunda palavra quatro vezes

• Quanta madeira seria uma madeira chuck chuckse madeira chuckpudesse chuckmadeira?

com o restante da saída sendo o mesmo para todas as entradas.

• How muchmadeira would amarmota mandril if amarmota couldmandril de madeira?

A entrada e a saída podem estar em qualquer formato que seu idioma reconheça razoavelmente como lidando com cadeias de texto. A saída deve estar exatamente no formato indicado, incluindo letras maiúsculas, espaços e falta delas, e o ponto de interrogação final. Uma nova linha opcional à direita é aceitável.

Idealmente, seu código manipulará a entrada que contenha caracteres ASCII imprimíveis. No entanto, é permitido restringir a entrada a subconjuntos razoáveis ​​de ASCII imprimível; apenas indique isso na sua resposta. Lidar com conjuntos de caracteres maiores é claro.

Pares de entrada-saída de exemplo:

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

Isso é código-golfe , e o menor número de bytes vence. As respostas são bem-vindas em todos os idiomas, mesmo que outro idioma possa fazê-lo em menos bytes.

(Inspirado neste meme , que usa um par de entradas melhor do que esse padrão rígido ...)

Python 3 , 70 67 bytes

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

Experimente online!

Quero dizer, se o sapato couber ..

Graças a manatwork por pegar um erro de digitação

Agradecimentos a Remco Haszing pela excelente idéia de -3 bytes

Estou fugindo da suposição de que isso ainda seria uma submissão válida (porque, cara, é muito legal não tentar). Se o OP pudesse esclarecer se isso é aceitável (porque eu não escrevi uma função, por si só), isso seria apreciado.

Atualização: Bênção recebida, tudo é bom :)

Versão anterior:

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

A entrada é obtida da tabela preexistente $t$ com as colunas $w$ e$c$ , deacordo com nossas regras de IO.

Um byte a mais, mas por algum motivo um pouco mais agradável:

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

Esta versão funciona em um subconjunto de entradas que não incluem o numeral2 na primeira palavra $w$ .

Como estou no SQL, posso pré-carregar todos os exemplos na tabela e executá-los todos de uma vez:

Bater , 50 bytes

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

Experimente online!

-5 bytes devido à ajuda dos comentários abaixo.

Stax , 33 31 30 29 bytes

-1 graças a recursiva !

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

Execute e depure-o em staxlang.xyz!

Empurre cada componente para a pilha na ordem inversa e junte todos os espaços.

Descompactado (35 bytes) e explicação:

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

Tudo entre `` é literal de string compactado. Essa vírgula é vital. A última vez que li na pilha de entrada, devo aparecer em vez de espiar para evitar um "chuck" extra no final da minha saída.

Você notará que eu coloco as duas entradas na mesma linha para alguns casos de teste e que elas estão na ordem inversa. Isso é necessário para obter cadeias vazias ou cadeias de espaços como entrada.

27 26 bytes com restrições de entrada

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

Execute e depure-o em staxlang.xyz!

Assim como o SOGL do @ dzaima , isso falhará se a primeira entrada contiver a letra minúscula 'y'. Empurra a string "Quanto b seria a por y se a by poderia yb?" E faz um par de substituições.

JavaScript, 70 bytes

Entediante!

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

Experimente online!

Um pouco menos chato!

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

Experimente online!

SOGL , 32 30 bytes

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

Experimente aqui!

A primeira entrada não pode conter a letra y, que parece deixar um subconjunto razoável de ASCII (e unicode) restantes.

½ouiīZģ9Ο|ΧyΚ⅞ō÷Jeq(‚7‘é uma sequência compactada de "how much b would a by y if a by could y b?"(caracteres escolhidos para que as palavras necessárias estejam todas nas 512 palavras principais do dicionário que se compactam melhor) e depois bé substituída pela primeira entrada e ypela segunda.

R , 90 77 76 bytes

-13 graças a Sumner18
-1 graças a Giuseppe

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

Experimente online!

PHP , 72 bytes

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

Experimente online!

Ou:

PHP , 72 bytes

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

Experimente online!

Entrada da linha de comando, saída para STDOUT.

JavaScript (V8) , 72 bytes

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

Experimente online!

A atribuição da variável na verdade salva 0 bytes, mas achei que a manteria apenas para tornar isso um pouco exclusivo.

ZX Spectrum Basic, 87 bytes

Apenas para completar, implementação direta:

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

O uso da IFpalavra - chave (1 byte) reduz em 3 bytes, mas quebra a condição "mesma capitalização":

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

Ferrugem , 75 bytes

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

Experimente online!

Usando esse truque , você pode pular o índice de formatação uma vez por item para formatar.

Também usando print!(), porque é um byte menor do que construir format!()e retornar uma string .

05AB1E , 37 35 31 30 bytes

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

-5 bytes graças a @Grimy .

Leva uma lista de dois itens: woodcomo primeiro valor e chuckcomo segundo.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Veja esta dica 05AB1E meu (seção Como usar o dicionário? ) Para entender por que “Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“é "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$"?

O exemplo acima pode não parecer o BASIC adequado, mas a Applesoft permite alguns atalhos ao usar a PRINTinstrução:

• Uso de ?no lugar de PRINTao inserir a declaração
• Os caracteres de concatenação ( ;ou +) podem ser omitidos
• Se a instrução terminar em uma string entre aspas, a citação final poderá ser omitida Obrigado, Mark !

O número da linha é obrigatório ou a INPUTinstrução causará uma?ILLEGAL DIRECT ERROR

33 , 78 bytes

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

Experimente online!

Aceita a entrada como argumentos da linha de comando.

Bônus: 91 bytes

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

Experimente online!

Dá saída semelhante a si mesmo quando recebe entradas 1bztpe2bztp

Kotlin , 59 bytes

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

Experimente online!

PowerShell , 65 bytes

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

Experimente online!

A única coisa a observar é que você precisa escapar do ponto de interrogação, porque essas podem ser partes válidas de um identificador do 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

Também deveria funcionar como VBScript, usei dois atalhos: "ould" está se repetindo e "chuck" nunca aparece sem um espaço 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]);}}

Obrigado a Andrew Baumher por me falar sobre seqüências de caracteres interpoladas !!
EDIT: Classe completa agora adicionada
EDIT: Obrigado a Kenneth K. por me dar algumas dicas para reduzi-lo
EDIT: Obrigado a Andrew novamente por me dizer que o uso de seqüências de caracteres interpoladas é realmente mais longo nesse cenário.

Haskell , 76 bytes

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

Experimente online!

Primeira tentativa, então espero não ter quebrado nenhuma regra.

Geléia , 39 bytes

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

Um programa completo que aceita uma lista de duas strings.

Experimente online!

... Ou (também um programa completo que aceita uma lista de duas strings)

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

Experimente online!

Python 3 , 80 bytes

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

Experimente online!

quando estiver em roma, use o formato str.

Editado usando o truque do squid.

C # (compilador interativo do Visual C #) , 66 65 bytes

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

Experimente online!

igual a todos os outros, exceto C #. -1 byte usando a sequência de curry a => b => c em vez 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='')

Experimente online!

APL (Dyalog Unicode) , 56 59 bytes

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

Experimente online!

Dfn bastante simples. Salva um byte cortando∊ se for permitido retornar uma matriz de seqüências de caracteres em vez de uma única sequência.

3 bytes adicionados porque eu tinha esquecido de adicionar o ponto de interrogação.

Wolfram Language (Mathematica) , 68 bytes

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

Experimente online!

Geléia , 41 37 bytes

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

Experimente online!

Um programa completo usando um par de cadeias como argumento e imprimindo a cadeia processada. Um link monádico pode ser formado adicionando um Fno final (obrigado a @ JonathanAllan por apontar isso).

Agora mudei para o uso de "b" e "e" como espaços reservados, inspirados em na resposta SOGL do @ dzaima . Isso significa que a primeira palavra não pode incluir a letra e.

Japonês -S , 44 39 bytes

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

Tente

Quarto (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 ." ?";

Experimente online!

Código Explicação

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

Experimente online!

Programa completo, tome entrada como argumentos.

Nada de especial aqui. Espero que exista uma versão mais curta, mas não há maneiras óbvias de encurtar isso à primeira vista.

Bash , 58 bytes

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

Recebe entrada como argumentos de linha de comando. Experimente online!