Mientras intentaba (y fracasaba) haber persuadido a mi pequeño hijo de cenar, intenté cantarle. A mitad de esta canción me di cuenta de que la estructura de la fórmula podría prestarse bien para el golf de código.

La tarea es escribir un programa o función que no acepte entradas y produzca el siguiente texto:

There's a hole in the bottom of the sea
There's a hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a log in the hole in the bottom of the sea
There's a log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a bump on the log in the hole in the bottom of the sea
There's a bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a frog on the bump on the log in the hole in the bottom of the sea
There's a frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

There's a smile on the flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a smile on the flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea
There's a hole, there's a hole
There's a hole in the bottom of the sea

Reglas de desafío:

• El texto puede imprimirse o devolverse como salida de función
• Cada verso está separado por una sola línea vacía
• El espacio en blanco final está bien siempre que no cambie el diseño (por lo que no hay espacios en blanco iniciales ni espacios adicionales entre palabras)
• Las nuevas líneas finales también están bien.
• No hay nuevas líneas principales.
• Todos los idiomas son bienvenidos, y este es el código de golf , por lo que gana la respuesta más corta en bytes para cada idioma.

SOGL , 103 94 93 bytes

Ψ ~Δ№Q‘离vζh‛←&M⁶╥7[P≈╔6≡⁸(φΔ\⅔Σ‚>≡ā⁷⁽○¹‘Ξ⁵K4s³‘⁽Bθ2n{@∑" the ”+Κ:bΚē‽:C}TPb"n@²‘+Tō, upcPøP

Pruébalo aquí!

...‘                 push "bottom of the sea" - kept for the loop, here for 
    ...‘             push "hole in log in bump on frog on wart on hair on fly on flea on smile on"
        ...‘         push "there's a "
            ⁽        uppercase the 1st letter of that
             B       save "There's a " in B
              θ      split the long data string on spaces
               2n    split in arrays of length 2

{                     for each of those:
 @∑                   join the current array with spaces - e.g. "hole in"
   " the ”+           append " the " to it
           Κ          prepend that to "bottom of the sea" (or whatever it is now)
            :         create a copy
             bΚ       prepend B to it - finishes current line
               ē‽:C}  if (E++), save a copy of that in C (for the last line)

TP                   print the current line twice
  b"...‘+            B + "hole" - "There's a hole"
         T           output that, keeping item
          ō,         output ", "
             up      print the kept item lowercased
               cP    print the contents of C
                 øP  print an empty line

Stax , 90 87 75 bytes

¥▌▼h4█☻■Ω1gçΔ¶Zjµ│☺X▄)/╞▄╒)¥jêLqα╧ñu┌⌂½╧ûⁿ↕O◘╔╪kl<æàbπïfuσ♪╫qΓ╪ûQ├╘Te♥Æó♣ƒE

Ejecutar y depurarlo

Desempaquetado, sin golf, y comentó que se ve así.

`;$w]i"50h1&V~OP>F$`            compressed literal for "There's a hole in the bottom of the sea"
X                               store in register X without popping
zG                              push an empty string and jump to the target (trailing }) 
`hfUiVx}.|j~vG12])Bxk?v zF`j    split "log bump frog wart hair fly flea smile" into array of words
F                               for each word, execute the following
  i. o. i?                      (i ? " o" : " i") where i is the 0-based iteration index
  +                             concatenate to the word
  `_o9!`+                       concatenate "n the "
  G                             jump to target below, resume next foreach iteration when finished
}                               this is the target of `G`, execution resumes when finished
  As|@                          insert substring at position 10
  QQ                            peek and print with newlines twice
  x14(                          trim string to leftmost 14 characters
  q                             peek and print without newlines
  ., p                          print ", " without newline
  vP                            lowercase 14 characters and print with newline
  xP                            push value of register X, then print with newline
  zP                            print blank line

Ejecute este

Perl 5, 158154 bytes

$_="There's a bottom of the sea
";for$,(<{{hole,log}" i",{bump,frog,wart,hair,fly,flea,smile}" o"}>){s/a/a $,n the/;say$_.$_.($t||=s/.{14}/$&, \l$&
$&/r)}

154 bytes

158 bytes

Python 2 , 202 190 187 185 183 182 181 bytes

s="bottom of the sea\n"
a="There's a "
for w in'hole log bump frog wart hair fly flea smile'.split():s=w+" %sn the "%'io'['g'in s]+s;print(a+s)*2+a+"hole, t%shole\n"%a[1:]+a+s[-30:]

Pruébalo en línea!

Antiguas alternativas a 'io'['g'in s](13 bytes):

• 14: 'oi'[s[5]<'n']
• 15: 'io'[len(s)>30], 'ioo'[len(s)%3], 'ooi'[len(s)%4], y'io'[w[1]=='o']

Salvado:

• -1 byte, gracias a Jonathan Allan
• -1 byte, gracias a Rod
• -1 byte, gracias a Erik the Outgolfer

C (gcc) , 261 246 236 bytes

#define X" on the "
char*a="smile"X"flea"X"fly"X"hair"X"wart"X"frog"X"bump"X"log in the hole in the bottom of the sea\n";f(i){for(i=0;i<9;)printf("T%s%sT%1$s%2$sT%1$shole, t%1$shole\nT%1$s%3$s\n","here's a ",a+"_TH<0$\31\r"[i++],a+95);}

-15 bytes, gracias a Daniel Schepler
-10 bytes, gracias a ceilingcat

Pruébalo en línea!

05AB1E , 103 100 99 97 96 93 92 bytes

Salvó un byte gracias a Kevin Cruijssen

“¥ÊˆŽ bumpÑå‡îtíÁ¤†îÌea¹²“#v’T€Î's a ’s„oiN2‹èy“ÿ ÿn€€ ÿ“©“—耂€€í™“JDN_iDU}X14£Dl‚„, ýXõ»,®

Pruébalo en línea!

Explicación

“¥ÊˆŽ bumpÑå‡îtíÁ¤†îÌea¹²“#vcomienza un ciclo sobre la lista ["hole", "log", "bump", "frog", "wart", "hair", "fly", "flea", "smile"]. Las palabras se comprimen usando el diccionario 05AB1E.

En cada uno hacemos:

’T€Î's a ’    # push the string "There's a "
s             # move the string from the previous iteration to the top of the stack
              # will be an empty string the first iteration since there is no input
„oiN2‹è       # push "i" for the first 2 iterations and "o" otherwise
y             # push the current word
“ÿ ÿn€€ ÿ“    # use interpolacing to create the meat of the current iteration string
              # meaning "hole in the ", "log in the hole in the " and so on
©             # store a copy in the register for the next iteration
“—耂€€í™“    # push the string "bottom of the sea"
JD            # join the whole line together and duplicate it
N_iDU}        # if this is the first iteration, store a copy of the line in X
X14£          # push the first 14 chars of X, which is "There's a hole"
Dl            # make a lower-case copy
‚„, ý         # join the original with the lowercase copy on ", ", forming line 3
X             # push X which is line 4
õ             # push and empty string, to create the line break between sections
»,            # join the whole section on newlines and print
®             # push the register for the next iteration

PowerShell , 194 188 185 180 174 bytes

$z=$a="in the bottom of the sea"
$b="here's a"
$h="$b hole"
echo hole log bump frog wart hair fly flea smile|%{,"T$b $_ $a"*2
$a='oi'[!$j++]+"n the $_ $a"
"T$h, t$h
T$h $z
"}

Pruébalo en línea!

Parece que no puedo atrapar a Python ...

Básicamente, establece algunos hilos comunes a $h, $a, $z, y $b, a continuación, pasa a través de un bucle a través de cada uno de los elementos ( hole, log, ... flea, smile), la salida de cada iteración el verso apropiado. Hay un poco de lógica !$j++en el medio para dar cuenta del cambio in/ onque sucede. De lo contrario, todas las cadenas solo quedan en la tubería, y el valor predeterminado Write-Outputnos da nuevas líneas de forma gratuita.

-6 bytes gracias a Arnauld.
-3 bytes gracias a mazzy.
-5 bytes gracias a Veskah.
-6 bytes gracias a mazzy.

JavaScript (ES6),  201 194 189 188  187 bytes

Guardado 1 byte gracias a @Shaggy

_=>`14log4bump5frog5wart5hair5fly5flea5smile5`.replace(/.+?\d/g,w=>`T0${(p=w+3+p)+p}1, t01
T01432
`.replace(/\d/g,n=>`here's a |hole|bottom of the sea
|n the | i| o`.split`|`[n]),p=`2T0`)

Pruébalo en línea!

JavaScript (ES6), 235 bytes

Simplemente RegPack'ed .

_=>[..."Z[]^_$cdjkqvxz{}~"].reduce((p,c)=>(l=p.split(c)).join(l.pop()),`Tj{{}qq}$$}~~}dd}__}xx}cc}[[v~ frogz$}v
Z{kZz on^x flyz_v], tj]Zkq log in^{k] in^ bottom of^ seajhere's ad wartz~c fleazx$ bumpzq_ hairzd^ the] hole[ smilezcZ
Tj`)

Pruébalo en línea!

Bash, 168160 bytes

r="There's a bottom of the sea
";for i in {hole,log}\ in {bump,frog,wart,hair,fly,flea,smile}\ on;{
r=${r/a/a $i the};t=${r:0:14};echo "$r$r${u=$t, ${t,}
$r}";}

160 bytes

168 bytes

Traducido de mi otra respuesta en Perl.

Japt -Rx, 126 116 113 112 111 109 107 bytes

Resulta que jugar al golf en un desafío de compresión de cuerdas mientras estás en tu teléfono, el boozer es increíblemente difícil, ¿quién habría tocado?

`T's»dâ ÈÞ­omºfdÈ a`rdS
tE8
¯E
`logn¿mpnfgnØnirnf§nf¤Úè`qÍË2ÆiAV¯E©8 iF¯E ÔqVri'oÃpW+v iSi,)UPÃc

Pruébalo

                                              :The first 3 lines get assigned to variables U, V & W, respectively
`...`                                         :The compressed string "There'sdadholedindthedbottomdofdthedsea"
     rdS                                      :Replace all "d"s with spaces
tE8                                           :Substring of U from 0-based index 14 (E), of length 8 (="  in the ")
¯E                                            :Slice U to index 14 (="There's a hole")
`...`                                         :The compressed string "lognbumpnfrognwartnhairnflynfleasmilent"
     qÍ                                       :Split on "n" (note that the last element is irrelevant)
       Ë                                      :Map each element at 0-based index E in array F
        2Æ                                    :  Map the range [0,2)
          iA                                  :    Insert the following in U at index 10
            V¯                                :      V sliced to index
              E©8                             :        Logical AND of E and 8 (=0 on first iteration, 8 on all others)
                  i                           :      Prepend
                   F¯E                        :        Slice F to index E
                       Ô                      :        Reverse
                        q                     :        Join with
                         Vri'o                :          Replace "i" with "o" in V
                              Ã               :  End map
                               p              :  Push
                                W+            :    W appended with
                                  v           :      W lowercased
                                    iSi,      :      Prepended with a space prepended with a comma
                                        )     :    End append
                                         UP   :    U and an empty string
                                           Ã  :End map
                                            c :Flatten
                                              :Implicitly join with newlines, trim & output

XML, 719 673 603 514 493 486 bytes

<!DOCTYPE a[<!ENTITY T "There's a"><!ENTITY O " on the"><!ENTITY a " hole in the bottom of the sea
"><!ENTITY b " log in the&a;"><!ENTITY c " bump&O;&b;"><!ENTITY d " frog&O;&c;"><!ENTITY e " wart&O;&d;"><!ENTITY f " hair&O;&e;"><!ENTITY g " fly&O;&f;"><!ENTITY i " flea&O;&g;"><!ENTITY z "&T; hole, there's a hole
&T;&a;
">]><a>&T;&a;&T;&a;&z;&T;&b;&T;&b;&z;&T;&c;&T;&c;&z;&T;&d;&T;&d;&z;&T;&e;&T;&e;&z;&T;&f;&T;&f;&z;&T;&g;&T;&g;&z;&T;&i;&T;&i;&z;&T; smile&O;&i;&T; smile&O;&i;&z;</a>

Puedes "ejecutarlo" con xmlstarlet sel -t -m '//a' -v . -n <xml_file_here>.

Esto sería mucho más fácil si XML no fuera tan detallado, pero en el lado positivo, esto es menos del 25% del tamaño del texto original.

Retina 0.8.2 , 150 bytes

THsmile oNflea oNfly oNhair oNwart oNfrog oNbump oNlog iNE
N
$&$'¶TH
O^$`

.+
$&¶$&¶THW, tHW¶THE¶
H
here's a 
E
W iNbottom of the sea
W
hole
N
n the 

Pruébalo en línea! Explicación:

THsmile oNflea oNfly oNhair oNwart oNfrog oNbump oNlog iNE

Inserta el último verso.

N
$&$'¶TH

Calcule todos los versos.

O^$`

Pon los versos en el orden correcto.

.+
$&¶$&¶THW, tHW¶THE¶

Completa cada verso y agrega el coro.

H
here's a 
E
W iNbottom of the sea
W
hole
N
n the 

Expandir algunos marcadores de posición.

R , 237 231 bytes

i=" in the "
for(j in 0:8)cat(f<-c(t<-"There's a ",paste(c("log","bump","frog","wart","hair","fly","flea","smile")[j:0],collapse=" on the "),if(j)i,h<-"hole",i,b<-"bottom of the sea
"),f,t,h,", there's a ",h,"
",t,h,i,b,"
",sep="")

Pruébalo en línea!

PHP, 180 178 bytes

foreach([hole,log,bump,frog,wart,hair,fly,flea,smile]as$w)echo$a=T.($b="here's a ").($s="$w ".io[++$i>2]."n the $s").$c="bottom of the sea
",$a,T,$b.=hole,", t$b
T$b in the $c
";

Ejecutar -nro probarlo en línea .

Produce advertencias en PHP 7.2; para arreglarlo, ponga comillas alrededor de
los elementos de la matriz io, holey los dos independientes T.

C (gcc) , 334 328 307 299 bytes

char*s="here's a \0smile on the flea on the fly on the hair on the wart on the frog on the bump on the log in the hole in the bottom of the sea\n";i;k=105;a[]={0,1,1,1,1,0,1,2,2};main(j){for(;i<9;k-=11+a[i++])do{printf("T%s%s",s,s+k);}while(j++&1||!printf("T%shole, t%shole\nT%s%s\n",s,s,s,s+105));}

Pruébalo en línea!

Perl 6 , 166 bytes

($/=@(($!="There's a")X [\R,](<hole log bump frog wart hair fly flea smile>Z(<i o>[$++>1]~"n the")xx*)X"bottom of the sea
")).map:{say "$_$_$! hole, {$!.lc} hole
$0"}

Pruébalo en línea!

Japt -R , 142 bytes

`—¤clogc¿mpcfžgcØÖŽrcf§cf¤acsÚè`qc
`ˆ e Þ­om  e  a`
`T”œ's a `
£W+U¯YÄ ÔËE?"io"gE<Y +`n e `:P +Dø+` {V}
` ²+W+`—¤, t”œ's a —¤
{W}—¤ {V+R

Pruébalo en línea!

Lote, 267 bytes

@echo off
set r=i
set t= There's a hole
set s=bottom of the sea
for %%w in (hole log bump frog wart hair fly flea smile)do call:c %%w
exit/b
:c
set s=%1 %r%n the %s%
echo%t:~,11%%s%
echo%t:~,11%%s%
echo%t%,%t:T=t%
echo%t%%s:~-25%
echo(
if %1==log set r=o

tcontiene una cadena repetida en el coro, scontiene la mayor parte de la línea del verso, mientras que relige entre in they on the. En los versos, solo tse necesitan los primeros 11 caracteres de , mientras que en la primera línea de coro la segunda copia ttiene Tminúsculas y la segunda línea de coro reutiliza los últimos 25 caracteres de s.

Ruby , 173 170 bytes

a="T#{["here's a hole"]*3*"%s"%[", t","
T"]+c=" in the "}bottom of the sea

"
b=a[31,39]
%w{log bump frog wart hair fly flea smile x}.map{|i|puts b,b,a;b[9]+=i+c;c[1]=?o}

Pruébalo en línea!

Haskell , 243 215 bytes

Reducido a 215 bytes con gran ayuda de nimi

c[[l n,l n,'T'#h++", "++'t'#h,l 8,""]|n<-[8,7..0]]
t#u=t:"here's a "++u
h="hole"
c=concat
l n='T'#c(drop n$map(++" on the ")(words"smile flea fly hair wart frog bump")++["log in the ",h," in the bottom of the sea"])

Pruébalo en línea!

(La versión anterior de 243 bytes está aquí ).

Una solución bastante sencilla.

-- main function producing a list of lines
v = concat [[
    l n,
    l n, -- second line of each verse equals to its first line
    'T' # h ++ ", " ++ 't' # h,
    l 8, -- last line of each verse is the same in all verses
    ""
  ] | n <- [8,7..0]]

-- a small helper to construct similar strings 
t # u = t : "here's a " ++ u

h = "hole"

-- construct a first line of n-th verse (with n = 8 is the first and n = 0 is the last one)
-- Every such line begins with a constant prefix followed by expanding list of nested entities
l n = 'T' # concat (
      drop n $
         map (++ " on the ") (words "smile flea fly hair wart frog bump")
         ++ ["log in the ", h, " in the bottom of the sea"]
    )

JavaScript (nodo Babel) , 239 bytes

-7 bytes de @Oliver *.*

(x=0,r='hole0log0bump0frog0wart0hair0fly0flea0smile'.split`0`).map(a=>(t=(i="There's a ")+a+r.slice(0,x++).reverse().map((h,_)=>` ${"io"[_<x-2|0]}n the ${h}`).join``+(o=` in the bottom of the sea
`))+t+(`${k=i+"hole"}, ${k}
`)+k+o).join`
`

Pruébalo en línea!

Python 3 , 213 206 198 193 bytes

k='n the ';o=e='bottom of the sea\n';b="There's a ";h='hole'
for j in[h]+'log bump frog wart hair fly smile'.split():o=j+' '+'io'['g'in o]+k+o;print(b+o+b+o+b+h+', t'+b[1:]+h+'\n'+b+h+' i'+k+e)

Pruébalo en línea!

-15 bytes gracias a @Sara
-5 bytes gracias a @ ASCII-only

Probablemente un poco más golfable, pero no mucho.

Limpio , 267 bytes

import StdEnv,Text,Data.List
t="here's a "
h="hole"
b=" in the bottom of the sea"
f=foldr((+)o\s#p="T"+t+join" on the "(reverse s)+" in the "+h+b
=join"\n"[p,p,"T"+t+h+", t"+t+h+"\nT"+t+h+b+"\n\n"])""(tl(inits["log","bump","frog","wart","hair","fly","flea","smile"]))

Pruébalo en línea!

cQuents , 238 219 bytes

|@
#36::"T"~c1)~j\rbk));@ )~c2,Z,"T"~c1)~"hole, t"~c1)~"hole","T"~c1)~c2)~@

::"","log in the","bump"~c3,"frog"~c3,"wart"~c3,"hair"~c3,"fly"~c3,"flea"~c3,"smile"~c3
:"here's a ","hole in the bottom of the sea"," on the"

Pruébalo en línea!

Este desafío me hizo finalmente implementar listas y cadenas en mi idioma. Este lenguaje está construido para secuencias enteras, por lo que funcionó bastante bien.

Explicación

:"here's a ","hole in the bottom of the sea"," on the"

    helper line: c1), c2), and c3) access the three terms in this list

::"","log in the","bump"~c3,"frog"~c3,"wart"~c3,"hair"~c3,"fly"~c3,"flea"~c3,"smile"~c3

    helper line: yields a list containing the first n terms in it, accessed with bx)
    for example, the first three terms are:

"","log in the","bump"~c3

    so b3) would yield ["","log in the","bump on the"] (~ is concatenation and c3 is " on the")


|@
#36::"T"~c1)~j\rbk));@ )~c2,Z,"T"~c1)~"hole, t"~c1)~"hole","T"~c1)~c2)~@


|@
                              join sequence on literal newline
#36::                         output first 36 terms in sequence joined together
                              following are the 4 terms in the sequence, which will cycle through 9 times (for a total of 36 terms)
"T"~c1)~j\rbk));@ )~c2,       first term
"T"~c1)~                      "T" concat "here's a " concat
        j\rbk));@ )           the first k terms of b, reversed, and joined on " "
                   ~c2,       concat "hole in the bottom of the sea"
Z,                            second term - same as previous
"T"~c1)~"hole, t"~c1)~"hole", third term
"T"~c1)~                      "T" concat "here's a " concat
        "hole, t"~c1)~"hole", "hole, t" concat "here's a " concat "hole"
"T"~c1)~c2)~@
                              fourth term - "T" concat "here's a " concat "hole on the bottom of the sea" concat newline

Perl 5 , 194 bytes

@ ASCII solo redujo 6 bytes con nuevas líneas literales y un \ltruco que olvidé

$"=" on the ";say+($b=($e="There's a ").hole,$c=" in the bottom of the sea",$/)x2,$.="$b, \l$b
$b$c
";say"$e@a[-$_..-1] in the hole$c
"x2,$.for 1..(@a=qw/smile flea fly hair wart frog bump log/)

Pruébalo en línea!

Carbón , 115106 bytes

≔There's a holeθＥＥ⁹⁺…θχ⪫⮌…⪪”↶±∧⟲!↶⁼,(_⎇ＲB↧ω⪪zθⅉＱθ`✳＆⬤⸿◧σ⁻y▷»ΣＫ▶↙⁻υＸ`SξQ6 /ι⁹Ｗq”x⁺²ιn the ⟦ιι⁺⁺θ, ↧θ⁺θ✂ι±²⁵

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: ahorré 9 bytes copiando mi código de lote para la última línea del coro. Explicación:

≔There's a holeθ

Guarde la cadena There's a hole, que se usa dos veces como está, una tercera vez en minúsculas y también una cuarta vez, pero solo los primeros 10 caracteres.

⪪”↶±∧⟲!↶⁼,(_⎇ＲB↧ω⪪zθⅉＱθ`✳＆⬤⸿◧σ⁻y▷»ΣＫ▶↙⁻υＸ`SξQ6 /ι⁹Ｗq”x

Dividir la cuerda bottom of the seaxhole ixlog ixbump oxfrog oxwart oxhair oxfly oxflea oxsmile oen xs.

Ｅ⁹⁺…θχ⪫⮌…...⁺²ιn the 

Pase los 9 versos, tome los primeros i+2elementos de la matriz, inviértalos n the, únalos y prefije There's ael resultado.

Ｅ...⟦ιι⁺⁺θ, ↧θ⁺θ✂ι±²⁵

Expande cada línea en un verso duplicando la línea y construyendo el coro. Cada línea del verso se imprime implícitamente en cada línea, y cada verso se separa implícitamente por una línea en blanco.

V , 184 170 bytes

4iThere's a hole in the bottom of the sea
kky5w5eá,lpD5brtHj4yyGp4w8ion the 2briilog 3bibump 3bifrog 3biwart 3bihair 3bifly 3biflea 3bismile 7ñ4yykp4wd3wñ8ñÄ5jñ

Pruébalo en línea!

Explicación:

• 4iThere's a hole in the bottom of the sea<\n><esc> Inserte "Hay un agujero en el fondo del mar" 4 veces.
• kk Pasar a la tercera línea
• y5w copia "Hay un agujero"
• 5eá, inserte una coma después de "Hay un agujero"
• lp pegar después de la coma
• D eliminar el resto de la línea
• 5brt minúscula la segunda T
• Hj4yy copia 4 líneas de la segunda línea
• Gp Pega todo después de la primera línea
• 4w8ion the <esc>(al final del primer verso) pasar al primer "hoyo" en el segundo verso e insertar "en el" 8 veces
• 2briilog <esc> mover hacia atrás hasta el último "encendido", reemplazar la o con una i y luego insertar "log"
• 3bibump <esc>3bifrog <esc>3biwart <esc>3bihair <esc>3bifly <esc>3biflea <esc>3bismile <esc> Muévase hacia atrás a través de la línea, insertando las palabras apropiadas entre cada "en el"
• 7ñ4yykp4wd3wñejecutar 4yykp4wd3w7 veces
  • 4yykp duplicar el verso antes de este
  • 4wd3w pasar a la primera palabra después de "Hay un agujero" y eliminar 3 palabras
• 8ñÄ5jñ duplicar la primera línea de cada verso después del primero (hay 8 de estos para hacer)

/// , 216 bytes

/V/\/\///U/\/ VS/TCVR/iBVQUtheVPUoBVOUholeVN/RASVM/ASO, tCO
SA
VL/RMSVKUlog VJUbumpPKVIUfrogPJVHUwartPIVGUhairPHVFUflyPGVEUfleaPFVDUsmilePEVC/here's aVB/nQVA/O R bottom ofQ sea
/SASMSKNKLJNJLINILHNHLGNGLFNFLENELDNDRM

Pruébalo en línea!

Este tipo de tarea es la única cosa en la que /// es razonablemente bueno. : D ¡Hey, el resultado es más corto que C, C # o Java!

La salida de este programa termina en dos saltos de línea finales; Espero que eso no sea un factor decisivo.

De todos modos, no hay inteligencia real aquí. Simplemente identifiqué cadenas repetidas y definí atajos de un carácter para ellas, y repetí hasta que no vi más cadenas repetidas. Hice esto de una manera más o menos ingenua y codiciosa. Sin embargo, definí intencionalmente un atajo para "sonreír en la pulga en el ... mar", seguido de "pulga en la mosca en el ... mar", y así sucesivamente, para formar una cadena de atajos . El resultado es que toda la secuencia de nombres nuevos es claramente visible en el código, y eso me parece bastante agradable. :)

Después de reemplazar V y U, tenemos el siguiente código más legible:

/S/TC//R/iB//Q/ the//P/ oB//O/ hole//N/RAS//M/ASO, tCO
SA
//L/RMS//K/ log //J/ bumpPK//I/ frogPJ//H/ wartPI//G/ hairPH//F/ flyPG//E/ fleaPF//D/ smilePE//C/here's a//B/nQ//A/O R bottom ofQ sea
/SASMSKNKLJNJLINILHNHLGNGLFNFLENELDNDRM

LaTeX, 265 268 caracteres

\documentclass{book}\input{pgffor}\def\i{bottom of the sea}\let~\i\def\b{here's a }\def\h{hole}\def\s#1{ in}\begin{document}\foreach\x in{\h\s,log\s,bump,frog,wart,hair,fly,flea,smile}{\xdef~{\x{ on} the ~}T\b~\\T\b~\\T\b\h, t\b\h\\T\b\h\,in the \i\par}\enddocument

compila en un buen PDF, con sangrías de párrafo y todo

Ungolfed y comentó:

\documentclass{book}
\input{pgffor}
\def\i{bottom of the sea}   %for re-use in the last two verses 
\let~\i                     %here I keep attaching words
\def\b{here's a }               
\def\h{hole}
\def\s#1{ in}               %this replaces the next token with "in", useful for log and hole where "in" is used instead of"on"
\begin{document}
\foreach\x in{\h\s,log\s,bump,frog,wart,hair,fly,flea,smile}{
    \xdef~{\x{ on} the ~}   %keep attaching words and on/on to ~
    T\b~\\                  %verse 1
    T\b~\\                  %verse 2
    T\b\h, t\b\h\\          %verse 3
    T\b\h\,in the \i\par    %verse 4
}
\enddocument

De salida:

C # (compilador interactivo de Visual C #) , 220 bytes

string b="There's a ",d="hole in the bottom of the sea\n",e,f;" log bump frog wart hair fly flea smile".Split().Any(s=>Write((e=b+(f=s!=""?s+(f!=""?" o":" i")+"n the "+f:s)+d)+e+b+$@"hole, there's a hole
{b+d}
")is int);

Pruébalo en línea!

-5 bytes gracias a @ASCIIOnly y -2 bytes gracias a @someone!

Tengo un hijo pequeño y puedo asegurarles que esta canción es a la vez pegadiza y molesta.