Scrivi una funzione o un programma che impieghi due parole come input e produca varianti del popolare scioglilingua inglese "Quanto legno verrebbe lanciato da un ceppo se un ceppo potesse tagliare il legno?".

L'output utilizzerà la prima parola quattro volte

• Quanto woodsarebbe un woodmandrino a mandrino se un woodmandrino potesse mandar via wood?

e la seconda parola quattro volte

• Quanto legno sarebbe un legno chuck chuckse un legno chuckpotesse chucklegno?

con il resto dell'output uguale per tutti gli input.

• How muchlegno would amarmotta chuck if amarmotta couldchuck legno?

L'input e l'output possono essere in qualsiasi formato che la tua lingua riconosce ragionevolmente come gestire stringhe di testo. L'output deve essere esattamente nel formato indicato, inclusi lettere maiuscole, spazi e mancanza, e il punto interrogativo finale. Una nuova riga finale facoltativa è accettabile.

Idealmente, il codice gestirà l'input contenente qualsiasi carattere ASCII stampabile. Tuttavia, è consentito limitare l'input a sottoinsiemi ragionevoli di ASCII stampabile; indica questo nella tua risposta. Gestire set di caratteri più grandi va ovviamente bene.

Esempio di coppie input-output:

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

Questo è code-golf , quindi vince meno byte. Le risposte sono benvenute in tutte le lingue, anche se un'altra lingua può farlo in meno byte.

(Ispirato da questo meme , che utilizza una coppia di input migliore di questo modello rigido ....)

Python 3 , 70 67 byte

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

Provalo online!

Voglio dire, se la scarpa si adatta ..

Grazie a manatwork per la cattura di un errore di battitura

Grazie a Remco Haszing per l'eccellente idea di -3 byte

Sto scappando dal presupposto che questo sarebbe ancora un valido contributo (perché amico, è troppo bello non provarci). Se OP potesse chiarire se questo è accettabile (perché non ho scritto una funzione, di per sé), sarebbe apprezzato.

Aggiornamento: benedizione ricevuta, tutto va bene :)

Versione precedente:

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

T-SQL, 82 byte

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

L'input è preso dalla tabella preesistente con colonne e , secondo le nostre regole IO .$t$$w$$c$

Un byte in più, ma per qualche motivo leggermente più gradevole:

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

Questa versione funziona su un sottoinsieme di input che non include il numero 2nella prima parola .$w$

Poiché sono in SQL, posso precaricare tutti gli esempi nella tabella ed eseguirli tutti in una volta:

Bash , 50 byte

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

Provalo online!

-5 byte a causa di aiuto dai commenti qui sotto.

Stax , 33 31 30 29 byte

-1 grazie a ricorsivo !

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

Eseguilo e esegui il debug su staxlang.xyz!

Spingere ciascun componente nello stack in ordine inverso, quindi unire tutti con spazi.

Spacchettato (35 byte) e spiegazione:

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

Tutto tra '' è letterale stringa compressa. Quella virgola è vitale. L'ultima volta che ho letto dallo stack di input, devo pop piuttosto che sbirciare per evitare un "chuck" extra alla fine del mio output.

Noterai che ho inserito entrambi gli input sulla stessa riga per alcuni casi di test e che sono in ordine inverso. Ciò è necessario per prendere come input stringhe vuote o stringhe di spazi.

27 26 byte con restrizioni sull'input

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

Eseguilo e esegui il debug su staxlang.xyz!

Proprio come il SOGL di @dzaima , questo fallirà se il primo input contiene la lettera minuscola 'y'. Spinge la stringa "Quanto b sarebbe a by y se a by potrebbe yb?", Quindi effettua una coppia di sostituzioni.

JavaScript, 70 byte

Noioso!

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

Provalo online!

Leggermente meno noioso!

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

Provalo online!

SOGL , 32 30 byte

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

Provalo qui!

Il primo input non può contenere la lettera y, che sembra lasciare un sottoinsieme ragionevole di ASCII (e unicode).

½ouiīZģ9Ο|ΧyΚ⅞ō÷Jeq(‚7‘è una stringa compressa di "how much b would a by y if a by could y b?"(caratteri scelti in modo che le parole richieste siano tutte nelle prime 512 parole del dizionario che comprimono meglio), quindi bviene sostituita con il 1o input e ycon il 2o.

R , 90 77 76 byte

-13 grazie a Sumner18
-1 grazie a Giuseppe

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

Provalo online!

PHP , 72 byte

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

Provalo online!

O:

PHP , 72 byte

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

Provalo online!

Input dalla riga di comando, output a STDOUT.

JavaScript (V8) , 72 byte

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

Provalo online!

L'assegnazione della variabile in realtà salva 0 byte, ma ho pensato di tenerlo solo per renderlo leggermente unico.

ZX Spectrum Basic, 87 byte

Solo per completezza, implementazione diretta:

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

L'uso della IFparola chiave (1 byte) lo riduce di 3 byte, ma rompe la condizione di "stessa capitalizzazione":

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

Ruggine , 75 byte

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

Provalo online!

Usando questo trucco , che ti consente di saltare l'indice di formattazione una volta per elemento da formattare.

Anche usando print!(), perché è più corto di un byte rispetto alla creazione format!()e alla restituzione di una stringa .

05AB1E , 37 35 31 30 byte

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

-5 byte grazie a @Grimy .

Prende un elenco di due elementi: woodcome primo valore e chuckcome secondo.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo suggerimento 05AB1E mio (sezione Come utilizzare il dizionario? ) Per capire il motivo per cui “Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“è "How much1 would a ÿ0 if a ÿ could01?".

Applesoft BASIC, 77 76 byte

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

Quanto sopra potrebbe non sembrare BASIC corretto, ma Applesoft consente alcune scorciatoie quando si utilizza l' PRINTistruzione:

• Utilizzo ?al posto di PRINTquando si immette la dichiarazione
• I caratteri di concatenazione (o ;o +) possono essere omessi
• Se l'istruzione termina con una stringa tra virgolette, la citazione finale può essere omessa Grazie, Mark !

È richiesto il numero di riga o l' INPUTistruzione causerà un?ILLEGAL DIRECT ERROR

33 , 78 byte

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

Provalo online!

Accetta l'input come argomenti della riga di comando.

Bonus: 91 byte

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

Provalo online!

Fornisce un output simile a se stesso quando viene fornito input 1bztpe2bztp

Kotlin , 59 byte

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

Provalo online!

PowerShell , 65 byte

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

Provalo online!

L'unica cosa da notare è che devi sfuggire al punto interrogativo perché possono essere parti valide di un identificatore di PowerShell

VBA, 107 byte

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

Dovrei funzionare anche come VBScript, ho usato due scorciatoie: "ould" si ripete e "chuck" non appare mai senza uno spazio aggiuntivo.

C # , 165 148 133 byte

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

Grazie ad Andrew Baumher per avermi parlato delle stringhe interpolate !!
EDIT: ora è stata aggiunta la classe completa
EDIT: Grazie a Kenneth K. per avermi dato alcuni consigli per accorciarlo
EDIT: Grazie ancora ad Andrew per avermi detto che l'uso della stringa interpolata è in realtà più lungo in questo scenario.

Haskell , 76 byte

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

Provalo online!

Primo tentativo, quindi spero di non aver infranto alcuna regola.

Gelatina , 39 byte

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

Un programma completo che accetta un elenco di due stringhe.

Provalo online!

... O (anche un programma completo che accetta un elenco di due stringhe)

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

Provalo online!

Python 3 , 80 byte

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

Provalo online!

quando a roma, usa il formato str.

Modificato usando il trucco dei calamari.

C # (compilatore interattivo Visual C #) , 66 65 byte

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

Provalo online!

come tutti gli altri, tranne C #. -1 byte usando il curring strat a => b => c anziché (a, b) => c

R , 95 byte

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

Provalo online!

APL (Dyalog Unicode) , 56 59 byte

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

Provalo online!

Dfn piuttosto semplice. Salva un byte tagliando ∊se è consentito restituire un array di stringhe anziché una singola stringa.

3 byte aggiunti perché avevo dimenticato di aggiungere il punto interrogativo.

Wolfram Language (Mathematica) , 68 byte

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

Provalo online!

Gelatina , 41 37 byte

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

Provalo online!

Un programma completo che accetta una coppia di stringhe come argomento e stampa la stringa elaborata. Un collegamento monadico potrebbe essere formato aggiungendo un Falla fine (grazie a @JonathanAllan per averlo sottolineato).

Ora sono passato a usare "b" ed "e" come segnaposto, ispirati dalla risposta SOGL di @dzaima, quindi assicurati di votare anche quello! Ciò significa che la prima parola non può includere la lettera e.

Japt -S , 44 39 byte

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

Provalo

Forth (gforth) , 116 byte

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

Provalo online!

Spiegazione del codice

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

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

Provalo online!

Programma completo, accetta input come argomenti.

Niente di speciale qui. Spero che ci sia una versione più breve, ma nessun modo ovvio per accorciarlo a prima vista.

Bash , 58 byte

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

Accetta input come argomenti della riga di comando. Provalo online!