Hay un agujero en el fondo del mar

48

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 , por lo que gana la respuesta más corta en bytes para cada idioma.
Sok
fuente
66
Similar a There Was an Old Lady (otros desafíos similares, por ejemplo, esto se han cerrado como duplicados, aunque no creo que necesariamente deberían).
Jonathan Allan
66
Ho, ro, el pantano rattlin ', el pantano en el valle-o.
fəˈnɛtɪk
44
A modo de comparación (aunque no es un lenguaje de programación) lo gzip -5comprime a 186 bytes ( bzip2y xzparece que va peor).
Daniel Schepler
2
Felicidades, de otro padre desarrollador :)
AJFaraday
1
Quiero adaptar esta canción a 05AB1E ... "¡Hay un agujero en oh-five-ay-bee-one-ee!"
Urna de pulpo mágico el

Respuestas:

23

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
dzaima
fuente
14
Pero ... pero ¿cómo?
SomeShinyMonica
8
Increíble. ¿Cómo?
Austin Burk
1
¡HNQ ataca de nuevo! : \
Shaggy
44
¿Te importaría agregar una explicación? Curioso por ver cómo funciona.
Kevin Cruijssen
@KevinCruijssen agregado
dzaima
19

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

recursivo
fuente
2
¿Te importaría agregar una explicación? Curioso por ver cómo funciona.
Kevin Cruijssen
Lo haré pero todavía tengo la sensación de que un enfoque totalmente diferente funcionará mejor. Después de que tenga éxito o falle, explicaré lo que quede.
recursivo
1
@KevinCruijssen: Tenía la sensación de que había un enfoque mucho mejor. Efectivamente, lo reescribí por completo y guardé otros 12 bytes de hinchazón. También agregué alguna explicación.
recursivo
16

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

Nahuel Fouilleul
fuente
55
There's a bottom of the sea. Los hechos se verifican, +1
Jo King
:), también existe esta variación que comienza There's a seapero es más larga
Nahuel Fouilleul
13

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
TFeld
fuente
"hole, t%shole\n"%a[1:]guarda un byte
Jonathan Allan
Puede guardar un byte soltando el zip
Rod
@JonathanAllan Gracias :)
TFeld
@ Rod Gracias, :-)
TFeld
'oi'[s[5]<'n']también será una vieja alternativa: 'io'['g'in s]¡ Presentar !
Erik the Outgolfer
13

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!

Giacomo Garabello
fuente
2
¿Podrías escribir en su ,*b="_TH<0$\31\r"lugar?
Daniel Schepler
¿Guardaría bytes para definir "en el"?
OldBunny2800
@ OldBunny2800 no, ¡ sería más largo ! en este caso necesita al menos 6 ocurrencias para ser efectivo ...
Giacomo Garabello
12

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
Emigna
fuente
2
Puede eliminar el inicio õ, porque aparentemente genera una cadena vacía de forma predeterminada cuando sse utiliza un wap sin nada en la pila . No pude encontrar nada más para jugar al golf; muy buena respuesta!
Kevin Cruijssen
1
@KevinCruijssen: Oh, sí, no lo consideré, ya que generalmente hay aportes. Gracias :)
Emigna
11

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.

AdmBorkBork
fuente
-3 bytes :) ¡ Pruébelo en línea!
mazzy
@mazzy Ese es un truco inteligente. Tendré que tener eso en cuenta, porque uso -splitbastante para obtener palabras.
AdmBorkBork
180 bytes
Veskah
1
174. ¡ Pruébelo en línea!
mazzy
9

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!

Arnauld
fuente
8

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.

Nahuel Fouilleul
fuente
7

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
Lanudo
fuente
7

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.

Carne de res
fuente
5

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.

Neil
fuente
5

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!

Kirill L.
fuente
5

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.

Titus
fuente
4

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!

cleblanc
fuente
265 bytes
techo
4

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!

Jo King
fuente
4

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!

Oliver
fuente
4

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.

Neil
fuente
4

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!

Level River St
fuente
4

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"]
    )
Max Yekhlakov
fuente
1
Algunos consejos: a) ssolo los usa una vez, por lo que puede incluirlos en línea. b) siempre anteponer y añadir algo que t, por lo que puede hacer que sea una función (infija): t#u=t:"here's a "++u. c) la construcción de la lista grande en función lcon map(++" on the ")(words"smile flea ..."es más corta. Además: mueva todo lo adjunto a esa lista a la lista misma. d) la lista de números para soltar ahora va de 8abajo a 0(¡números de un solo dígito!) e) ahora la alineación itambién guarda algunos bytes. f) no es necesario nombrar su función principal. De acuerdo con nuestro meta, los valores de Haskell se consideran funciones adecuadas, por lo tanto, elimine el v=.
nimi
... En total 215 bytes ¡ Pruébelo en línea!
nimi
1
Otros 3 bytes para guardar: en lugar de la comprensión de la lista, puede usar >>=(concatMap) de la mónada de la lista y la concatfunción en línea l. Pruébalo en línea!
nimi
3

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!

Luis felipe De jesus Munoz
fuente
1
El segundo Ten la tercera línea de cada verso debe estar en minúsculas.
Shaggy
3

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.

Artemis Fowl
fuente
198 bytes
Sara J
@SaraJ Gracias. Estaba bajo la impresión (claramente equivocada) de que o=e=haría ambas cosas oy se ereferiría al mismo objeto. También pensé que la división sería más larga.
Artemis Fowl
@ArtemisFowl oy e no se refieren al mismo objeto ... es sólo que las cadenas son inmutables en Python así que cosas como +=van a crear una nueva copia en lugar de la mutación de la existente
ASCII de sólo
193
Solo ASCII
@ Solo ASCII Lo sé, pero pensé que Python de alguna manera se aseguró de que continuaran refiriéndose al mismo objeto.
Artemis Fowl
2

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!

Οurous
fuente
2

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
Stephen
fuente
2

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!

Xcali
fuente
194?
Solo ASCII
Sip. Buen trabajo. Debería haber recordado las nuevas líneas con certeza. He visto lo \lanterior, pero nunca tuve una razón para usarlo, así que nunca pensé en ello.
Xcali
190?
Solo ASCII
más cerca
ASCII solo
2

Carbón , 115106 bytes

≔There's a holeθEE⁹⁺…θχ⪫⮌…⪪”↶±∧⟲!↶⁼,(_⎇RB↧ω⪪zθⅉQθ`✳&⬤⸿◧σ⁻y▷»ΣK▶↙⁻υX`SξQ6 /ι⁹Wq”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.

⪪”↶±∧⟲!↶⁼,(_⎇RB↧ω⪪zθⅉQθ`✳&⬤⸿◧σ⁻y▷»ΣK▶↙⁻υX`SξQ6 /ι⁹Wq”x

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

E⁹⁺…θχ⪫⮌…...⁺²ι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.

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

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.

Neil
fuente
2

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)
Carne de res
fuente
2

/// , 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
Tanner Swett
fuente
2

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:

ingrese la descripción de la imagen aquí

sheß
fuente
2

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.

dana
fuente
1
Lamento haberte recordado que existe: o)
Sok
.Any()-> !=""?
Solo ASCII
también 223
solo ASCII
y no necesitas el espacio después inen foreach> _>
solo ASCII
@ASCIIOnly - Gracias por los consejos :)
dana