Há um buraco no fundo do mar

48

Enquanto tentava (e falhei) convencer meu filho a comer o jantar, tentei cantar para ele. No meio dessa música, eu percebi que a estrutura da fórmula poderia se dar bem no código do golfe!

A tarefa é escrever um programa ou função que não aceita entrada e produz o seguinte 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

Regras do desafio:

  • O texto pode ser impresso ou retornado como saída de função
  • Cada verso é separado por uma única linha vazia
  • O espaço em branco à direita é aceitável, desde que não mude o layout (portanto, não há espaço em branco à esquerda nem espaços extras entre as palavras)
  • As novas linhas à direita também são boas.
  • Não há novas linhas principais.
  • Todos os idiomas são bem-vindos, e isso é ; portanto, a resposta mais curta em bytes para cada idioma vence!
Sok
fonte
6
Semelhante a Havia uma velha senhora (outros desafios semelhantes, por exemplo , foram fechados como duplicatas, embora eu ache que não devam necessariamente).
Jonathan Allan
6
Ho, ro, o pântano, o pântano no vale.
fəˈnɛtɪk 30/01
4
Para comparação (embora não seja uma linguagem de programação), a gzip -5compacta em 186 bytes ( bzip2e xzparece piorar).
Daniel Schepler 30/01
2
Parabéns, de outro pai desenvolvedor :)
AJFaraday 31/01
1
Eu quero adaptar essa música para 05AB1E ... "Há um buraco no oh-cinco-ay-bee-one-ee!"
Magic Octopus Urn

Respostas:

23

SOGL , 103 94 93 bytes

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

Experimente aqui!

...‘                 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
fonte
14
Mas .... mas como?
SomeShinyObject
8
Incrível. Como até--
Austin Burk
1
HNQ ataca novamente! : \
Shaggy
4
Você se importaria de adicionar uma explicação? Curioso para ver como funciona.
Kevin Cruijssen
@KevinCruijssen adicionou
dzaima
19

Stax , 90 87 75 bytes

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

Execute e depure

Descompactado, não jogado e comentou que é assim.

`;$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

Execute este

recursivo
fonte
2
Você se importaria de adicionar uma explicação? Curioso para ver como funciona.
Kevin Cruijssen
Eu vou, mas ainda tenho a sensação de que uma abordagem totalmente diferente fará melhor. Depois que eu tiver sucesso ou falhar, explicarei o que resta.
recursivo em
1
@KevinCruijssen: Tive a sensação de que havia uma abordagem muito melhor. Com certeza, eu reescrevi totalmente e salvei outros 12 bytes de inchaço. Eu adicionei algumas explicações também.
recursivo
16

Perl 5, 158 154 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
fonte
5
There's a bottom of the sea. Os fatos confirmam, +1
Jo King
:), há também esta variação começando com There's a seamas é mais
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:]

Experimente online!

Alternativas antigas para 'io'['g'in s](13 bytes):

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

Salvou:

  • -1 byte, graças a Jonathan Allan
  • -1 byte, graças a Rod
  • -1 byte, graças a Erik the Outgolfer
TFeld
fonte
"hole, t%shole\n"%a[1:]salva um byte
Jonathan Allan
Você pode salvar um byte , soltando o zip
Rod
@JonathanAllan Thanks :)
TFeld
@Rod Obrigado, :-)
TFeld 30/01
'oi'[s[5]<'n']também será uma alternativa antiga: Featuring 'io'['g'in s]!
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, graças a Daniel Schepler
-10 bytes, graças a tetocat

Experimente online!

Giacomo Garabello
fonte
2
Você poderia escrever ,*b="_TH<0$\31\r"?
Daniel Schepler 30/01
Economizaria bytes para definir "no"?
OldBunny2800 31/01
@ OldBunny2800 não, seria mais longo ! neste caso, você precisa de pelo menos 6 ocorrências para ser eficaz ...
Giacomo Garabello
12

05AB1E , 103 100 99 97 96 93 92 bytes

Guardou um byte graças a Kevin Cruijssen

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

Experimente online!

Explicação

“¥ÊˆŽ bumpÑå‡îtíÁ¤†îÌea¹²“#vinicia um loop sobre a lista ["hole", "log", "bump", "frog", "wart", "hair", "fly", "flea", "smile"]. As palavras são compactadas usando o dicionário 05AB1E.

Em cada um de nós:

’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
fonte
2
Você pode remover a guia inicial õ, porque, aparentemente, gera uma string vazia por padrão quando um swap é usado sem nada na pilha . Não consegui encontrar mais nada para jogar golfe; resposta muito boa!
Kevin Cruijssen 31/01
1
@KevinCruijssen: Ah, sim, eu não considerei isso, pois geralmente há informações. Obrigado :)
Emigna 31/01
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
"}

Experimente online!

Não consigo pegar Python ...

Basicamente, define algumas cordas comuns $h, $a, $z, e $b, em seguida, passa por um loop através de cada um dos itens ( hole, log... flea, smile), cada iteração saída do verso apropriado. Há um pouco de lógica !$j++no meio para explicar a opção in/ onque acontece. Caso contrário, todas as strings serão deixadas no pipeline e o padrão Write-Outputnos fornecerá novas linhas gratuitamente.

-6 bytes graças a Arnauld.
-3 bytes graças ao mazzy.
-5 bytes graças ao Veskah.
-6 bytes graças ao mazzy.

AdmBorkBork
fonte
-3 bytes :) Experimente online!
mazzy 31/01
@mazzy Esse é um truque inteligente. Precisarei ter isso em mente, porque uso -splitbastante para obter palavras.
AdmBorkBork 31/01
Dois bytes esquecidos
Veskah 31/01
180 bytes
Veskah 31/01
1
174. Experimente online!
mazzy
9

JavaScript (ES6),  201 194 189 188  187 bytes

Guardado 1 byte graças 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`)

Experimente online!


JavaScript (ES6), 235 bytes

Simplesmente 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`)

Experimente online!

Arnauld
fonte
8

Bash, 168 160 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

Traduzido da minha outra resposta em Perl.

Nahuel Fouilleul
fonte
7

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

Acontece que jogar golfe em um desafio de compressão de cordas enquanto você está no telefone é incrivelmente difícil - quem teria pensado ?!

`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

Teste-o

                                              :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
Shaggy
fonte
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>

Você pode "executá-lo" com xmlstarlet sel -t -m '//a' -v . -n <xml_file_here>.

Isso seria muito mais fácil se o XML não fosse tão detalhado, mas, pelo lado positivo, isso é menos de 25% do tamanho do texto original.

Beefster
fonte
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 

Experimente online! Explicação:


THsmile oNflea oNfly oNhair oNwart oNfrog oNbump oNlog iNE

Insira o último verso.

N
$&$'¶TH

Calcule todos os versos.

O^$`

Coloque os versículos na ordem correta.

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

Complete cada versículo e adicione o refrão.

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

Expanda alguns espaços reservados.

Neil
fonte
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="")

Experimente online!

Kirill L.
fonte
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
";

Corra com -nrou experimente online .

Gera avisos no PHP 7.2; Para corrigir, coloque aspas em torno
dos elementos da matriz, io, holee os dois autônomo T.

Titus
fonte
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));}

Experimente online!

cleblanc
fonte
265 bytes
ceilingcat
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"}

Experimente online!

Brincadeira
fonte
4

Japonês -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

Experimente online!

Oliver
fonte
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

tcontém uma sequência repetida no coro, scontém a maior parte da linha do verso, enquanto rescolhe entre in thee on the. Nos versos, apenas os 11 primeiros caracteres de tsão necessários, enquanto na primeira linha de coro a segunda cópia ttem Tletras minúsculas e a segunda linha de coro reutiliza os últimos 25 caracteres de s.

Neil
fonte
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}

Experimente online!

Level River St
fonte
4

Haskell , 243 215 bytes

Reduzido para 215 bytes com grande ajuda do 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"])

Experimente online!

(A versão antiga de 243 bytes está aqui ).

Uma solução bastante direta.

-- 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
fonte
1
Algumas dicas: a) você usa sapenas uma vez para poder incorporá-lo. b) você sempre preceder e acrescentar algo para t, assim você pode torná-lo uma função (infix): t#u=t:"here's a "++u. c) construir a grande lista em função lcom map(++" on the ")(words"smile flea ..."o menor. Além disso: mova tudo o que foi anexado a essa lista para a própria lista. d) a lista de números a cair agora passa de 8baixo para 0(números de um dígito!) e) agora inlining itambém salva alguns bytes. f) não há necessidade de nomear sua função principal. De acordo com nossa meta, os valores de Haskell são considerados funções apropriadas v=;
nimi 31/01
... Ao todo 215 bytes Experimente online!
nimi 31/01
1
Outros 3 bytes para salvar: em vez da compreensão da lista, você pode usar >>=(concatMap) a partir da lista monad e concatda função inline l. Experimente online!
nimi 01/02
3

JavaScript (Nó 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`
`

Experimente online!

Luis felipe De jesus Munoz
fonte
1
O segundo Tna terceira linha de cada versículo deve estar em 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)

Experimente online!


-15 bytes graças a @Sara
-5 bytes graças a @ somente ASCII

Provavelmente um pouco mais jogável, mas não muito.

Artemis Fowl
fonte
198 bytes
Sara J
@SaraJ Thanks. Eu estava com a impressão (claramente equivocada) de o=e=criar as duas coisas oe se ereferir ao mesmo objeto. Eu também pensei que a divisão seria mais longa.
Artemis Fowl
@ArtemisFowl oe e que se referem ao mesmo objeto ... é só que strings são imutáveis em Python para que coisas como +=vai criar uma nova cópia em vez de mutação do já existente
ASCII-only
193
somente ASCII
@ Somente ASCII eu sei, mas achei que o python de alguma forma garantiu que continuassem se referindo ao mesmo objeto.
Artemis Fowl
2

Limpo , 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"]))

Experimente online!

Furioso
fonte
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"

Experimente online!

Esse desafio me fez finalmente implementar listas e strings no meu idioma. Essa linguagem foi criada para seqüências inteiras, e foi muito bem!

Explicação

:"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
fonte
2

Perl 5 , 194 bytes

@ Somente ASCII eliminou 6 bytes com novas linhas literais e um \ltruque que eu esqueci

$"=" 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/)

Experimente online!

Xcali
fonte
194?
somente ASCII em
Sim. Bom trabalho. Eu deveria ter me lembrado das novas linhas com certeza. Eu já vi o \lantes, mas nunca tive um motivo para usá-lo, então nunca pensei nisso.
Xcali 31/01
190?
somente ASCII em
mais perto
apenas ASCII
2

Carvão , 115 106 bytes

≔There's a holeθEE⁹⁺…θχ⪫⮌…⪪”↶±∧⟲!↶⁼,(_⎇RB↧ω⪪zθⅉQθ`✳&⬤⸿◧σ⁻y▷»ΣK▶↙⁻υX`SξQ6 /ι⁹Wq”x⁺²ιn the ⟦ιι⁺⁺θ, ↧θ⁺θ✂ι±²⁵

Experimente online! Link é a versão detalhada do código. Editar: salvou 9 bytes, copiando meu código de lote para a última linha do refrão. Explicação:

≔There's a holeθ

Salve a string There's a hole, que é usada duas vezes como está, uma terceira vez em letras minúsculas e também uma quarta vez, mas apenas os 10 primeiros caracteres.

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

Divida a sequência bottom of the seaxhole ixlog ixbump oxfrog oxwart oxhair oxfly oxflea oxsmile oem xs.

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

Passe os 9 versículos, pegando os primeiros i+2elementos da matriz, revertendo-os, juntando-os n thee prefixando There's ao resultado.

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

Expanda cada linha em um verso duplicando a linha e construindo o refrão. Cada linha do verso é impressa implicitamente em cada linha, e cada verso é implicitamente separado por uma linha em branco.

Neil
fonte
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ñ

Experimente online!

Explicação:

  • 4iThere's a hole in the bottom of the sea<\n><esc> Inserir "Há um buraco no fundo do mar" 4 vezes.
  • kk Mover para a terceira linha
  • y5w cópia "Há um buraco"
  • 5eá, insira uma vírgula após "Existe um buraco"
  • lp cole após a vírgula
  • D excluir o resto da linha
  • 5brt minúsculas o segundo T
  • Hj4yy copie 4 linhas da segunda linha
  • Gp Cole tudo após a primeira linha
  • 4w8ion the <esc>(no final do primeiro verso) vá para o primeiro "buraco" no segundo verso e insira "no" 8 vezes
  • 2briilog <esc> retroceda até o último "on", substitua o por um ie insira "log"
  • 3bibump <esc>3bifrog <esc>3biwart <esc>3bihair <esc>3bifly <esc>3biflea <esc>3bismile <esc> Mover para trás pela linha, inserindo as palavras apropriadas entre cada "no"
  • 7ñ4yykp4wd3wñexecutar 4yykp4wd3w7 vezes
    • 4yykp duplicar o verso antes deste
    • 4wd3w vá para a primeira palavra depois de "Existe um buraco" e exclua 3 palavras
  • 8ñÄ5jñ duplique a primeira linha de cada versículo após o primeiro (há 8 delas para fazer)
Beefster
fonte
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

Experimente online!

Esse tipo de tarefa é a única coisa em que /// é razoavelmente boa. : D Ei, o resultado é menor que C, C # ou Java!

A saída deste programa termina em duas quebras de linha à direita; espero que isso não seja um desagrado.

De qualquer forma, não há nenhuma inteligência real aqui. Eu simplesmente identifiquei seqüências repetidas e defini atalhos de um caractere para elas, e repeti até não ver mais seqüências repetidas. Fiz isso de uma maneira mais ou menos ingênua e gananciosa. No entanto, defini intencionalmente um atalho para "sorria na pulga no ... mar", seguido de "pulga na mosca no ... mar" e assim por diante, para formar uma cadeia de atalhos . O resultado é que toda a sequência de novos substantivos é claramente visível no código, e acho isso bastante agradável. :)

Após a substituição de V e U, temos o seguinte código mais legível:

/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
fonte
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 em um PDF agradável, com recuos de parágrafos e tudo mais.

Ungolfed e comentou:

\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 saída:

insira a descrição da imagem aqui

sheß
fonte
2

C # (compilador interativo do 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);

Experimente online!

-5 bytes graças a @ASCIIOnly e -2 bytes graças a @someone!

Eu tenho um filho pequeno e posso garantir que essa música é igual em partes cativantes e irritantes.

dana
fonte
1
Lamento ter lembrado que existe: o)
Sok
.Any()-> !=""?
somente ASCII em
também 223
somente ASCII em
e você não precisa do espaço depois inem foreach> _>
somente ASCII em
@ASCIIOnly - Obrigado pelas dicas :)
dana