Canta Baby Shark

68

"Baby Shark" è una canzone per bambini su una famiglia di squali. Essendo stato a lungo popolare come canzone da falò, è stato reso popolare dalla metà degli anni 2000 da social media, video online e radio. - Wikipedia

Scrivi un programma che non accetta input e scrive il seguente testo nell'output standard o in un file 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!

Questo è il codice golf - vince il codice più corto.

Ho trovato questo su Reddit ^ 1 ^ 2 e sembra una sfida interessante per il golf.

aggiornamenti:

Nessuna nuova riga tra le stanze, questo rende troppo facile :)

Le nuove linee guida / finali vanno bene.

code-golf  string  kolmogorov-complexity 
— njha
fonte
6
È accettabile una nuova riga tra ogni stanza (ogni squalo)? (È sempre così che ho visto i testi scritti)
— Quintec,
6
Eh, mancano alcuni versi, come tutti quelli sui nuotatori che nuotano e perdono gli arti negli attacchi degli squali.
— mbomb007,
2
"doo doo doo doo doo doo" è davvero troppo semplificato.
— R ..
26
Come genitore, sento il forte bisogno di sottovalutare questo. Sto reprimendo l'impulso perché non è così che Stack Exchange funziona. Ma se mi ritrovo a canticchiare "doo doo doo doo" più tardi oggi, torno qui e ti ritengo responsabile!
— Cort Ammon,
5
Quante giornate di persone hanno rovinato ora che questo è sugli HNQ?
— CactusCake

Risposte:

74

Emojicode, 292 byte (140 caratteri)

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

Eseguirlo

Espanso:

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

Spiegato (secondo il documento Emojicode ):

🍇🍉

Lo stesso di un {e }(ad esempio un blocco di codice)

🏁

L '"avvio del programma" (ad es. int main())

🔤Baby🔤 ➡️ b

Assegnazione variabile (ad es. const char* b = "Baby";)

🍨b y o g a🍆➡️f

Dice, crea un elenco di valori tra 🍨 e 🍆 e assegna (➡️) a f(es. const char* f[] = {b,y,o,g,a};)

🔂m f🍇 ... 🍉

Questa riga dice di scorrere gli elementi fnell'uso dell'alias m, dove ...è il codice tra 🍇 e 🍉.

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

Questa riga dice di passare sopra l'intervallo [0,3), dove ...è il codice tra 🍇 e 🍉.

😀🍪 ... 🍪️❗️

Questa riga dice di stampare il formato specificato in ...(es. printf("%s\n");)

Il codice tradotto 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;
}

In seguito, il codice originale (pubblicato di seguito per i posteri) presentava alcuni problemi; principalmente che il blocco 🏁🍇🍉 non è stato incluso per coloro che desiderano eseguirlo e che le emoji non sono state effettivamente salvate correttamente, a questo, ecco la versione corrente di quel codice:

Originale modificato per l'esecuzione: Emojicode, 224 byte (67 caratteri)

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

Espanso:

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

Che produce l'output:

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

Eseguirlo

Dove in te hai le singole emoji che rappresentano le parole:

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

Originale: Emojicode, 138 byte (47 caratteri)

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

Espanso:

🍨👶👨🤱👴👵🍆➡️f
🔂m f🍇
  🔂 i 🆕⏩⏩ 0 3❗️🍇
    😀 m 🦈💩💩💩💩💩💩❗️
  🍉
  😀 m 🦈!❗️
🍉
— txtechhelp
fonte
31
Punti per la creatività, ma questo non produce l'output richiesto
— Jo King,
15
Benvenuti nel sito! Mentre JoKing stava arrivando, chiediamo che le risposte facciano esattamente quello che la domanda pone qui. Ciò significa che mentre la tua interpretazione della sfida è creativa, questa risposta dovrebbe essere corretta per produrre l'output corretto o eliminata.
— Wheat Wizard
12
Sebbene questa risposta sia creativa, non segue i requisiti della sfida e quindi non è valida: il testo deve essere prodotto esattamente come indicato nella sfida.
— Mego
8
Modifica questa risposta per produrre l'output corretto oppure eliminala.
— mbomb007,
6
Benvenuti nel sito! Quando provo a eseguire questo codice online , viene visualizzato un errore. (Conta anche 98 caratteri invece di 94). Mi sto perdendo qualcosa?
— DJMcMayhem
31

IBM PC DOS, assembly 8088, 115 114 109 108 byte

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

smontato:

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

Produzione

DOS DIR, SHARK

Scarica SHARK.COM!

  • -5 byte grazie a @Deadcode
— 640KB
fonte
6
Assolutamente pazzo.
— MGOwen il
5
Quando hai detto Download SHARK.COM!, ho pensato subito ai virus informatici.
— MilkyWay90,
@gwaugh Stavo scherzando
— MilkyWay90 il
@gwaugh Ma sono 109 byte
— MilkyWay90
21

Python 2 , 93 byte

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

Provalo online!

94 byte

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

Provalo online!

— XNOR
fonte
16

05AB1E , 50 41 byte

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

L'ultima parte v4FN3Qiy'!«ë…doo6иyšðý},può sicuramente essere giocata a golf un po '.. E avevo ragione, -9 byte grazie a @Emigna (anche più di quanto mi aspettassi).

Provalo online.

Spiegazione:

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

Vedi questo mio suggerimento 05AB1E (sezione Come usare il dizionario? ) Per capire perché “‡ÍÊТ×myîºpaîºma“è "baby daddy mommy grandpa grandma"ed 'ã¢è "shark".

— Kevin Cruijssen
fonte
2
Puoi giocare a golf con 9 byte dell'ultimo bit conv…doo6иyšÐy'!«»
— Emigna,
@Emigna Hai anche giocato a golf più di quanto mi aspettassi, grazie! Modo intelligente di usare il triplicato e »!
— Kevin Cruijssen,
14

PowerShell, 88 86 85 80 79 76 byte

-5 byte grazie a @mazzy
-1 byte grazie a @Joey
-3 byte grazie a @AdmBorkBork

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

Provalo online!

Abbiamo sicuramente fatto molta strada.

PowerShell (con sintesi vocale), 156 byte

Questo NON dipende dalle specifiche, ma è piuttosto divertente. Grazie a @rkeet per l'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 pronuncia vocale di .NET è ... beh ... interessante. Tienilo a mente quando ascolti. Godere!

— Gabriel Mills
fonte
2
80 byte :)
— mazzy il
1
È possibile salvare un altro byte assegnando "$_ Shark"una variabile e riutilizzandola.
— Joey,
2
76 byte usando echoinvece di -split.
— AdmBorkBork,
1
Penso che dovresti avere anche un "text to speech": p Per l'inferno ha provato a combinarlo un po 'con questo codice , non ha funzionato del tutto :-)
— rkeet
@rkeet Challenge accettata! Attualmente lo sto scervellando.
— Gabriel Mills,
9

Retina 0.8.2 , 77 75 74 byte


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

Provalo online! Spiegazione:


Baby¶Daddy¶MommyGpaGma
G
¶Grand

Inserisci le relazioni su righe separate.

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

Espandi in quattro righe.

s
S6$*O¶
O
 doo
S
 Shark

Espandi i segnaposto.

69 68 byte in Retina 1:


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

Provalo online! Spiegazione:


Baby¶Daddy¶MommyGpaGma
G
¶Grand

Inserisci le relazioni su righe separate.

.+
$& Shark

Aggiungi lo squalo a ciascuno.

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

Espandi in interi versi.

— Neil
fonte
9

Python 3, 105 97 96 byte

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

Provalo online!

Una semplice soluzione Python 3. (9 byte salvati da Jo King e Quintec)

— njha
fonte
2
Le parentesi qui intorno ' doo'*6non sono necessarie e hai spazi bianchi non necessari lì
— Quintec,
1
Cosa ha detto quintec ... 97 byte
— Jo King il
2
@ReverseCold tecnicamente dove non c'è []una tupla, non un elenco, ma non è rilevante per questo programma
— Stephen,
2
96 byte impostando x+' Shark'una variabile
— Jo King,
1
Questo sembra funzionare anche in 2.7?
— UHOH
9

Haskell , 122 113 108 106 104 byte

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

Provalo online!

  • "aaa">>xsi replica x3 volte, così come la "aaa"lunghezza 3.

  • s>>" doo"si replica " doo"6 volte, così come la " Shark"lunghezza 6!

  • 2 byte salvati grazie a @Fox

  • 2 byte salvati grazie a @Laikoni
— starsandspirals
fonte
2
Benvenuti nel sito! Consentiamo solo di generare una stringa di output fissa come espressione , in modo da poter omettere main=putStr. Vedi anche il riepilogo delle regole di Haskell .
— xnor
1
Benvenuti in PPCG. Bello risparmiare con s>>.
— Shaggy,
@xnor grazie per i collegamenti!
— starsandspirals
1
m=(stuff)può essere solo m=stuffper due byte in meno
— Fox
1
104 byte usando do-notation: provalo online!
— Laikoni,
7

Perl 6 , 79 78 byte

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

Provalo online!

Abbastanza semplice.

Spiegazione:

 <...>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
— Jo King
fonte
7

JavaScript, 104 byte

Più golf da seguire.

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

Provalo online!

— ispido
fonte
1
Questa tecnicamente non è una soluzione valida poiché non scrive né su un file né lo registra. Tuttavia, se la rendi una soluzione valida avvolgendola con un console.log(), non puoi renderla non una dichiarazione lambda (guadagno di soli 10 caratteri)
— Delioth
3
@Delioth, il ritorno da una funzione è perfettamente valido su questo sito. Dai un'occhiata a Meta per le nostre regole I / O predefinite.
— Shaggy,
2
Sono generalmente d'accordo, ma questa domanda afferma specificamente che il programma "scrive il seguente testo nell'output standard o in un file arbitrario"
— Delioth,
7

bash, 78 byte

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

TIO

73 byte se è consentito lo spazio finale

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

> <> , 158 115 byte

Risparmio di molti byte grazie a Jo King

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

Provalo online! Puoi anche incollare il codice su fishlanguage.com , dove puoi vederne un'animazione mentre nuota .

— DLosc
fonte
121 byte , principalmente attraverso il riordino del bambino / papà / ... su più righe anziché su una riga. Ma c'è di più nel golf
— Jo King,
— Jo King,
@JoKing Ah, grazie. Tendo ad assumere (principalmente dal lavorare con BitCycle) che meno linee siano migliori, ma in questo caso non è vero a causa delle diverse lunghezze delle stringhe.
— DLosc
5

PostgreSQL, 162 156 138 byte

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

Risparmiato 6 24 byte grazie a @Nahuel Fouilleul!

  • utilizzare ||invece diconcat()
  • utilizzare unnest('{foo,bar}'::text[])invece diregexp_split_to_table('foo,bar')

DB <> violino

— Peter Vandivier
fonte
1
-6 byte usando ||invece di concat Visualizza su DB Fiddle
— Nahuel Fouilleul il
1
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,
5

Haskell , 97 byte

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

Provalo online!

Questa è un'ottimizzazione della soluzione Haskell di starsandspirals . Il nuovo trucco è quello di scorrere le righe di ogni stanza con un ciclo interno e unire le linee usando unlines, risparmiando la necessità di inserire esplicitamente nuove righe.

I suffissi delle quattro linee sono [a,a,a,"!"], dove aviene " doo"replicato 6 volte con a=s>>" doo", dove gli spirali stellari riutilizza abilmente la lunghezza di sei caratteri s=" Shark". Scrivere [a,a,a,...]sembra un po 'sciocco, ma non vedo un modo più breve.

Una versione list-monad ha la stessa lunghezza ma sembra interessante.

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

Provalo online!

— XNOR
fonte
4

Rubino , 82 byte

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

Provalo online!

— Kirill L.
fonte
Mi ci è voluto un po 'di tempo per capire che hai usato la parte "doo" come separatori di array. Ottimo lavoro :)
— Idva,
4

R , 131 122 120 byte

-9 byte grazie a Giuseppe

-2 byte in più, anche Giuseppe

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

Provalo online!

Molto orgoglioso di questo in realtà, specialmente con R che è piuttosto povero nel maneggiare le stringhe. Ho iniziato a usare cat(sapply(...)), ma ho realizzato che un ciclo for si rade di pochi byte.

Abusare della "?"=criduzione significativa della quantità di parentesi necessaria.

Ho anche provato a fare "*"=repper ripetere le singole linee delle stanze e dei "doos", ma questo non ha rasato alcun byte.

111 byte

La soluzione alternativa (e migliore) per soli Giuseppe e ASCII che risolve alcuni problemi di spaziatura.

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

Provalo online!

— Sumner18
fonte
1
— Giuseppe,
Come sempre, grazie per il tuo saggio contributo @Giuseppe. Avrei dovuto notare quei
— campi da
1
— Giuseppe,
1
@Giuseppe wow, vettorializzazione, simpatica. Ho dimenticato che R ha una bella vettorializzazione come questa. 114? anche 114?
— ASCII il
1
— ASCII, solo il
3

R , 126 125 byte

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

Questo non sembra "intelligente" come le risposte di CT Hall o Sumner18 , ma evitando il sovraccarico di definire le variabili risulta più piccolo.

Provalo online!

Modifica: salvato 1 byte utilizzando il ritorno a capo come da commento di Jonathan Frech

— BobbyBean
fonte
Ciao e benvenuto in PPCG! Ho aggiunto collegamenti alle risposte dell'utente che hai citato per confrontare meglio le tue soluzioni. Complimenti per aver superato entrambi, potresti aggiungere un link a un ambiente di test online per una facile verifica?
— Jonathan Frech,
Grazie per la modifica @JonathanFrech. Ho ora aggiunto un link per testare il codice online (che ha aggiunto un byte alla mia risposta!).
— BobbyBean,
È possibile utilizzare una nuova riga effettiva anziché \nriportare nuovamente indietro il conteggio dei byte.
— Jonathan Frech,
— Giuseppe,
1
Beh, sono stato completamente superato; a volte l'opzione più semplice è la migliore. Sottolinea inoltre quanto sia difficile lavorare con le stringhe in R.
— CT Hall,
3

R , 139 138 137 byte

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

Probabilmente c'è un modo migliore per fare i doo ma non sono riuscito a farlo.

Modifica:
sostituito "\ n" con la nuova riga effettiva su suggerimento di JDL;
Rimossa la nuova riga finale su suggerimento di Giuseppe.

Provalo online

— CT Hall
fonte
benvenuto in ppcg! Per lo meno, la sostituzione di "\ n" con una nuova riga letterale salverà un byte.
— JDL
Grazie, l'ho fatto e poi ho capito che il mio output era un po 'fuori moda, quindi l'ho aggiornato, purtroppo ha comportato più byte.
— CT Hall
Credo che tu abbia una nuova riga finale per un byte in più
— Giuseppe,
3

quando si perde accidentalmente100endorsementsnationstates - 123.065 121.716 113.695 100.889 98.554 byte

Il programma

Giocherò a golf più tardi. Fatto.

Giocherò più a golf (più tardi) Fatto.

Lo golfò ancora di più in seguito. FATTO.

Prenderò il conteggio dei byte a 5 cifre più tardi. SÌÌ.

Prenderò il conteggio dei byte a 4 cifre (non so se questo è possibile, ma so che è impossibile ottenere 3 cifre con il mio approccio attuale).

— MilkyWay90
fonte
Che diavolo è questo? Lo adoro
— Adrian Zhang,
@AdrianZhang Un linguaggio di programmazione difficile da programmare. Inoltre, il programma sembra essere una persona che urla ('AAAAAAAAAAA ...')
— MilkyWay90,
3

C (gcc) , 123 122 byte

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

Provalo online!

— gastropner
fonte
Quali sono le regole per C? Non c'è bisogno main()o #includeper printf?
— BoBTFish,
@BoBTFish: non specifico per C ma generalmente è consentito utilizzare qualsiasi funzione (il nome non ha importanza, anzi può essere un lambda senza nome o simile). E i linguaggi sono definiti dalla loro (qualsiasi) implementazione, dal momento che funziona gcc(genera solo avvisi, ma compila bene) è valido.
— ბიმო
Mi sono reso conto che la mancanza di #includeera solo un errore perché stavo ancora compilando come C ++, ma non riuscivo ancora a farlo compilare senza rinominare la tua funzione main.
— BoBTFish
2

cQuents , 93 89 byte

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

Provalo online!

Si noti che a partire dalla pubblicazione di TIO non viene aggiornato alla versione più recente, quindi il collegamento TIO potrebbe non funzionare.

Spiegazione

|                               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
— Stefano
fonte
2

JavaScript (Node.js) , 132 byte

Probabilmente molto in grado di giocare a golf. Genera la riga "doo doo", quindi ne crea tre con "!" linea dopo e ripete questo per ogni squalo.

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)

Provalo online!

— Neil A.
fonte
Una soluzione leggermente cambiata in Javascript, nessun guadagno però: a = ""; c = "doo"; for (b di ["Baby", "Daddy", "Mommy", "Grandpa", "Grandma"]) {b + = "Squalo"; t = b + c.repeat (6) + "\ n"; a + = t + t + t + b + "! \ N"} console.log (a)
— BogdanBiv
2

jq, 87 caratteri

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

Esecuzione di esempio:

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!

Provalo online!

— uomo al lavoro
fonte
2

TeX semplice, 147 byte

\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

Piuttosto deludente, ma non ho pubblicato una risposta TeX da anni. I loop sono molto dettagliati in teX (e il looping sulle stringhe non è nemmeno incorporato, quindi anche questo è un po 'allungato)

— Chris H
fonte
2

PHP , 153 147 byte

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

Grazie a @manatwork per aver salvato 6 byte sottolineando str_pad('',23'doo ');è più breve dirtrim(str_repeat('doo ',6));

Provalo online!

— EvanBarbour3
fonte
Sfortunatamente anche $d='doo doo doo doo doo doo'è più breve di quella rtrim()+ str_repeat()combinazione. :( Ma per fortuna $d=str_pad('',23,'doo ')è ancora più breve. Per ulteriori suggerimenti sull'ottimizzazione, vedi Suggerimenti per giocare a golf in PHP .
— manatwork
@manatwork Grazie per averlo sottolineato, ho aggiornato il post per riflettere
— EvanBarbour3 il
1
Nel frattempo ho
— arte
113 byte . Benvenuti in PPCG!
— Shaggy,
2
— Shaggy
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.