"Baby Shark" ist ein Kinderlied über eine Haifamilie. Es war lange Zeit als Lagerfeuersong beliebt und wurde seit Mitte der 2000er Jahre durch soziale Medien, Online-Videos und Radio populär gemacht. - Wikipedia

Schreiben Sie ein Programm, das keine Eingabe benötigt, und schreiben Sie den folgenden Text in die Standardausgabe oder in eine beliebige Datei:

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!

Dies ist Code Golf - der kürzeste Code gewinnt.

Fand dies auf Reddit ^ 1 ^ 2 , und es scheint eine interessante Herausforderung für Golf.

Aktualisierung:

Keine Zeilenumbrüche zwischen den Strophen, das macht es zu einfach :)

Führende / nachfolgende Zeilenumbrüche sind in Ordnung.

SOGL , 40 Bytes

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

Probieren Sie es hier aus!

Emojicode, 292 Bytes (140 Zeichen)

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

Starte es

Erweitert aus:

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

Erklärt (gemäß dem Emojicode- Dokument):

🍇🍉

Das Gleiche wie ein {und }(zB ein Codeblock)

🏁

Der "Programmstart" (zB int main())

🔤Baby🔤 ➡️ b

Variablenzuordnung (zB const char* b = "Baby";)

🍨b y o g a🍆➡️f

Sagt, erstellen Sie eine Liste von Werten zwischen 🍨 und 🍆 und weisen Sie (➡️) zu f(zB const char* f[] = {b,y,o,g,a};)

🔂m f🍇 ... 🍉

In dieser Zeile wird angegeben, dass die Elemente im fAlias durchlaufen werden sollen m, wobei ...der Code zwischen 🍇 und 🍉 steht.

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

In dieser Zeile wird angegeben, dass die Schleife über den Bereich [0,3] geführt werden soll, wobei ...der Code zwischen 🍇 und 🍉 steht.

😀🍪 ... 🍪️❗️

In dieser Zeile steht, dass das in ...(zB printf("%s\n");) angegebene Format gedruckt werden soll.

Der Code übersetzt in 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;
}

Im Anschluss daran hatte der Originalcode (unten für die Nachwelt veröffentlicht) einige Probleme. meistens, dass der 🏁🍇🍉-Block nicht für diejenigen enthalten war, die ihn ausführen möchten, und die Emojis nicht richtig maskiert wurden, dazu hier die aktuelle Version dieses Codes:

Original für die Ausführung modifiziert: Emojicode, 224 Bytes (67 Zeichen)

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

Erweitert aus:

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

Welches erzeugt die Ausgabe:

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

Starte es

Wo haben Sie die einzelnen Emojis, die die Wörter darstellen:

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

Original: Emojicode, 138 Bytes (47 Zeichen)

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

Erweitert aus:

🍨👶👨🤱👴👵🍆➡️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

Zerlegt:

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

Ausgabe

Laden Sie SHARK.COM herunter!

• -5 Bytes dank @Deadcode

Python 2 , 93 Bytes

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

Probieren Sie es online!

94 Bytes

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

Probieren Sie es online!

05AB1E , 50 41 Bytes

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

Letzter Teil v4FN3Qiy'!«ë…doo6иyšðý},kann definitiv ein bisschen golfen werden. Und ich hatte recht, -9 Bytes dank @Emigna (sogar mehr als ich erwartet hatte).

Probieren Sie es online aus.

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie verwende ich das Wörterbuch? ) An, um zu verstehen, warum es “‡ÍÊТ×myîºpaîºma“ist "baby daddy mommy grandpa grandma"und 'ã¢ist "shark".

PowerShell, 88 86 85 80 79 76 Byte

-5 Bytes dank @mazzy
-1 Bytes dank @Joey
-3 Bytes dank @AdmBorkBork

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

Probieren Sie es online!

Wir haben sicherlich einen langen Weg zurückgelegt.

PowerShell (mit Text in Sprache), 156 Byte

Dies entspricht NICHT der Spezifikation, ist aber irgendwie lustig. Danke an @rkeet für die Idee!

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

Die Aussprache von .NET Text to Speech ist ... nun ja ... interessant. Denken Sie daran, wenn Sie zuhören. Genießen!

Java (JDK) , 135 Byte

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

Probieren Sie es 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

Probieren Sie es online! Erläuterung:

Baby¶Daddy¶MommyGpaGma
G
¶Grand

Fügen Sie die Relationen in separate Zeilen ein.

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

In vier Zeilen erweitern.

s
S6$*O¶
O
 doo
S
 Shark

Erweitern Sie die Platzhalter.

69 68 Bytes in Retina 1:

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

Probieren Sie es online! Erläuterung:

Baby¶Daddy¶MommyGpaGma
G
¶Grand

Fügen Sie die Relationen in separate Zeilen ein.

.+
$& Shark

Füge jedem Shark hinzu.

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

Erweitern Sie in ganze Verse.

Python 3, 105 97 96 Bytes

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

Probieren Sie es online!

Eine einfache Python 3-Lösung. (9 Bytes von Jo King und Quintec gespeichert)

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"

Probieren Sie es online!

• "aaa">>xWird xdreimal repliziert , ebenso "aaa"wie Länge 3.

• s>>" doo"repliziert " doo"6 mal, wie " Shark"Länge 6 hat!

• 2 Bytes gespart dank @Fox

• 2 Bytes gespart dank @Laikoni

Perl 6 , 79 78 Bytes

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

Probieren Sie es online!

Ziemlich einfach.

Erläuterung:

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

Weitere Golfspiele folgen.

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

Probieren Sie es online!

Bash, 78 Bytes

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

TIO

73 Bytes, wenn nachfolgender Speicherplatz zulässig ist

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

Probieren Sie es online!

> <> , 158 115 Bytes

Jo King hat eine Menge Bytes gespart

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

Probieren Sie es online! Sie können den Code auch in fishlanguage.com einfügen , wo Sie eine Animation davon sehen können, wie sie schwimmt .

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

6 24 Bytes gespart dank @Nahuel Fouilleul!

• Verwenden Sie ||anstelle vonconcat()
• Verwenden Sie unnest('{foo,bar}'::text[])anstelle vonregexp_split_to_table('foo,bar')

DB <> Geige

Haskell , 97 Bytes

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

Probieren Sie es online!

Dies ist eine Optimierung der Haskell-Lösung durch Sterne und Spiralen . Der neue Trick besteht darin, die Zeilen jeder Zeilengruppe mit einer inneren Schleife unlineszu durchlaufen und die Zeilen mithilfe von zu verbinden , ohne dass explizit neue Zeilen eingefügt werden müssen.

Die Suffixe der vier Zeilen sind [a,a,a,"!"], in denen asie " doo"repliziert 6mal mit a=s>>" doo", wo starsandspirals geschickt verwendet die sechs Zeichen lang s=" Shark". Das Schreiben [a,a,a,...]sieht ein bisschen albern aus, aber ich sehe keinen kürzeren Weg.

Eine List-Monad-Version hat die gleiche Länge, sieht aber cool aus.

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

Probieren Sie es online!

Ruby , 82 Bytes

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

Probieren Sie es online!

R , 131 122 120 Bytes

-9 Bytes dank Giuseppe

-2 weitere Bytes, auch Giuseppe

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

Probieren Sie es online!

Wirklich sehr stolz darauf, vor allem, wenn R im Umgang mit Saiten ziemlich schlecht ist. Ich begann mit cat(sapply(...)), realisierte aber, dass sich eine for-Schleife um einige Bytes verringert.

Missbrauch der "?"=cdeutlich reduzierten Anzahl der benötigten Klammern.

Ich habe auch versucht, "*"=repdie einzelnen Zeilen der Strophen und der "doos" zu wiederholen, aber das hat keine Bytes abgeschabt.

111 Bytes

Die alternative (und bessere) Lösung von Giuseppe und ASCII, die einige Platzprobleme behebt.

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

Probieren Sie es 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!
";

Laufen Sie mit php -nr '<code>'oder versuchen Sie es 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 doo\n";Write(a+a+a+i+" Shark!\n");}

Vielen Dank an @Destrogio für die Einsparung von 30 Bytes!

Probieren Sie es 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="
")

Dies fühlt sich nicht so 'clever' an wie die Antworten von CT Hall oder Sumner18 , aber durch die Vermeidung des Overheads beim Definieren von Variablen wird es kleiner.

Probieren Sie es online!

Bearbeiten: 1 Byte mit Wagenrücklauf nach Kommentar von Jonathan Frech gespeichert

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

Es gibt wahrscheinlich einen besseren Weg, das zu tun, aber ich konnte es nicht bekommen.

Bearbeiten:
'\ n' wird auf Vorschlag von JDL durch eine aktuelle neue Zeile ersetzt.
Der nachgestellte Zeilenumbruch wurde auf Vorschlag von Giuseppe entfernt.

Probieren Sie es online aus

wenn Sie versehentlich 100Angebote schließen - 123.065 121.716 113.695 100.889 98.554 Bytes

Das Programm

Ich werde das später Golf spielen. Getan.

Ich werde diesmal Golf spielen. (Später) Fertig.

Ich werde das später noch mehr Golf spielen. GETAN.

Ich werde die Byteanzahl später auf 5 Stellen bringen. YAY.

Ich werde die Byteanzahl auf 4 Stellen bringen (ich weiß nicht, ob dies möglich ist, aber ich weiß, dass es mit meinem aktuellen Ansatz unmöglich ist, 3 Stellen zu bekommen).

C (gcc) , 123 122 Bytes

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

Probieren Sie es online!

cQuents , 93 89 Bytes

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

Probieren Sie es online!

Beachten Sie, dass TIO zum Zeitpunkt der Veröffentlichung nicht auf die neueste Version aktualisiert wurde, sodass der TIO-Link möglicherweise nicht funktioniert.

Erläuterung

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

Wahrscheinlich sehr golffähig. Erzeugt die Zeile "doo doo" und erstellt dann drei davon mit dem "!" Zeile danach und wiederholt dies für jeden Hai.

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)

Probieren Sie es online!

jq, 87 Zeichen

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

Probelauf:

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!

Probieren Sie es online!

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

Ziemlich enttäuschend, aber ich habe seit Ewigkeiten keine TeX-Antwort mehr gepostet. Schleifen sind in teX sehr ausführlich (und das Schleifen über Strings ist noch nicht einmal eingebaut, selbst dies ist ein bisschen langwierig)

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

Dank an @manatwork für das Speichern von 6 Bytes durch Hinweisen str_pad('',23'doo ');ist kürzer alsrtrim(str_repeat('doo ',6));

Probieren Sie es online!