sfondo

L'estate è finita nell'emisfero settentrionale e a molti di noi manca il sole, le spiagge, le onde dell'oceano ... Questa sfida ha lo scopo di rallegrarli ricordandoli del mare.

La sfida

Ecco il mare:

             **              **              **              **              ** 
         ****            ****            ****            ****            ****   
      *****           *****           *****           *****           *****     
    **   **         **   **         **   **         **   **         **   **     
  **      **      **      **      **      **      **      **      **      **    
**          ******          ******          ******          ******          ****

Il mare è composto da 5 volte questo modello d'onda:

            **  
        ****    
     *****      
   **   **      
 **      **     
*          *****

Si noti che il modello è lungo 16 caratteri e il mare è 5 volte questo modello = 80 caratteri.

Che puoi stampare in un terminale usando questa riga di comando:

perl -e 'print "            **  \n        ****    \n     *****      \n   **   **      \n **      **     \n*          *****\n"'

O questo:

perl -e 'print " "x12, "*"x2, " "x2, "\n", " "x8, "*"x4, " "x4, "\n", " "x5, "*"x5, " "x6, "\n", " "x3, "*"x2, " "x3, "*"x2, " "x6, "\n", " "x1, "*"x2, " "x6, "*"x2, " "x5, "\n", "*"x1, " "x10, "*"x5, "\n"'

(Il secondo dovrebbe renderti più semplice ottenere il modello esatto)

Il tuo compito è quello di visualizzare il mare in un terminale e far sembrare che le onde si stiano muovendo verso destra: deve spostarsi a destra alla velocità di 1 carattere ogni 100 ms (= 10 volte al secondo). Nessun carattere dovrebbe essere stampato dopo l'80a colonna, ma quando scompare l'onda più a destra, una nuova appare a sinistra.
Ecco un esempio di output:

tempo = 0,0 s

             **              **              **              **              ** 
         ****            ****            ****            ****            ****   
      *****           *****           *****           *****           *****     
    **   **         **   **         **   **         **   **         **   **     
  **      **      **      **      **      **      **      **      **      **    
**          ******          ******          ******          ******          ****

tempo = 0,1 s

              **              **              **              **              **
          ****            ****            ****            ****            ****  
       *****           *****           *****           *****           *****    
     **   **         **   **         **   **         **   **         **   **    
   **      **      **      **      **      **      **      **      **      **   
***          ******          ******          ******          ******          ***

tempo = 0,2 s

*              **              **              **              **              *
           ****            ****            ****            ****            **** 
        *****           *****           *****           *****           *****   
      **   **         **   **         **   **         **   **         **   **   
    **      **      **      **      **      **      **      **      **      **  
****          ******          ******          ******          ******          **

tempo = 0,3 s

**              **              **              **              **              
            ****            ****            ****            ****            ****
         *****           *****           *****           *****           *****  
       **   **         **   **         **   **         **   **         **   **  
     **      **      **      **      **      **      **      **      **      ** 
*****          ******          ******          ******          ******          *

tempo = 0.4s

 **              **              **              **              **             
*            ****            ****            ****            ****            ***
          *****           *****           *****           *****           ***** 
        **   **         **   **         **   **         **   **         **   ** 
      **      **      **      **      **      **      **      **      **      **
******          ******          ******          ******          ******          

Naturalmente, ogni uscita dovrebbe sostituire la precedente.

Puoi eseguire questo codice in un terminale unix per vedere come dovrebbe apparire con l'animazione:

perl -M5.010 -MTime::HiRes=sleep -E '@arr=([($")x12,($n="*")x2,($")x3],[($")x8,($n)x4,($")x4],[($")x5,($n)x5,($")x6],[($")x3,($n)x2,($")x3,($n)x2,($")x6],[($")x1,($n)x2,($")x6,($n)x2,($")x5],[($n)x1,($")x10,($n)x5]);while(++$j){for$i(0..5){for$k(0..15) {$out[$i][16*$_+$k]=$arr[$i][($k-$j)%16]for 0..4}}say"\e[H",$/,join$/,map{join"",@$_}@out;sleep 0.1}'

(Si noti che questo codice non è molto ben equipaggiato: l'ho appena reso abbastanza compatto da essere comodo da funzionare in un terminale.)

Criterio vincente

Questo è codegolf, quindi vince il codice più breve in byte.

MATL , 41 40 byte

`'3SJp/B@Tc`@+ara'F'* 'Za6el&Xx80:@-Z)DT

Esempio di esecuzione:

Oppure provalo su MATL Online! (la velocità effettiva può dipendere dal carico del server).

Come funziona

`                    % Do...while
  '3SJp/B@Tc`@+ara'  %   Compressed string (actually it's just a change of base)
  F                  %   Push false. Indicates base-95 input alphabet for decompression
  '* '               %   Push this string, which defines output alphabet
  Za                 %   Base conversion. This decompresses the string
  6e                 %   Reshape as a 6-row char array. This gives the basic pattern
  l&Xx               %   Pause 0.1 seconds and clear screen
  80:                %   Push array [1 2 ... 80] 
  @-                 %   Subtract iteration index to each element of that array. This
                     %    will produce the rotation via modular indexing
  Z)                 %   Use as column index. Indexing is modular, so this repeats
                     %   (and rotates) the pattern
  D                  %   Display
  T                  %   True. Loop condition for infinite loop
                     % Implicit end

JavaScript (ES6) + HTML, 151 143 + 10 = 161 153 byte

a=[48,15,57347,6147,1542,504];setInterval("a=a.map(n=>{for(x=-1;++x<80;)s+=' *'[n>>x%16&1];s+=`\n`;return n>>>15|n<<1},s='');O.innerHTML=s",99)

<pre id=O>

HTML + CSS, 70 + 181 175 = 245 byte

Fa uso di text-shadow, rtlanimazioni di testo e dei fotogrammi chiave CSS.

a{display:flex;overflow:hidden;width:80ch}pre{text-shadow:16ch 0,32ch 0,48ch 0,64ch 0,80ch 0;direction:rtl;animation:w steps(16)1.6s infinite}@keyframes w{0%{margin-left:-16ch

<a><pre>**
  ****
    *****
    **   **
   **      **
***          ***

C # 450 444 425 417 byte

399 senza using System.Linq;ma sono sicuro che sarebbe barare ...

Modifica: salvato 25 byte grazie a @Cyoce

golfed:

void S(){Func<string,string>r=a=>string.Concat(Enumerable.Repeat(a,5));Func<string,int,string>s=(b,i)=>(b.Substring(16-i)+b).Substring(0,80);int p=0;for(;;){Console.Clear();Console.WriteLine(string.Join("\r\n",new string[]{s(r("            **  "),p),s(r("        ****    "),p),s(r("     *****      "),p),s(r(" **      **     "),p),s(r("*          *****"),p),}));Thread.Sleep(100);p++;if(p==16)p=0;}}

Ungolfed:

public void S()
{
  Func<string, string> r = a => string.Concat(Enumerable.Repeat(a, 5));
  Func<string, int, string> s = (b, i) => (b.Substring(16 - i) + b).Substring(0, 80);

  int p = 0;
  for(;;)
  {
    Console.Clear();
    Console.WriteLine(
      string.Join("\r\n", new string[]
    {
      s(r("            **  "), p),
      s(r("        ****    "), p),
      s(r("     *****      "), p),
      s(r(" **      **     "), p),
      s(r("*          *****"), p),})
      );
    Thread.Sleep(100);
    p++;

    if (p == 16)
      p = 0;
  }
}

V, 98 97 73 byte

Grazie a @ nmjcman101 per aver salvato 24 byte!

i¹ ³ **  
¸ ´*´ 
µ µ*¶ 
³ **³ **¶ 
 **¶ **µ 
*± µ*<ESC>{<C-v>}y4pò:sl100m
$<C-v>}x|Pò

Questo contiene molti non stampabili, quindi ecco un hexdump xxd:

0000000: 69c2 b920 c2b3 202a 2a20 200a c2b8 20c2  i.. .. **  ... .
0000010: b42a c2b4 200a c2b5 20c2 b52a c2b6 200a  .*.. ... ..*.. .
0000020: c2b3 202a 2ac2 b320 2a2a c2b6 200a 202a  .. **.. **.. . *
0000030: 2ac2 b620 2a2a c2b5 200a 2ac2 b120 c2b5  *.. **.. .*.. ..
0000040: 2a1b 7b16 7d79 3470 c3b2 3a73 6c31 3030  *.{.}y4p..:sl100
0000050: 6d0a 2416 7d78 7c50 c3b2 0a              m.$.}x|P...

modificare

1. Usato al y$posto di<C-v>$y

2. Molti cambiamenti

   • Invece di copiare ogni riga e incollarle 4 volte, prima di tutto generi l'onda e poi copio tutto e incollalo 4 volte
   • Utilizzato {e }per salvare pochi byte
   • Usato al òposto dei registri per creare il ciclo infinito (per qualche motivo devo includere un òalla fine per farlo funzionare)
   • riparato lo statico *nella parte inferiore

Mini-Spiegazione

Sto usando <alt-n>per creare copie di stringhe. Ad esempio, <alt-5>*(sembra simile µ5) crea 5copie *in modalità inserimento. Ho scoperto che questo è più breve rispetto alla copia della stringa e all'uso di una regex per eseguire le sostituzioni necessarie. Dopo aver creato un'onda, la incollo per creare le altre onde. Infine, eseguo il loop ricorsivamente usando òper creare il loop infinito (con un ritardo di 100ms).

gif

Gran parte del codice è dedicato alla creazione dell'onda, quindi sto ancora cercando di giocare a golf. Si noti che questo codice non funzionerà su TIO poiché TIO emette l'output solo dopo che il codice ha terminato l'esecuzione. Quindi ecco una gif (mi dispiace per la bassa qualità, ho dovuto usare un sito Web per convertire un .movin un .gif, anche quello >_che continua a spuntare a destra è l'icona Terminale sul dock del mio mac):

Lotto, 424 byte

@echo off
set f=     
set a=%f%%f%  **  
set b=%f%   ****    
set c=%f%***** %f%
set d=   **   ** %f%
set e= **%f% **%f%
set f=*%f%%f%*****
set a=%a%%a%%a%%a%%a%%b%%b%%b%%b%%b%%c%%c%%c%%c%%c%%d%%d%%d%%d%%d%%e%%e%%e%%e%%e%%f%%f%%f%%f%%f%
:l
cls
echo %a%
set a=%a:~79,1%%a:~0,79%%a:~159,1%%a:~80,79%%a:~249,1%%a:~160,79%%a:~319,1%%a:~240,79%%a:~399,1%%a:~320,79%%a:~-1%%a:~-80,79%
ping>nul 1.1 -n 1 -w 100
goto l

Alcune linee hanno spazi finali. Richiede un terminale standard a 80 colonne. I tempi non sono molto precisi, ma è il massimo che puoi fare in Batch.

Racchetta 395 374 373 367 364 351 byte

Utilizza una libreria esterna per la cancellazione dello schermo
Modifica: salvato 21 byte non definendo we incorporando la funzione.
Modifica2: 1 byte salvato rimuovendo uno spazio.
Edit3: salvato 6 byte rinominandolo loopin p, grazie @rnso!
Edit4: inserendo la sottostringa nel salvataggio di 3 byte.
Edit5: Rimuovi #lang racket, che non è necessario nell'interprete.

Golf: 351 byte

[require[planet neil/charterm:3:0]][let p([n 1])[with-charterm[void[charterm-clear-screen]]][for([i'["            **  ""        ****    ""     *****      ""   **   **      "" **      **     ""*          *****"]])[let([g substring][x[string-join[make-list 5 i]""]])[displayln[string-append[g x[- 16 n]][g x 0[- 16 n]]]]]][sleep .1][p[modulo[+ n 1]16]]]

Scorrimento (non azzerato): 272 byte

[let p([n 1])[for([i'["            **  ""        ****    ""     *****      ""   **   **      "" **      **     ""*          *****"]])[let([g substring][x[string-join[make-list 5 i]""]])[displayln[string-append[g x[- 16 n]][g x 0[- 16 n]]]]]][sleep .1][p[modulo[+ n 1]16]]]

Ungolfed:

#lang racket
[require [planet neil/charterm:3:0]]
[define w
'[
"            **  "
"        ****    "
"     *****      "
"   **   **      "
" **      **     "
"*          *****"]]
[define (rotmul count)
  [for ([i w])
    [let ([x [string-join [make-list 5 i] ""]])
      [displayln [string-append [substring x count]
                                [substring x 0 count]]]]]]

[let loop ([n 1])
  [with-charterm
   [void [charterm-clear-screen]]]
  [rotmul [- 16 n]]
  [sleep .1]
  [loop [modulo [+ n 1] 16]]]

PowerShell 3.0, 183 182 173 byte

Richiede PS 3.0 per gli operatori di spostamento binario. Ridotto a 173 byte con l'aiuto di AdmBorkBork !

$w=12,240,1984,6336,24672,32799
for(){0..5|%{'{0:D16}'-f+[Convert]::ToString(([uint16]$o=$w[$_]),2)*5-replace0,' '-replace1,'*'
$w[$_]=$o-shr1-bor$o-shl15}
sleep -m 100
cls}

Bash + coreutils, 172 148 byte

24 byte salvati grazie a @zeppelin , molte grazie

while :
do clear
cut -c$[i=i%16+1]-$[79+i] <(base64 -d<<<4AJFACddABVgf2dnw+CvmeyOkhIoUJOPLK6oKkljh0+Peqi5BfrbbnDyuVkr+AA==|xz -qdFraw)
sleep .1
done

La prima riga decomprime il seguente schema costituito da 6 onde consecutive:

**              **              **              **              **              **              
            ****            ****            ****            ****            ****            ****
         *****           *****           *****           *****           *****           *****  
       **   **         **   **         **   **         **   **         **   **         **   **  
     **      **      **      **      **      **      **      **      **      **      **      ** 
*****          ******          ******          ******          ******          ******          *

Quindi, il ciclo fa scorrere una finestra larga 80 byte attraverso quel modello.

*> <> , 251 250 251 byte (non concorrenti)

" **             "e1C0["   ****         "e1C0["     *****      "e1C0["     **   **    "e1C0["    **      **  "e1C0["****          **"e1C0[06.
52Cl2,[52C52C]R
<v0&:l
$>:@=?v1+{:}&l1-[:&$@
?!v]1->:
~R>
vDDDDDD"H;0["ooooo
>l?u1S06.O{52Cl2,[a}48C]I
ol?!R

^{Nota: "H;0["dovrebbe avere ascii 27dopo [.}

Provalo qui! (imposta il ritardo su 0ms)

Non riesco a credere di aver finito con successo. Questo utilizza le istruzioni Ie D, che incrementa o decrementa la pila selezionata. Ciò dimostra che probabilmente è possibile farlo in puro> <> (meno il sonno) o in una risposta competitiva *> <>, anche se probabilmente molto più difficile da fare.

La versione dell'interprete online è diversa semplicemente per cancellare l'output usando un ritorno a capo.

Questo è fuori concorso perché i I, D, C, e Rle istruzioni sono più giovani rispetto alla sfida. Questo è probabilmente possibile fare a meno di quelle istruzioni, ma sarebbe molto difficile / lungo.

Modifica: in realtà sono riuscito a rimuovere un byte, ma ho anche notato che ho misurato la dimensione sbagliata, quindi ho effettivamente guadagnato un byte.

Farò del mio meglio per abbattere i passaggi e spiegare cosa sta succedendo qui ...

Spiegazione

" **             "e2C0["   ****         "e2C0["     *****      "e2C0["     **   **    "e2C0["    **      **  "e2C0["****          **"e2C0[09.
# Copy current stack 4 times
54Cl2,[54C54C]R
# Copy stack
<v0&:l
$>:@=?v1+{:}&l1-[:&$@
?!v]1->:
~R>
# Main loop
vDDDDDD"H;0["ooooo
>l?u1S09.O{54Cl2,[a}4cC]I
# Output stack
ol?!R

Sommario

Line 1 - Initialization
e2C    - Call "copy current stack 4 times"
54C    - Call "copy stack"
09.    - Jump to "main loop"
4cC    - Call "output stack" (not explained, is very simple)

Inizializzazione

Qui costruiamo le 6 linee che costruiscono le onde. Dobbiamo ripetere ogni stringa 5 volte per avere la lunghezza corretta.

Iniziamo con 6 di questi, uno per ogni linea dell'onda:

 " **             "       push " **             " to the stack
                   e2C    call "copy current stack 4 times"
                      0[  create a new stack

E entriamo nel ciclo principale dopo l'inizializzazione 09..

Copia lo stack corrente 4 volte

Questa è una semplice funzione che prende semplicemente lo stack corrente e lo copia 4 volte. Quindi "a" diventerebbe "aaaaa".

54C              call "copy stack"
   l2,[          copy half the current stack to a new stack
       54C54C    call "copy stack" twice
             ]   close the current stack, moving values to the one below
              R  return from the function

Copia pila

Questo copia lo stack corrente, aggiungendo la copia allo stack corrente.

Impostare

Andando per saltare l'iniziale <e invertire la prima riga per diventare l:&0vcome è l'ordine in cui viene eseguita dopo le <modifiche alla direzione dell'IP.

l      push the stack length to the stack
 :&    copy the length to the register
   0   push 0 to the stack
    v  move the IP downwards, entering the loop

Da qui in poi la lunghezza verrà indicata come ne 0come i.

Ciclo continuo

>                        move the IP to the right
 :                       copy i
  @=?v                   pop i from the stack, if n == i, proceed to cleanup
      1+                 add 1 to i
        {:}              copy the first value of the stack to the end of the stack
           &             place n on the stack
            l1-[         open a new stack moving all values but index 0 to the new one
                :&       copy n and place it on the register
                  $@     swap i with the value on its right
                     $   swap i with n

Pulire

>                        move the IP to the right
 :?!v                    if i == 0 then ...
  ~R>                      remove i from the stack and return
     ]                   close the stack, appending all values to the stack below
      1-                 subtract 1 from i

Ciclo principale

Qui è dove il codice viene eseguito per sempre, ridisegnando costantemente le onde tra i 100 ms di sonno.

Impostare

DDDDDD                 select the 6th stack down
      "H;0[x"ooooo     move the cursor to the top-left of the term (x == ascii 27)
                  v    move the IP downwards, entering the loop 

Ciclo continuo

>                          move the IP to the right
 l?u     O                 if the stack is empty ...
    1S                       sleep for 100ms
      09.                    jump to main loop initialisation
          {                shift the stack left
           54Cl2,[         copy the current stack to a new stack
                  a        append a newline to the stack
                   }       shift the stack to the right
                    4cC    call "output stack"
                       ]   close the stack
                        I  select one stack higher

PHP, 128 byte

for($a=[3,60,496,1584,6168,57351];;usleep(1e5))foreach($a as&$x)for($x=$x/2|$x%2<<15,$i=80;$i--;)echo" *"[$x>>$i%16&1],"\n"[$i];

Impossibile animare più di una riga, ma scorre.
Aggiungi ,0all'array per una riga vuota tra le iterazioni. Corri con -r.

Mathematica, 213 byte

i=0;RunScheduledTask[i++,0.1];Dynamic[RotateRight[#,i]&/@Characters/@(StringRepeat[#,5]&)/@{"            **  ","        ****    ","     *****      ","   **   **      "," **      **     ","*          *****"}//Grid]

In Mathematica non vedo alcun modo di giocare a golf il motivo a onde se non quello di iniziare con un elenco di stringhe per ogni riga. Inizializzo ia essere 0e pianifico un'attività per incrementarla ogni 0.1secondo. Ho Dynamicalleato visualizzare il risultato delle seguenti:

1. StringRepeat ogni riga 5 volte.
2. Converti ogni riga in un suo elenco Characters.
3. RotateRightogni elenco di caratteri di i.
4. Visualizza la matrice di caratteri risultante come a Grid.

C (unix), 231 191 byte

Funzionerà solo su ambienti unix. Inoltre, ti preghiamo di scusare il fatto che sleep accetta solo numeri interi ... quindi in realtà ritarda di 1 secondo tra i frame.

Versione non golfata:

#include <stdio.h>
int main() {
    int x=0,l,i,a[6]={32799,24672,6336,1984,240,12};
    while(l=6,++x) {
        printf("\033[2J");
        while(i=128,l--) {
            while(i--) putchar(a[l]&1<<(i+x)%16 ? 42 :32);
            puts("");
        }
        sleep(1);
    }
}

Versione golfizzata:

#include <stdio.h>
int main(){int x=0,l,i,a[6]={32799,24672,6336,1984,240,12};while(l=6,++x){printf("\033[2J");while(i=128,l--){while(i--)putchar(a[l]&1<<(i+x)%16?42:32);puts("");}sleep(1);}}

Javascript (ES6), 152 147 145 byte

x=0,c=console;setInterval(a=>{for(c.clear();f="",i=128,++x,a--;c.log(f))for(;i--;)f+=" *"[[32799,24672,6336,1984,240,12][a]>>(i+x)%16&1]},100,6);

Perl 6, 140 138 137 123 120 byte

for ^Inf ->\i{print "\e[H";for 12,240,1984,6336,24672,32799 ->\j{say [~] map {j+>((i-$_)%16)%2??'*'!!' '},^80};sleep .1}

Vecchie soluzioni:

for ^Inf ->\i {print "\e[H";for 12,240,1984,6336,24672,32799 ->\j {say [~] map {j+>((i-$_)%16)%2??'*'!!' '},^80};sleep .1;}
my @a=12,240,1984,6336,24672,32799;for ^Inf ->\i {print "\e[H";for @a ->\j {for ^80 {print j+>((i-$_)%16)%2??'*'!!' '};say ""};sleep .1;}
my @a=12,240,1984,6336,24672,32799;for ^Inf {print "\e[H";for @a ->\j {for ^80 ->\k {print j+>(($_- k)%16)%2??'*'!!' '};say ""};sleep .1;}
my @a=12,240,1984,6336,24672,32799;for ^Inf {print "\e[H";for @a ->\j {for ^80 ->\k {print j+>(($_+15*k)%16)%2??'*'!!' '};say ""};sleep .1;}

Python 3, 240 239 230 byte

_{-1 byte grazie a @redstarcoder}

_{-9 byte grazie a @PascalvKooten}

import time
def p():print("\x1b[0;H")
i=0;p();s=[' '*13+'**',' '*9+'****  ','      *****    ','    **   **    ','  **      **   ','**          ***']
while True:
 for x in s:x*=5;c=i%80;print(x[-c:]+x[:-c])
 i+=1;p();time.sleep(.1)

Racchetta 295 byte

(let*((g string-append)(h substring)(d displayln)(j(λ(l)(map(λ(x)(g(h x 1)(h x 0 1)))l))))(let p((l(map(λ(x)(apply g(for/list((i 5))x)))'("            **  ""         ****   ""      *****     ""    **   **     ""  **      **    ""*          *****"))))(for((i l))(d i))(d"")(sleep .1)(p(j l))))

Ungolfed:

(define(f)
 (define (lf l)
    (map (λ (x) (string-append (substring x 1) (substring x 0 1)))
         l))
  (let loop ((l (map (λ (x) (apply string-append (for/list ((i 5)) x)) )
                     (list 
                      "            **  "
                      "         ****   "
                      "      *****     "
                      "    **   **     "
                      "  **      **    "
                      "*          *****"))))
    (for ((i l))
      (displayln i))
    (displayln "")
    (sleep 0.1)
    (loop (lf l))))

test:

(f)

Produzione:

(La visualizzazione di questo file gif è più lenta dell'output effettivo).

Python 2, 207 202 byte

Di solito sono uno sviluppatore C #, quindi potrebbe non essere ancora completamente golfato ...

import time;i=0
while 5:
    print"\033[;H"
    for l in[" "*12+"**  "," "*8+"*"*4+" "*4," "*5+"*"*5+" "*6,"   **   **"+" "*6," **     "*2,"*"+" "*10+"*"*5]:print(l[16-i:]+l*5)[:80]
    time.sleep(.1);i=(i+1)%16

C #, 327 byte

Più o meno una versione con porting della mia soluzione in Python ...

_=>{Func<string,int,string>t=(s,j)=>(s.Substring(16-j)+string.Concat(Enumerable.Repeat(s,5))).Substring(0,80);for(var i=0;;i=++i%16){Console.Clear();foreach(var q in "            **  ,        ****    ,     *****      ,   **   **      , **      **     ,*          *****".Split(','))Console.WriteLine(t(q,i));Thread.Sleep(100);}}

Perl, 110 byte

Richiede -Esenza costi aggiuntivi. Questo contiene caratteri non stampabili.

$_=unpack"B*","x?`00?";s!.{16}!$&x5 .$/!ge;y/01/ */;{say"\ec$_";select!s/(.+)(.)$/$2$1/mg,$a,$a,.1;redo}"

Crea i dati sopra usando il hexdump reversibile sotto. Esegui xxd -d > sea.plin un terminale Linux o compatibile, incolla il seguito e premi Ctrl+ d, quindi esegui perl -E "$(cat sea.pl)".

0000000: 245f 3d75 6e70 6163 6b22 422a 222c 2200  $_=unpack"B*",".
0000010: 0600 7803 e00c 6030 30c0 0f22 3b73 212e  ..x...`00..";s!.
0000020: 7b31 367d 2124 2678 3520 2e24 2f21 6765  {16}!$&x5 .$/!ge
0000030: 3b79 2f30 312f 202a 2f3b 7b73 6179 225c  ;y/01/ */;{say"\
0000040: 6563 245f 223b 7365 6c65 6374 2173 2f28  ec$_";select!s/(
0000050: 2e2b 2928 2e29 242f 2432 2431 2f6d 672c  .+)(.)$/$2$1/mg,
0000060: 2461 2c24 612c 2e31 3b72 6564 6f7d       $a,$a,.1;redo}

uso

Per una semplice copia / incolla, utilizzare quanto segue:

perl -E '$_=unpack"B*","\x00\x06\x00\x78\x03\xe0\x0c\x60\x30\x30\xc0\x0f";s!.{16}!$&x5 .$/!ge;y/01/ */;{say"\ec$_";select!s/(.+)(.)$/$2$1/mg,$a,$a,.1;redo}'

Spiegazione

Una soluzione abbastanza semplice che all'inizio memorizza l'onda come stringa, che viene modificata unpackin binario, ogni sezione è quintuplicata, 0s vengono convertiti in spazi e 1s vengono convertiti in *s. Ora abbiamo l'intera stringa, quindi entriamo in un redociclo che stampa l'intera stringa, quindi aspettiamo 0,1 secondi e per ogni riga nella stringa, spostiamo l'ultimo carattere all'inizio della stringa.

Mathematica 171 byte

L'onda stessa è un dato, quindi sto memorizzando una versione compressa dell'intera onda nel mio codice. Posso memorizzare una singola onda in modo molto più compatto poiché \fð߀ᣀ恠耟usando la sua rappresentazione binaria, ma il sovraccarico del conteggio dei caratteri di decompressione è troppo alto *.

Ecco il codice:

w=Uncompress@"1:eJxTTMoPSmNjYGAoZgESPpnFJcEBQIYCEtDSUlCglI9iqJYWqhJy+QhDtdCUUMCHGQrmIymiiA8xFMajEg02FMkXWmi+IosPAJNuSHg=";
Dynamic[Pause[.1];Column[w=StringRotateRight/@w]]   

Ecco il codice che ho usato per creare la versione compressa dei dati wave:

s={"            **  ","        ****    ","     *****      ","   **   **      "," **      **     ","*          *****"};
s//TableForm
StringRepeat[#,5]&/@s
Compress[%]

Ecco il codice che avrei preferito utilizzare per memorizzare i dati binari ripetuti compressi come questa onda:

StringJoin /@ (PadLeft[(IntegerDigits[#1, 2] & ) /@ ToCharacterCode["\fð߀ᣀ恠耟"]] /. {0 -> " ", 1 -> "*"})

Come puoi vedere, l'overhead per trasformare i dati compressi in una stringa è troppo costoso per questo particolare problema, anche se una singola onda può essere memorizzata in questo modo con 7 caratteri UTF e 15 byte.

Ecco il codice per determinare la sequenza di caratteri UTF per memorizzare una singola onda (come sopra).

StringReplace[#,{" "->"0","*"->"1"}]&/@s
ToExpression/@%
IntegerDigits/@%
FromDigits[#,2]&/@%
FromCharacterCode/@%
StringJoin@%

Rubino 269 217 189 185 byte

-28 byte grazie a @manatwork

-5 byte grazie a @ropata

Normale

p=0
loop do
  system 'clear'
  [' '*12+'**  ', ' '*8+'****    ','     *****      ','   **   **      ',' **      **     ','*          *****'].each {|i| puts ((i*5)[16-p..-1]+i)[0..79]}
  p=-~p%16
  sleep 0.1
end

golfed

p=0
b=' '
loop{system'clear'
[b*12+'**  ',b*8+'****    ',b*5+'*****'+b*6,'   **   **'+b*6,' **      **     ',"*#{b*10}*****"].map{|i|puts ((i*5)[16-p..-1]+i)[0,79]}
p=-~p%16
sleep 0.1}

HTML + JS + jQuery, 10 + 233 = 243 byte

b="            **  q        ****    q     *****      q   **   **      q **      **     q*          *****".split`q`.map(x=>x.repeat(5).split``)
setInterval(a=>$("#a").text(b.map(f=>f.join``).join`\n`)+b.map(e=>e.unshift(e.pop())),100)

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

<!-- start -->
<pre id=a>

JavaScript sposta ogni riga di 1 e cambia il testo ogni 100 ms.