Emojicode, 292 bytes (140 characters)

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

Run it

Expanded out:

🏁🍇

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

  🍉

🍉

Explained (per the Emojicode doc):

🍇🍉

The same as a { and } (e.g. a code block)

🏁

The "program start" (e.g. int main())

🔤Baby🔤 ➡️ b

Variable assignment (e.g. const char* b = "Baby";)

🍨b y o g a🍆➡️f

Says, create a list of values between 🍨 and 🍆 and assign (➡️) to f (e.g. const char* f = {b,y,o,g,a};)

🔂m f🍇 ... 🍉

This line says to loop over the elements in f using the alias m, where the ... is the code between 🍇 and 🍉.

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

This line says to loop over the range [0,3), where the ... is the code between 🍇 and 🍉.

😀🍪 ... 🍪️❗️

This line says to print the format specified in ... (e.g. printf("%sn");)

The code translated to 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%sn", f[m], s, d, d, d, d, d, d);

    }

    printf("%s%s!n", f[m], s);

  }

  return 0;

}

Following this, the original code (posted below for posterity) had some issues; mostly that the 🏁🍇🍉 block was not included for those who wish to run it, and the emoji's were not actually properly escaped, to that, here is the actual running version of that code:

Original modified to run: Emojicode, 224 bytes (67 characters)

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

Expanded out:

🏁🍇

  🍨

    🔤👶🔤

    🔤👨🔤

    🔤🤱🔤

    🔤👴🔤

    🔤👵🔤

  🍆 ➡️ f

  🔂 m f 🍇

    🔂 i 🆕⏩⏩ 0 3❗️🍇

      😀🍪m🔤🦈💩💩💩💩💩💩🔤🍪️❗️

    🍉

    😀🍪m🔤🦈!🔤🍪❗️

  🍉

🍉

Which produces the output:

👶🦈💩💩💩💩💩💩

👶🦈💩💩💩💩💩💩

👶🦈💩💩💩💩💩💩

👶🦈!

👨🦈💩💩💩💩💩💩

👨🦈💩💩💩💩💩💩

👨🦈💩💩💩💩💩💩

👨🦈!

🤱🦈💩💩💩💩💩💩

🤱🦈💩💩💩💩💩💩

🤱🦈💩💩💩💩💩💩

🤱🦈!

👴🦈💩💩💩💩💩💩

👴🦈💩💩💩💩💩💩

👴🦈💩💩💩💩💩💩

👴🦈!

👵🦈💩💩💩💩💩💩

👵🦈💩💩💩💩💩💩

👵🦈💩💩💩💩💩💩

👵🦈!

Run it

Where in you have the individual emoji's representing the words:

👶 -> Baby

👨 -> Daddy

🤱 -> Mommy

👴 -> Grandpa

👵 -> Grandma

🦈 -> Shark

💩 -> doo

Original: Emojicode, 138 bytes (47 characters)

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

Expanded out:

🍨👶👨🤱👴👵🍆➡️f

🔂m f🍇

  🔂 i 🆕⏩⏩ 0 3❗️🍇

    😀 m 🦈💩💩💩💩💩💩❗️

  🍉

  😀 m 🦈!❗️

🍉

IBM PC DOS, 8088 assembly, 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

Unassembled:

    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,'$'

Output

Download SHARK.COM!

• -5 bytes thanks to @Deadcode

Python 2, 93 bytes

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

Try it online!

94 bytes

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

Try it online!

05AB1E, 50 41 bytes

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

Last part v4FN3Qiy'!«ë…doo6иyšðý}, can definitely be golfed a bit.. And I was right, -9 bytes thanks to @Emigna (even more than I was expecting).

Try it online.

Explanation:

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

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why “‡ÍÊТ×myîºpaîºma“ is "baby daddy mommy grandpa grandma" and 'ã¢ is "shark".

PowerShell, 88 86 85 80 79 76 bytes

-5 bytes thanks to @mazzy

-1 byte thanks to @Joey

-3 bytes thanks to @AdmBorkBork

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

Try it online!

We've certainly come a long way.

PowerShell (with Text to Speech), 156 bytes

This is NOT up to spec, but it's kinda funny. Thanks to @rkeet for the idea!

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

.NET Text to speech pronunciation is... well... interesting. Keep this in mind when listening. Enjoy!

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+"!");}

Try it online!

Retina 0.8.2, 77 75 74 bytes

Baby¶Daddy¶MommyGpaGma

G

¶Grand

.+

$&s$&s$&s$&S!

s

S6$*O¶

O

 doo

S

 Shark

Try it online! Explanation:

Baby¶Daddy¶MommyGpaGma

G

¶Grand

Insert the relations on separate lines.

.+

$&s$&s$&s$&S!¶

Expand into four lines.

s

S6$*O¶

O

 doo

S

 Shark

Expand the placeholders.

69 68 bytes in Retina 1:

Baby¶Daddy¶MommyGpaGma

G

¶Grand

.+

$& Shark

.+

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

Try it online! Explanation:

Baby¶Daddy¶MommyGpaGma

G

¶Grand

Insert the relations on separate lines.

.+

$& Shark

Append Shark to each.

.+

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

Expand into whole verses.

Python 3, 105 97 96 bytes

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

Try it online!

A simple Python 3 solution. (9 bytes saved by Jo King and 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"

Try it online!

• "aaa">>x replicates x 3 times, as "aaa" has length 3.




• s>>" doo" replicates " doo" 6 times, as " Shark" has length 6!




• 2 bytes saved thanks to @Fox



• 2 bytes saved thanks to @Laikoni

Perl 6, 79 78 bytes

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

Try it online!

Pretty simple.

Explanation:

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

More golfing to follow.

_=>`Baby

Daddy

Mommy

Grandpa

Grandma`.replace(/.+/g,x=>(s=(x+=` Shark`)+` doo`.repeat(6)+`

`)+s+s+x+`!`)

Try It Online!

bash, 78 bytes

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

TIO

73 bytes if trailing space is allowed

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$!

Try it online!

><>, 158 115 bytes

Saved a lot of bytes thanks to Jo King

>4>1-&0'krahS '0l3-.

~ ^oa~<

ooo:?!/1-'ood 'o

ao'!'^?$6:&~

!?:o

^'ybaB'

^'yddaD'

^'ymmoM'

^'apdnarG'

^'amdnarG'

;

Try it online! You may also want to paste the code in at fishlanguage.com, where you can see an animation of it swimming running.

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

Saved 6 24 bytes thanks to @Nahuel Fouilleul!

• use || instead of concat()


• use unnest('{foo,bar}'::text) instead of regexp_split_to_table('foo,bar')
  

DB<>fiddle

Haskell, 97 bytes

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

s=" Shark"

a=s>>" doo"

Try it online!

This is an optimization of the Haskell solution by starsandspirals. The new trick is to iterate over the rows of each stanza with an inner loop, and join the lines using unlines, saving the need to explicitly insert newlines.

The suffixes of the four lines are [a,a,a,"!"], where a is " doo" replicated 6 times with a=s>>" doo", where starsandspirals cleverly reuses the six-character-long s=" Shark". Writing [a,a,a,...] looks a bit silly, but I'm not seeing a shorter way.

A list-monad version is the same length but it looks cool.

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

s=" Shark"

a=s>>" doo"

Try it online!

Ruby, 82 bytes

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

Try it online!

C# (Visual C# Interactive Compiler), 153 131 bytes

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

Thanks to @Destrogio for saving 30 bytes!

Try it online!

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="

")

This doesn't feel as 'clever' as either CT Hall or Sumner18's answers, but by avoiding the overhead of defining variables it comes out smaller.

Try it online!

Edit: Saved 1 byte by using carriage return as per comment by 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='

')

There's probably a better way to do the 'doo's but I wasn't able to get it.

Edit:

Replaced 'n' with actual new line at JDL's suggestion;

Removed trailing newline at Giuseppe's suggestion.

Try it online

R, 131 122 120 bytes

-9 bytes thanks to Giuseppe

-2 more bytes, also Giuseppe

`?`=c

s="Shark"

for(x in "Baby"?"Daddy"?"Mommy"?"Grandpa"?"Grandma")cat(rep("

"?x?s?rep("doo",6),3)?"

"?x?paste0(s,"!"))

Try it online!

Quite proud of this actually, especially with R being rather poor at handling strings. I started out using cat(sapply(...)), but realized a for loop shaves off a few bytes.

Abusing the "?"=c significantly reduced the amount of parentheses needed.

I also tried to do "*"=rep to repeat the individual lines of the stanzas and the "doos", but that did not shave off any bytes.

111 bytes

Giuseppe and ASCII-only's alternative, (and better) solution that fixes some spacing issues.

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

Try it online!

cQuents, 93 89 bytes

|

#20&bk)~" Shark"~(" doo"6,Z,Z,bk)~" Shark!"

:"Baby","Daddy","Mommy","Grandpa","Grandma"

Try it online!

Note that as of posting TIO is not updated to the latest version, so the TIO link may not work.

Explanation

|                               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

Probably very golf-able. Generates the "doo doo" line, then creates three of those with the "!" line after, and repeats this for each shark.

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)

Try it online!

PHP, 104 bytes

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

$t

$t

$s$u!

";

Run with php -nr '<code>' or try it online.

Plain TeX, 147 Bytes

input pgffordefD{doo~}defd{DDDDDD}defS{Shark}defy{x~S~dpar}foreachx in{Baby,Mommy,Daddy,Grandma,Grandpa}{yyyx~S!par}bye

Rather disappointing, but I haven't posted a TeX answer in ages. Loops are very verbose in teX (and looping over strings isn't even built-in so even this is a bit of a stretch)

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 $dn",3),"$a $s!n";}

Thanks to @manatwork for saving 6 bytes by pointing out str_pad('',23'doo '); is shorter than rtrim(str_repeat('doo ',6));

Try it online!

C (gcc), 123 122 bytes

-1 byte thanks to ceilingcat

#define A" doo doo"

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

Try it online!