"Baby Shark" es una canción infantil sobre una familia de tiburones. Habiendo sido popular durante mucho tiempo como una canción de fogata, se ha popularizado desde mediados de la década de 2000 en las redes sociales, los videos en línea y la radio. - Wikipedia

Escriba un programa que no tome entrada y escriba el siguiente texto en la salida estándar o en un archivo arbitrario:

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 es el código de golf: el código más corto gana.

Encontré esto en Reddit ^ 1 ^ 2 , y parece un desafío interesante para el golf.

Actualizaciones:

No hay nueva línea entre estrofas, eso lo hace demasiado fácil :)

Las nuevas líneas iniciales / finales están bien.

SOGL , 40 bytes

o⅝ηvΒvPΝ┘÷ΖnΨ‘θ{"nOe;‘+ū:" doo”6*+TTPPļ!

Pruébalo aquí!

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🔤!🔤🍪❗️🍉🍉

Ejecutarlo

Ampliado:

🏁🍇
  🔤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 (según el documento de Emojicode ):

🍇🍉

Lo mismo que una {y }(por ejemplo, un bloque de código)

🏁

El "inicio del programa" (p int main(). Ej. )

🔤Baby🔤 ➡️ b

Asignación variable (p const char* b = "Baby";. Ej. )

🍨b y o g a🍆➡️f

Dice, cree una lista de valores entre 🍨 y 🍆 y asigne (➡️) a f(por ejemplo const char* f[] = {b,y,o,g,a};)

🔂m f🍇 ... 🍉

Esta línea dice que se repitan los elementos al fusar el alias m, donde ...es el código entre 🍇 y 🍉.

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

Esta línea dice que se repita en el rango [0,3), donde ...es el código entre 🍇 y 🍉.

😀🍪 ... 🍪️❗️

Esta línea dice que imprima el formato especificado en ...(p printf("%s\n");. Ej. )

El código traducido a 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;
}

Después de esto, el código original (publicado a continuación para la posteridad) tuvo algunos problemas; principalmente que el bloque 🏁🍇🍉 no se incluyó para aquellos que desean ejecutarlo, y los emoji no se escaparon correctamente, para eso, aquí está la versión real de ese código:

Original modificado para ejecutar: Emojicode, 224 bytes (67 caracteres)

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

Ampliado:

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

Que produce la salida:

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

Ejecutarlo

¿Dónde tienes los emoji individuales que representan las palabras?

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

Original: Emojicode, 138 bytes (47 caracteres)

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

Ampliado:

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

IBM PC DOS, ensamblaje 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,'$'

Salida

Descargar SHARK.COM!

• -5 bytes gracias a @Deadcode

Python 2 , 93 bytes

for w in"Baby Daddy Mommy Grandpa Grandma".split():w+=" Shark";print(w+" doo"*6+"\n")*3+w+"!"

Pruébalo en línea!

94 bytes

for w in"Baby Daddy Mommy Grandpa Grandma".split():print((" doo"*6+"\n%s Shark"%w)*4)[25:]+"!"

Pruébalo en línea!

05AB1E , 50 41 bytes

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

La última parte v4FN3Qiy'!«ë…doo6иyšðý},definitivamente se puede jugar un poco al golf ... Y tenía razón, -9 bytes gracias a @Emigna (incluso más de lo que esperaba).

Pruébalo en línea.

Explicación:

“‡ÍÊТ×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)

Vea esta sugerencia mía 05AB1E (sección ¿Cómo usar el diccionario? ) Para comprender por qué “‡ÍÊТ×myîºpaîºma“es "baby daddy mommy grandpa grandma"y 'ã¢es "shark".

PowerShell, 88 86 85 80 79 76 bytes

-5 bytes gracias a @mazzy
-1 byte gracias a @Joey
-3 bytes gracias a @AdmBorkBork

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

Pruébalo en línea!

Ciertamente hemos recorrido un largo camino.

PowerShell (con texto a voz), 156 bytes

Esto NO está a la altura, pero es un poco divertido. ¡Gracias a @rkeet por la idea!

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

La pronunciación de texto a voz .NET es ... bueno ... interesante. Tenga esto en cuenta cuando escuche. ¡Disfrutar!

Java (JDK) , 135 bytes

v->{for(var s:"Baby Daddy Mommy Grandpa Grandma".split(" "))System.out.println(((s+=" Shark")+" doo".repeat(6)+"\n").repeat(3)+s+"!");}

Pruébalo en línea!

Retina 0.8.2 , 77 75 74 bytes

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

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

Baby¶Daddy¶MommyGpaGma
G
¶Grand

Insertar las relaciones en líneas separadas.

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

Expande en cuatro líneas.

s
S6$*O¶
O
 doo
S
 Shark

Expande los marcadores de posición.

69 68 bytes en Retina 1:

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

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

Baby¶Daddy¶MommyGpaGma
G
¶Grand

Insertar las relaciones en líneas separadas.

.+
$& Shark

Añadir tiburón a cada uno.

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

Expandir en versos enteros.

Python 3, 105 97 96 bytes

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

Pruébalo en línea!

Una solución simple de Python 3. (9 bytes guardados por Jo King y Quintec)

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"

Pruébalo en línea!

• "aaa">>xreplica x3 veces, ya que "aaa"tiene longitud 3.

• s>>" doo"replica " doo"6 veces, como " Shark"tiene longitud 6!

• 2 bytes guardados gracias a @Fox

• 2 bytes guardados gracias a @Laikoni

Perl 6 , 79 78 bytes

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

Pruébalo en línea!

Bastante simple.

Explicación:

 <...>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

JavaScript, 104 bytes

Más golf para seguir.

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

¡Pruébelo en línea!

bash, 78 bytes

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

TIO

73 bytes si se permite el espacio final

echo '
'{Baby,Daddy,Mommy,Grand{p,m}a}\ Shark{" `echo doo{,,}{,}`"{,,},!}

/// , 124 bytes

/*/$!
//)/Grand//(/Baby//'/Mommy//&/Daddy//%/ doo//$/ Shark//#/a")//"/$%%%%%%
/("("("(*&"&"&"&*'"'"'"'*)p#p#p#pa*)m#m#m#ma$!

Pruébalo en línea!

> <> , 158115 bytes

Ahorré muchos bytes gracias a Jo King

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

Pruébalo en línea! También puede pegar el código en fishlanguage.com , donde puede ver una animación de él nadando corriendo.

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

Sin golf

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 gracias a @Nahuel Fouilleul!

• usar en ||lugar deconcat()
• usar en unnest('{foo,bar}'::text[])lugar deregexp_split_to_table('foo,bar')

DB <> violín

Haskell , 97 bytes

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

Pruébalo en línea!

Esta es una optimización de la solución Haskell por estrellas y espirales . El nuevo truco es iterar sobre las filas de cada estrofa con un bucle interno, y unir las líneas usando unlines, ahorrando la necesidad de insertar líneas nuevas explícitamente.

Los sufijos de las cuatro líneas son [a,a,a,"!"], donde ase " doo"replica 6 veces con a=s>>" doo", donde las estrellas y las espirales reutilizan inteligentemente los seis caracteres de largo s=" Shark". Escribir [a,a,a,...]parece un poco tonto, pero no veo un camino más corto.

Una versión lista-mónada tiene la misma longitud pero se ve genial.

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

Pruébalo en línea!

Ruby , 82 bytes

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

Pruébalo en línea!

R , 131 122 120 bytes

-9 bytes gracias a Giuseppe

-2 bytes más, también Giuseppe

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

Pruébalo en línea!

Muy orgulloso de esto en realidad, especialmente porque R es bastante pobre en el manejo de cadenas. Comencé a usar cat(sapply(...)), pero me di cuenta de un bucle for afeitado de unos pocos bytes.

Abusar de esto "?"=credujo significativamente la cantidad de paréntesis necesarios.

También intenté "*"=reprepetir las líneas individuales de las estrofas y los "doos", pero eso no eliminó ningún byte.

111 bytes

La solución alternativa (y mejor) de Giuseppe y ASCII-only que soluciona algunos problemas de espacio.

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

Pruébalo en línea!

PHP, 104 bytes

foreach([Baby,Daddy,Mommy,Grandpa,Grandma]as$s)echo$t=$s.str_pad($u=" Shark",30," doo"),"
$t
$t
$s$u!
";

Ejecutar php -nr '<code>'o probarlo en línea .

C # (compilador interactivo de Visual C #) , 153 131 bytes

foreach(var i in"Baby Daddy Mommy Grandpa Grandma".Split()){var a=i+" Shark doo doo doo doo doo doo\n";Write(a+a+a+i+" Shark!\n");}

¡Gracias a @Destrogio por guardar 30 bytes!

Pruébalo en línea!

R , 126125 bytes

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

Esto no se siente tan 'inteligente' como las respuestas de CT Hall o Sumner18 , pero al evitar la sobrecarga de definir variables resulta más pequeña.

Pruébalo en línea!

Editar: guardado 1 byte mediante el retorno de carro según el comentario de Jonathan Frech

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='
')

Probablemente haya una mejor manera de hacer el 'doo' pero no pude conseguirlo.

Editar:
Reemplazado '\ n' con una nueva línea real a sugerencia de JDL;
Se eliminó la nueva línea final a sugerencia de Giuseppe.

Pruébalo en línea

cuando accidentalmente se cierran 100 establecimientos de proveedores - 123,065 121,716 113,695 100,889 98,554 bytes

El programa

Jugaré golf más tarde. Hecho.

Voy a jugar al golf más (más tarde) Listo.

Golfé esto aún más tarde. HECHO.

Obtendré el recuento de bytes hasta 5 dígitos más tarde. HURRA.

Obtendré el recuento de bytes a 4 dígitos (no sé si esto es posible, pero sí sé que es imposible obtener 3 dígitos con mi enfoque actual).

C (gcc) , 123122 bytes

-1 byte gracias a 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:"!");}

Pruébalo en línea!

cQuents , 93 89 bytes

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

Pruébalo en línea!

Tenga en cuenta que a partir de la publicación de TIO no se actualiza a la última versión, por lo que el enlace TIO puede no funcionar.

Explicación

|                               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

JavaScript (Node.js) , 132 bytes

Probablemente muy apto para el golf. Genera la línea "doo doo", luego crea tres de esos con el "!" línea después, y repite esto para cada tiburón.

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)

Pruébalo en línea!

jq, 87 caracteres

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

Ejecución de muestra:

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!

Pruébalo en línea!

TeX simple, 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

Más bien decepcionante, pero no he publicado una respuesta TeX en años. Los bucles son muy detallados en teX (y el bucle sobre las cadenas ni siquiera está incorporado, por lo que incluso esto es un poco exagerado)

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";}

Gracias a @manatwork por guardar 6 bytes al señalar que str_pad('',23'doo ');es más corto quertrim(str_repeat('doo ',6));

Pruébalo en línea!