Sing Baby Shark

68

"Baby Shark" é uma canção infantil sobre uma família de tubarões. Por muito tempo popular como uma canção de fogueira, é popularizada desde meados da década de 2000 pelas mídias sociais, vídeos online e rádio. - Wikipedia

Escreva um programa que não receba entrada e grave o seguinte texto na saída padrão ou em um arquivo arbitrário:

Baby Shark doo doo doo doo doo doo
Baby Shark doo doo doo doo doo doo
Baby Shark doo doo doo doo doo doo
Baby Shark!
Daddy Shark doo doo doo doo doo doo
Daddy Shark doo doo doo doo doo doo
Daddy Shark doo doo doo doo doo doo
Daddy Shark!
Mommy Shark doo doo doo doo doo doo
Mommy Shark doo doo doo doo doo doo
Mommy Shark doo doo doo doo doo doo
Mommy Shark!
Grandpa Shark doo doo doo doo doo doo
Grandpa Shark doo doo doo doo doo doo
Grandpa Shark doo doo doo doo doo doo
Grandpa Shark!
Grandma Shark doo doo doo doo doo doo
Grandma Shark doo doo doo doo doo doo
Grandma Shark doo doo doo doo doo doo
Grandma Shark!

Este é o código golf - o código mais curto vence.

Encontrei isso no Reddit ^ 1 ^ 2 e parece um desafio interessante para o golfe.

Atualizações:

Nenhuma nova linha entre estrofes, isso facilita demais :)

As novas linhas iniciais / finais estão corretas.

code-golf  string  kolmogorov-complexity 
— njha
fonte
6
Uma nova linha entre cada estrofe (cada tubarão) é aceitável? (É sempre assim que eu vi as letras escritas)
— Quintec
6
Faltando alguns versos, como todos os nadadores nadando e perdendo membros em ataques de tubarão.
— mbomb007 16/02
2
"doo doo doo doo doo doo" é realmente simplificado demais.
— R ..
26
Como mãe, sinto o desejo mais forte de rebater esta. Estou reprimindo o desejo, porque não é assim que o Stack Exchange funciona. Mas se eu me encontrar cantarolando "doo doo doo doo" hoje mais tarde, voltarei aqui e responsabilizarei você!
— Cort Ammon
5
Quantas pessoas arruinaram agora que isso acontece nos HNQs?
— CactusCake

Respostas:

74

Emojicode, 292 bytes (140 caracteres)

🏁🍇🔤Baby🔤➡️b🔤Daddy🔤➡️y🔤Mommy🔤➡️o🔤Grandpa🔤➡️g🔤Grandma🔤➡️a🔤 Shark🔤➡️s🔤 doo🔤➡️d🍨b y o g a🍆➡️f🔂m f🍇🔂i🆕⏩⏩0 3❗️🍇😀🍪m s d d d d d d🍪️❗️🍉😀🍪m s🔤!🔤🍪❗️🍉🍉

Executá-lo

Expandido para fora:

🏁🍇
  🔤Baby🔤 ➡️ b
  🔤Daddy🔤 ➡️ y
  🔤Mommy🔤 ➡️ o
  🔤Grandpa🔤 ➡️ g
  🔤Grandma🔤 ➡️ a
  🔤 Shark🔤 ➡️ s
  🔤 doo🔤 ➡️ d
  🍨b y o g a🍆➡️f
  🔂m f🍇
    🔂i🆕⏩⏩0 3❗️🍇
      😀🍪m s d d d d d d🍪️❗️
    🍉
    😀🍪m s🔤!🔤🍪❗️
  🍉
🍉

Explicado (de acordo com o documento Emojicode ):

🍇🍉

O mesmo como um {eo }(por exemplo, um bloco de código)

🏁

O "início do programa" (por exemplo int main())

🔤Baby🔤 ➡️ b

Atribuição variável (por exemplo const char* b = "Baby";)

🍨b y o g a🍆➡️f

Diz, crie uma lista de valores entre 🍨 e 🍆 e atribua (➡️) a f(por exemplo const char* f[] = {b,y,o,g,a};)

🔂m f🍇 ... 🍉

Esta linha diz para fazer um loop sobre os elementos fusando o alias m, onde ...é o código entre 🍇 e 🍉.

🔂 i 🆕⏩⏩ 0 3❗️🍇 ... 🍉

Esta linha diz que o loop está acima do intervalo [0,3), onde ...é o código entre 🍇 e 🍉.

😀🍪 ... 🍪️❗️

Esta linha diz para imprimir o formato especificado em ...(por exemplo printf("%s\n");)

O código traduzido para C:

#include <stdio.h>

int main() {
  const char* b = "Baby";
  const char* y = "Daddy";
  const char* o = "Mommy";
  const char* g = "Grandpa";
  const char* a = "Grandma";
  const char* s = " Shark";
  const char* d = " doo";
  const char* f[] = {b,y,o,g,a};
  int m = 0, i = 0;
  for (; m < 5; ++m) {
    for (i = 0; i < 3; ++i) {
      printf("%s%s%s%s%s%s%s%s\n", f[m], s, d, d, d, d, d, d);
    }
    printf("%s%s!\n", f[m], s);
  }
  return 0;
}

Depois disso, o código original (publicado abaixo para a posteridade) teve alguns problemas; principalmente que o bloco was não foi incluído para aqueles que desejam executá-lo, e os emoji não foram realmente escapados adequadamente; para isso, aqui está a versão atual em execução desse código:

Original modificado para execução: Emojicode, 224 bytes (67 caracteres)

🏁🍇🍨🔤👶🔤🔤👨🔤🔤🤱🔤🔤👴🔤🔤👵🔤🍆➡️f🔂m f🍇🔂i🆕⏩⏩0 3❗️🍇😀🍪m🔤🦈💩💩💩💩💩💩🔤🍪️❗️🍉😀🍪m🔤🦈!🔤🍪❗️🍉🍉

Expandido para fora:

🏁🍇
  🍨
    🔤👶🔤
    🔤👨🔤
    🔤🤱🔤
    🔤👴🔤
    🔤👵🔤
  🍆 ➡️ f
  🔂 m f 🍇
    🔂 i 🆕⏩⏩ 0 3❗️🍇
      😀🍪m🔤🦈💩💩💩💩💩💩🔤🍪️❗️
    🍉
    😀🍪m🔤🦈!🔤🍪❗️
  🍉
🍉

Qual produz a saída:

👶🦈💩💩💩💩💩💩
👶🦈💩💩💩💩💩💩
👶🦈💩💩💩💩💩💩
👶🦈!
👨🦈💩💩💩💩💩💩
👨🦈💩💩💩💩💩💩
👨🦈💩💩💩💩💩💩
👨🦈!
🤱🦈💩💩💩💩💩💩
🤱🦈💩💩💩💩💩💩
🤱🦈💩💩💩💩💩💩
🤱🦈!
👴🦈💩💩💩💩💩💩
👴🦈💩💩💩💩💩💩
👴🦈💩💩💩💩💩💩
👴🦈!
👵🦈💩💩💩💩💩💩
👵🦈💩💩💩💩💩💩
👵🦈💩💩💩💩💩💩
👵🦈!

Executá-lo

Onde você tem os emoji individuais que representam as palavras:

👶 -> Baby
👨 -> Daddy
🤱 -> Mommy
👴 -> Grandpa
👵 -> Grandma
🦈 -> Shark
💩 -> doo

Original: Emojicode, 138 bytes (47 caracteres)

🍨👶👨🤱👴👵🍆➡️f🔂m f🍇🔂i🆕⏩⏩0 3❗️🍇😀m🦈💩💩💩💩💩💩❗️🍉😀m🦈!❗️🍉

Expandido para fora:

🍨👶👨🤱👴👵🍆➡️f
🔂m f🍇
  🔂 i 🆕⏩⏩ 0 3❗️🍇
    😀 m 🦈💩💩💩💩💩💩❗️
  🍉
  😀 m 🦈!❗️
🍉
— txtechhelp
fonte
31
Pontos para criatividade, mas isso não produz a saída necessária
— Jo King
15
Bem vindo ao site! Como JoKing estava chegando, exigimos que as respostas façam exatamente o que a pergunta faz aqui. Isso significa que, embora sua interpretação do desafio seja criativa, essa resposta deve ser corrigida para produzir a saída correta ou excluída.
— Assistente de trigo
12
Embora essa resposta seja criativa, ela não segue os requisitos do desafio e, portanto, não é válida - o texto deve ser produzido exatamente como indicado no desafio.
— Mego
8
Modifique esta resposta para produzir a saída correta ou exclua-a.
— mbomb007 18/02
6
Bem vindo ao site! Quando tento executar esse código online , recebo um erro. (Também conta 98 ​​caracteres em vez de 94). Estou esquecendo de algo?
— DJMcMayhem
31

IBM PC DOS, montagem 8088, 115 114 109 108 bytes

bd43 01e8 1600 bd48 01e8 1000 bd4e 01e8 0a00 bd54 01e8 0400 c646 056d b409 b103
8bd5 cd21 ba5c 01cd 21e3 1249 b306 ba63 01cd 214b 75fb ba69 01cd 21eb e3ba 6801
cd21 c342 6162 7924 4461 6464 7924 4d6f 6d6d 7924 4772 616e 6470 6124 2053 6861
726b 2420 646f 6f24 210d 0a24

Desmontado:

    MOV  BP, OFFSET BABY        ; Baby Shark
    CALL VERSE
    MOV  BP, OFFSET DADDY       ; Daddy Shark
    CALL VERSE
    MOV  BP, OFFSET MOMMY       ; Mommy Shark
    CALL VERSE
    MOV  BP, OFFSET GRAND       ; Grandpa/ma Shark
    CALL VERSE
    MOV  BYTE PTR [BP+5], 'm'   ; change 'p' to 'm'                 
                                ; fall through for last VERSE                               

; display a shark verse
; input: BP: address of shark name string
; output: display full verse for shark
VERSE   PROC
        MOV  AH, 9              ; DOS API display string function
        MOV  CL, 3              ; loop verse three times
LOOP_VERSE:
        MOV  DX, BP             ; load shark name from BP
        INT  21H                ; display shark name
        MOV  DX, OFFSET SHARK   ; load 'Shark'
        INT  21H                ; display 'Shark'
        JCXZ LAST_VERSE         ; if last verse, skip to !
        DEC  CX                 ; decrement verse count
        MOV  BL, 6              ; loop 'doo' 6 times
        MOV  DX, OFFSET DOO     ; load 'doo' string
LOOP_DOO:
        INT  21H                ; display 'doo'
        DEC  BX                 ; decrement doo count
        JNZ  LOOP_DOO           ; if not zero, start again
        MOV  DX, OFFSET CRLF    ; load CRLF string
        INT  21H                ; display CRLF
        JMP  LOOP_VERSE
LAST_VERSE:
        MOV  DX, OFFSET BANG    ; display !, CRLF
        INT  21H
        RET
VERSE   ENDP

BABY    DB  'Baby$'
DADDY   DB  'Daddy$'
MOMMY   DB  'Mommy$'
GRAND   DB  'Grand'
PA      DB  'pa$'
SHARK   DB  ' Shark$'
DOO     DB  ' doo$'
BANG    DB  '!'
CRLF    DB  0DH,0AH,'$'

Resultado

DOS DIR, TUBARÃO

Faça o download do SHARK.COM!

  • -5 bytes graças a @Deadcode
— 640KB
fonte
6
Você absolutamente louco.
— MGOwen 20/02
5
Quando você disse Download SHARK.COM!, pensei imediatamente em vírus de computador.
— MilkyWay90
@gwaugh eu estava brincando
— MilkyWay90
@gwaugh Mas são 109 bytes
— MilkyWay90
16

05AB1E , 50 41 bytes

“‡ÍÊТ×myîºpaîºma“#ð«'㢫™v…doo6иyšÐy'!«»

A última parte v4FN3Qiy'!«ë…doo6иyšðý},pode definitivamente ser um pouco jogada de golfe . E eu estava certo, -9 bytes graças a @Emigna (ainda mais do que eu esperava).

Experimente online.

Explicação:

“‡ÍÊТ×myîºpaîºma“ # Push dictionary string "baby daddy mommy grandpa grandma"
 #                 # Split by spaces: ["baby","daddy","mommy","grandpa","grandma"]
  ð«               # Append a space to each
    '㢫          '# Append dictionary string "shark" to each
        ™          # Title-case each word
v                  # Loop `y` over these strings
 …doo              #  Push string "doo"
     6и            #  Repeat it 6 times as list
       yš          #  Prepend the string `y` at the front of the list
         Ð         #  Triplicate this list
 y'!«             '#  Push string `y`, concatted with a "!"
 »                 #  Join everything on the stack by newlines
                   #  (and each list implicitly by spaces)
                   # (and after the loop, output the result implicitly)

Veja esta dica 05AB1E (seção Como usar o dicionário? ) Para entender por que “‡ÍÊТ×myîºpaîºma“é "baby daddy mommy grandpa grandma"e 'ã¢é "shark".

— Kevin Cruijssen
fonte
2
Você pode jogar 9 bytes desse último bit comv…doo6иyšÐy'!«»
— Emigna 16/02
@ Emigna Você ainda jogou mais do que eu esperava, obrigado! Maneira inteligente de usar o triplicado e »!
— Kevin Cruijssen 16/02
14

PowerShell, 88 86 85 80 79 76 bytes

-5 bytes graças a @mazzy
-1 byte graças a @Joey
-3 bytes graças a @AdmBorkBork

echo Baby Daddy Mommy Grandpa Grandma|%{,(($a="$_ Shark")+" doo"*6)*3;"$a!"}

Experimente online!

Certamente percorremos um longo caminho.

PowerShell (com conversão de texto em fala), 156 bytes

Isso NÃO está dentro das especificações, mas é meio engraçado. Obrigado a @rkeet pela ideia!

Add-Type -a System.Speech;echo Baby Daddy Mommy Grandpa Grandma|%{(New-Object Speech.Synthesis.SpeechSynthesizer).Speak((($a="$_ Shark")+" doo"*6)*3+" $a")}

.NET A pronúncia de texto para fala é ... bem ... interessante. Lembre-se disso ao ouvir. Desfrutar!

— Gabriel Mills
fonte
2
— mazzy 16/02
11
Você pode salvar outro byte atribuindo "$_ Shark"a uma variável e reutilizando-a.
— Joey
2
76 bytes usando em echovez de -split.
— AdmBorkBork 19/02
11
Eu acho que você deveria ter um "texto em fala" também: p Porra, tentei combiná-lo um pouco com esse código , não funcionou muito :-)
— rkeet
Desafio @rkeet aceito! Atualmente, estou intrigando isso.
— Gabriel Mills
9

Retina 0.8.2 , 77 75 74 bytes


Baby¶Daddy¶MommyGpaGma
G
¶Grand
.+
$&s$&s$&s$&S!
s
S6$*O¶
O
 doo
S
 Shark

Experimente online! Explicação:


Baby¶Daddy¶MommyGpaGma
G
¶Grand

Inserir as relações em linhas separadas.

.+
$&s$&s$&s$&S!¶

Expanda em quatro linhas.

s
S6$*O¶
O
 doo
S
 Shark

Expanda os espaços reservados.

69 68 bytes na Retina 1:


Baby¶Daddy¶MommyGpaGma
G
¶Grand
.+
$& Shark
.+
3*$($&6*$( doo)¶)$&!

Experimente online! Explicação:


Baby¶Daddy¶MommyGpaGma
G
¶Grand

Inserir as relações em linhas separadas.

.+
$& Shark

Acrescente Shark a cada um.

.+
3*$($&6*$( doo)¶)$&!

Expanda em versos inteiros.

— Neil
fonte
9

Python 3, 105 97 96 bytes

for x in"Baby","Daddy","Mommy","Grandpa","Grandma":z=x+' Shark';print((z+' doo'*6+"\n")*3+z+"!")

Experimente online!

Uma solução simples do Python 3. (9 bytes salvos por Jo King e Quintec)

— njha
fonte
2
Os parênteses ' doo'*6são desnecessários e você tem espaços em branco desnecessários
— Quintec 16/02
11
O que QUINTEC disse ... 97 bytes
— Jo rei
2
@ReverseCold tecnicamente onde não há []uma tupla, não uma lista, mas isso não é relevante para este programa
— Stephen
2
96 bytes , definindo x+' Shark'uma variável
— Jo King
11
Isso parece funcionar em 2.7 também?
— uhoh 19/02
9

Haskell , 122 113 108 106 104 bytes

s=" Shark";m=do x<-words"Baby Daddy Mommy Grandpa Grandma";("aaa">>x++s++(s>>" doo")++"\n")++x++s++"!\n"

Experimente online!

  • "aaa">>xreplica x3 vezes, assim como o "aaa"comprimento 3.

  • s>>" doo"replica " doo"6 vezes, assim como o " Shark"comprimento 6!

  • 2 bytes salvos graças ao @Fox

  • 2 bytes salvos graças a @Laikoni
— starsandspirals
fonte
2
Bem vindo ao site! Permitimos apenas gerar uma string de saída fixa como uma expressão , para que você possa omitir o main=putStr. Veja também o resumo das regras de Haskell .
— xnor 16/02
11
Bem-vindo ao PPCG. Boa economia com s>>.
— Shaggy
@xnor obrigado pelos links!
— starsandspirals
11
m=(stuff)pode ser apenas m=stuffpara dois bytes a menos
— Fox
11
104 bytes usando do-notation: Experimente online!
— Laikoni 18/02
7

Perl 6 , 79 78 bytes

(<Baby Daddy Mommmy Grandpa Grandma>X~" Shark"X~ |((" doo"x 6)xx 3),'!')>>.say

Experimente online!

Bem simples.

Explicação:

 <...>X~                                  # Combine family members
        " Shark"X~                        # With "Shark" and
                   |((" doo"x 6)xx 3)     # doo repeated 6 times then 3 times
                                     ,'!' # Then !
(                                        )>>.say  # And print each line
— Brincadeira
fonte
7

JavaScript, 104 bytes

Mais golfe a seguir.

_=>`Baby
Daddy
Mommy
Grandpa
Grandma`.replace(/.+/g,x=>(s=(x+=` Shark`)+` doo`.repeat(6)+`
`)+s+s+x+`!`)

Experimente Online!

— Shaggy
fonte
11
Tecnicamente, essa não é uma solução válida, pois não grava ou registra em um arquivo. Embora se você a tornar uma solução válida, encapsulando com a console.log(), não poderá ser uma declaração lambda (apenas ganho de 10 caracteres)
— Delioth
3
@ Delioth, retornar de uma função é perfeitamente válido neste site. Veja no Meta nossas regras de E / S padrão.
— Shaggy
2
Eu geralmente concordo, mas esta pergunta afirma especificamente que o programa "grava o texto a seguir na saída padrão ou em um arquivo arbitrário"
— Delioth
7

bash, 78 bytes

printf %s\\n {Baby,Daddy,Mommy,Grand{p,m}a}\ Shark{" `echo doo{,,}{,}`"{,,},!}

TIO

73 bytes se o espaço à direita for permitido

echo '
'{Baby,Daddy,Mommy,Grand{p,m}a}\ Shark{" `echo doo{,,}{,}`"{,,},!}
— Nahuel Fouilleul
fonte
5

> <> , 158 115 bytes

Economizou muitos bytes graças a Jo King

>4>1-&0'krahS '0l3-.
~ ^oa~<
ooo:?!/1-'ood 'o
\ao'!'^?$6:&~
\!?:o
^'ybaB'
^'yddaD'
^'ymmoM'
^'apdnarG'
^'amdnarG'
;

Experimente online! Você também pode colar o código em fishlanguage.com , onde pode ver uma animação dele nadando em execução.

— DLosc
fonte
121 bytes , principalmente através da reorganização do bebê / papai / ... em várias linhas, em vez de uma linha. Porém, há mais para jogar golfe
— Jo King
— Jo King
@JoKing Ah, obrigado. Eu suponho (principalmente por trabalhar com o BitCycle) que menos linhas são melhores, mas nesse caso isso não é verdade devido aos diferentes comprimentos de string.
— DLosc 16/02
5

PostgreSQL, 162 156 138 bytes

select a||' Shark'||replace(b,'1',repeat(' doo',6))from unnest('{Baby,Daddy,Mommy,Grandpa,Grandma}'::text[])a,unnest('{1,1,1,!}'::text[])b

Ungolfed

select 
    a || ' Shark' || replace(b,'1',repeat(' doo',6))
from unnest('{Baby,Daddy,Mommy,Grandpa,Grandma}'::text[]) a
    ,unnest('{1,1,1,!}'::text[]) b

Guardado 6 24 bytes graças a @Nahuel Fouilleul!

  • use em ||vez deconcat()
  • use em unnest('{foo,bar}'::text[])vez deregexp_split_to_table('foo,bar')

DB <> violino

— Peter Vandivier
fonte
11
-6 bytes usando em ||vez de concat Visualizar no DB Fiddle
— Nahuel Fouilleul 18/02
11
select a||' Shark'||replace(b,'1',repeat(' doo',6))from unnest('{Baby,Daddy,Mommy,Grandpa,Grandma}'::text[])a,unnest('{1,1,1,!}'::text[])b
— Nahuel Fouilleul 18/02
5

Haskell , 97 bytes

unlines[x++s++p|x<-words"Baby Daddy Mommy Grandpa Grandma",p<-[a,a,a,"!"]]
s=" Shark"
a=s>>" doo"

Experimente online!

Esta é uma otimização da solução Haskell por starsandspirals . O novo truque é iterar nas linhas de cada sub-rotina com um loop interno e unir as linhas usando unlines, economizando a necessidade de inserir explicitamente novas linhas.

Os sufixos das quatro linhas são [a,a,a,"!"], onde aé " doo"replicado 6 vezes a=s>>" doo", onde estrelas epirais reutilizam inteligentemente o comprimento de seis caracteres s=" Shark". Escrever [a,a,a,...]parece um pouco bobo, mas não estou vendo uma maneira mais curta.

Uma versão de lista-mônada tem o mesmo comprimento, mas parece legal.

unlines$(++).(++s)<$>words"Baby Daddy Mommy Grandpa Grandma"<*>[a,a,a,"!"]
s=" Shark"
a=s>>" doo"

Experimente online!

— xnor
fonte
4

Ruby , 82 bytes

%w(Baby Daddy Mommy Grandpa Grandma).map{|a|puts [a+" Shark"]*4*(" doo"*6+?\n)+?!}

Experimente online!

— Kirill L.
fonte
Demorei um pouco para entender que você usava a parte "doo" como separadores de matriz. Bom trabalho :)
— Idva 18/02
4

R , 131 122 120 bytes

-9 bytes graças a Giuseppe

-2 mais bytes, também Giuseppe

`?`=c
s="Shark"
for(x in "Baby"?"Daddy"?"Mommy"?"Grandpa"?"Grandma")cat(rep("
"?x?s?rep("doo",6),3)?"
"?x?paste0(s,"!"))

Experimente online!

Bastante orgulhoso disso, na verdade, especialmente com R sendo bastante pobre em lidar com strings. Comecei a usar cat(sapply(...)), mas percebi que um loop for raspa alguns bytes.

Abusar com isso "?"=creduziu significativamente a quantidade de parênteses necessários.

Também tentei "*"=reprepetir as linhas individuais das estrofes e dos "doos", mas isso não eliminou nenhum bytes.

111 bytes

Giuseppe e a solução alternativa (e melhor) apenas do ASCII que corrige alguns problemas de espaçamento.

write(paste0(rep(c("Baby","Daddy","Mommy","Grandpa","Grandma"),,,4)," Shark",c(rep(strrep(" doo",6),3),"!")),1)

Experimente online!

— Sumner18
fonte
11
— Giuseppe
Como sempre, obrigado pela sua contribuição sensata @ Giuseppe. Eu deveria ter notado essas golfs
— Sumner18
11
— Giuseppe
11
@ Giuseppe uau, vetorização, bom. Esqueci que o R tem uma vetorização legal como essa. 114? também 114?
— somente ASCII
11
— somente ASCII
3

R , 126 125 bytes

cat(paste(rep(c("Baby","Daddy","Mommy","Grandpa","Grandma"),,,4),c(rep("Shark doo doo doo doo doo doo",3),"Shark!")),sep="
")

Isso não parece tão 'inteligente' quanto as respostas de CT Hall ou Sumner18 , mas, ao evitar a sobrecarga de definir variáveis, ele fica menor.

Experimente online!

Edit: Salvo 1 byte usando retorno de carro, conforme comentário de Jonathan Frech

— BobbyBean
fonte
Olá e bem-vindo ao PPCG! Eu adicionei links para as respostas do usuário que você mencionou para comparar melhor suas soluções. Parabéns por superar os dois, você poderia adicionar um link a um ambiente de teste on-line para facilitar a verificação?
— Jonathan Frech 19/02
Obrigado pela edição @JonathanFrech. Agora adicionei um link para testar o código online (que adicionou um byte à minha resposta!).
— BobbyBean
Você pode usar uma nova linha real em vez de \ndiminuir novamente a contagem de bytes.
— Jonathan Frech 19/02
— Giuseppe
11
Bem, eu fui totalmente derrotado; Às vezes, a opção mais simples é a melhor. Também destaca como é difícil trabalhar com seqüências de caracteres em R.
— CT Hall
3

R , 139 138 137 bytes

s='Shark';d='doo';cat(paste(rep(c('Baby','Daddy','Mommy','Grandpa','Grandma'),e=4),c(rep(paste(s,d,d,d,d,d,d),3),paste0(s,'!'))),sep='
')

Provavelmente existe uma maneira melhor de fazer o 'doo's, mas não consegui.

Edit:
Substituído '\ n' pela nova linha real por sugestão da JDL;
Removida a nova linha à direita por sugestão de Giuseppe.

Experimente online

— CT Hall
fonte
bem-vindo ao ppcg! No mínimo, a substituição do "\ n" por uma nova linha literal economizará um byte.
— JDL 19/02
Obrigado, eu fiz isso e, em seguida, percebi que minha saída estava um pouco baixa, então eu atualizei isso, infelizmente resultou em mais bytes.
— CT Hall
Eu acredito que você tem uma nova linha à direita para um byte extra
— Giuseppe
3

quando você perder acidentalmente100 estados de fomento - 123.065 121.716 113.695 100.889 98.554 bytes

O programa

Vou jogar isso depois. Feito.

Vou jogar mais isso (mais tarde) .

Vou jogar isso ainda mais tarde. FEITO.

Vou receber a contagem de bytes até 5 dígitos depois. YAY.

Vou obter a contagem de bytes para 4 dígitos (não sei se isso é possível, mas sei que é impossível obter 3 dígitos com a minha abordagem atual).

— MilkyWay90
fonte
O que diabos é isso? Eu adoro isso
— Adrian Zhang
@AdrianZhang Uma linguagem de programação difícil de programar. Além disso, o programa parece que é uma pessoa gritando ('AAAAAAAAAAAA ...')
— MilkyWay90
3

C (gcc) , 123 122 bytes

-1 byte graças ao ceilingcat

#define A" doo doo"
f(i){for(i=20;i--;)printf("%.7s Shark%s\n","GrandmaGrandpaMommy\0 Daddy\0 Baby"+i/4*7,i%4?A A A:"!");}

Experimente online!

— gastropner
fonte
Quais são as regras para C? Não há necessidade main()ou #includepara printf?
— BoBTFish
@BoBTFish: Não é específico de C, mas geralmente é permitido o uso de qualquer função (o nome não importa, na verdade, pode ser um lambda sem nome ou similar). E os idiomas são definidos por sua (qualquer) implementação, uma vez que isso funciona gcc(apenas gera avisos, mas compila bem) e é válido.
— ბიმო
Percebi que a falta de #includeera apenas um erro, porque eu ainda estava compilando como C ++, mas ainda não consegui compilar sem renomear sua função main.
— BoBTFish
2

cQuents , 93 89 bytes

|
#20&bk)~" Shark"~(" doo"6,Z,Z,bk)~" Shark!"
:"Baby","Daddy","Mommy","Grandpa","Grandma"

Experimente online!

Observe que a partir da publicação do TIO não é atualizada para a versão mais recente, portanto, o link do TIO pode não funcionar.

Explicação

|                               Set delimiter to newline
#20                             n = 20
   &                            Output first n terms in sequence
                                k = 1
                                First term is
    bk)~" Shark"                 kth term from the third line concatenated to " Shark"
                ~(" doo"6,        concatenated to " doo" repeated 6 times
Z,Z,                            Second and third terms equal the first term
    bk)~" Shark!"               Fourth term is the kth term from the third line concatenated to " Shark!"
                                k += 1, restart

Third line                      5 terms, each a string
— Stephen
fonte
2

JavaScript (Node.js) , 132 bytes

Provavelmente muito capaz de jogar golfe. Gera a linha "doo doo" e cria três com o "!" linha depois e repete isso para cada tubarão.

a=""
c=" doo"
for(b of["Baby","Daddy","Mommy","Grandpa","Grandma"]){b+=" Shark"
t=b+c+c+c+c+c+c+"\n"
a+=t+t+t+b+"!\n"}console.log(a)

Experimente online!

— Neil A.
fonte
Uma solução ligeiramente alterada em Javascript, porém sem ganho: a = ""; c = "doo"; for (b de ["Bebê", "Papai", "Mamãe", "Vovô", "Vovó"]) {b + = "Tubarão"; t = b + c.repeat (6) + "\ n"; a + = t + t + t + b + "! \ N"} console.log (a)
— BogdanBiv
2

jq, 87 caracteres

" Shark"as$s|("Baby Daddy Mommy Grandpa Grandma"/" ")[]|(.+$s+" doo"*6+"\n")*3+.+$s+"!"

Exemplo de execução:

bash-4.4$ jq -nr '" Shark"as$s|("Baby Daddy Mommy Grandpa Grandma"/" ")[]|(.+$s+" doo"*6+"\n")*3+.+$s+"!"'
Baby Shark doo doo doo doo doo doo
Baby Shark doo doo doo doo doo doo
Baby Shark doo doo doo doo doo doo
Baby Shark!
Daddy Shark doo doo doo doo doo doo
Daddy Shark doo doo doo doo doo doo
Daddy Shark doo doo doo doo doo doo
Daddy Shark!
Mommy Shark doo doo doo doo doo doo
Mommy Shark doo doo doo doo doo doo
Mommy Shark doo doo doo doo doo doo
Mommy Shark!
Grandpa Shark doo doo doo doo doo doo
Grandpa Shark doo doo doo doo doo doo
Grandpa Shark doo doo doo doo doo doo
Grandpa Shark!
Grandma Shark doo doo doo doo doo doo
Grandma Shark doo doo doo doo doo doo
Grandma Shark doo doo doo doo doo doo
Grandma Shark!

Experimente online!

— homem a trabalhar
fonte
2

TeX liso, 147 bytes

\input pgffor\def\D{doo~}\def\d{\D\D\D\D\D\D}\def\S{Shark}\def\y{\x~\S~\d\par}\foreach\x in{Baby,Mommy,Daddy,Grandma,Grandpa}{\y\y\y\x~\S!\par}\bye

Bastante decepcionante, mas eu não tenho postado uma resposta TeX há anos. Os loops são muito detalhados em teX (e o loop sobre as cordas nem mesmo é incorporado, então isso é um pouco exagerado)

— Chris H
fonte
2

PHP , 153 147 bytes

<?php $s='Shark';$d=str_pad('',23,'doo ');foreach(explode(' ','Baby Daddy Mommy Grandpa Grandma')as$a){echo str_repeat("$a $s $d\n",3),"$a $s!\n";}

Obrigado a @manatwork por salvar 6 bytes, indicando que str_pad('',23'doo ');é menor quertrim(str_repeat('doo ',6));

Experimente online!

— EvanBarbour3
fonte
Infelizmente, até $d='doo doo doo doo doo doo'é mais curto que a combinação rtrim()+ str_repeat(). :( Mas felizmente $d=str_pad('',23,'doo ')é ainda mais curto. Para obter mais dicas de otimização, consulte Dicas para jogar golfe em PHP .
— manatwork
@manatwork Obrigado por apontar isso, atualizei o post para refletir
— EvanBarbour3
11
Enquanto isso, encontrei algum tempo para jogar um pouco mais: Experimente online!
— manatwork 18/02
113 bytes . Bem-vindo ao PPCG!
— Shaggy
2
— Shaggy
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.