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

SOGL , 40 bytes

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

Experimente aqui!

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

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

Faça o download do SHARK.COM!

• -5 bytes graças a @Deadcode

Python 2 , 93 bytes

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

Experimente online!

94 bytes

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

Experimente online!

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

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!

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

Experimente 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

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.

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)

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

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

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!

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{,,}{,}`"{,,},!}

/// , 124 bytes

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

Experimente online!

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

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

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!

Ruby , 82 bytes

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

Experimente online!

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!

PHP, 104 bytes

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

Corra com php -nr '<code>'ou experimente online .

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

Obrigado a @Destrogio por salvar 30 bytes!

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

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

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

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

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!

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

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!

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!

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)

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!