Antecedentes

El verano ha terminado en el hemisferio norte, y muchos de nosotros extrañamos el sol, las playas, las olas del océano ... Este desafío tiene como objetivo animarlos recordándoles el mar.

El reto

Aquí está el mar:

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

El mar está hecho de 5 veces este patrón de onda:

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

Tenga en cuenta que el patrón tiene 16 caracteres de longitud y el mar tiene 5 veces este patrón = 80 caracteres de longitud.

Que puede imprimir en un terminal usando esta línea de comando:

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

O este :

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

(El segundo debería facilitarle obtener el patrón exacto)

Su tarea es mostrar el mar en una terminal y hacer que parezca que las olas se mueven hacia la derecha: debe desplazarse hacia la derecha a una velocidad de 1 carácter cada 100 ms (= 10 veces cada segundo). No se debe imprimir ningún carácter después de la columna 80, pero a medida que desaparece la onda más a la derecha, aparece una nueva a la izquierda.
Aquí hay un ejemplo de salida:

tiempo = 0.0s

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

tiempo = 0.1s

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

tiempo = 0.2s

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

tiempo = 0.3s

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

tiempo = 0.4s

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

Por supuesto, cada salida debe reemplazar a la anterior.

Puede ejecutar este código en un terminal Unix para ver cómo debería verse con la animación:

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}'

(Tenga en cuenta que este código no está muy bien desarrollado: solo lo hice lo suficientemente compacto como para que sea conveniente ejecutarlo en una terminal).

Criterio ganador

Esto es codegolf, por lo que gana el código más corto en bytes.

MATL , 41 40 bytes

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

Ejemplo de ejecución:

¡O pruébalo en MATL Online! (la velocidad real puede depender de la carga del servidor).

Cómo funciona

`                    % 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 bytes

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 bytes

Hace uso de text-shadow, rtlanimaciones de texto y de fotogramas clave 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 Bytes

399 sin using System.Linq;pero estoy seguro de que sería trampa ...

Editar: 25 bytes guardados gracias a @Cyoce

Golfizado:

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

Sin golf:

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 bytes

¡Gracias a @ nmjcman101 por guardar 24 bytes!

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

Esto contiene muchos no imprimibles, así que aquí hay un xxd hexdump:

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

Editar

1. Usado en y$lugar de<C-v>$y

2. Muchos cambios

   • En lugar de copiar cada línea y pegarlas 4 veces, primero genero la onda y luego copio todo y lo pego 4 veces
   • Usado {y }para guardar algunos bytes
   • Se usa en òlugar de registros para crear el bucle infinito (por alguna razón tengo que incluir un òal final para que funcione)
   • arregló la estática *en la parte inferior

Mini-Explicación

Estoy usando <alt-n>para crear copias de cadenas. Por ejemplo, <alt-5>*(esto parece µ5) hace 5copias de *en modo de inserción. Esto me pareció más corto que copiar la cadena y usar una expresión regular para hacer los reemplazos necesarios. Después de crear una ola, la pego para crear las otras olas. Finalmente, realizo un ciclo recursivo òpara crear el ciclo infinito (con un retraso de 100ms).

GIF

La mayor parte del código está dedicado a crear la ola, por lo que todavía estoy intentando jugar golf. Tenga en cuenta que este código no funcionará en TIO ya que TIO solo genera la salida una vez que el código ha finalizado la ejecución. Así que aquí hay un gif (perdón por la baja calidad, tuve que usar un sitio web para convertir un .mova .gif, también el >_que sigue apareciendo a la derecha es el ícono de Terminal en el muelle de mi Mac):

Lote, 424 bytes.

@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

Algunas líneas tienen espacios finales. Requiere un terminal estándar de 80 columnas. El momento no es muy preciso, pero es lo mejor que puedes hacer en Batch.

Raqueta 395 374 373 367 364 351 bytes

Utiliza una biblioteca externa para borrar la pantalla
Editar: guardado 21 bytes al no definir we incluir la función.
Edit2: guardado 1 byte eliminando un espacio.
Edit3: guardado 6 bytes cambiando el nombre loopa p, gracias @rnso!
Edit4: colocando la subcadena en dejar de guardar 3 bytes.
Edit5: Eliminar #lang racket, que no es necesario en el intérprete.

Golfizado: 351 bytes

[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]]]

Desplazamiento (sin borrar): 272 bytes

[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]]]

Sin golf:

#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 bytes

Requiere PS 3.0 para operadores de desplazamiento binario. ¡Reducido a 173 bytes con la ayuda de 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 bytes

24 bytes guardados gracias a @zeppelin , muchas gracias

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

La primera línea descomprime el siguiente patrón formado por 6 ondas consecutivas:

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

Luego, el bucle desliza una ventana de 80 bytes de ancho a través de ese patrón.

*> <> , 251 250 251 bytes (no competitivos)

" **             "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["se supone que tiene ascii 27después [.}

Pruébalo aquí! (establecer retraso a 0 ms)

No puedo creer que terminé haciendo esto con éxito. Utiliza las instrucciones Iy D, que aumentan o disminuyen la pila seleccionada. Esto demuestra que probablemente sea posible hacer esto en puro> <> (menos el sueño) o una respuesta competitiva *> <>, aunque probablemente sea mucho más difícil de hacer.

La versión del intérprete en línea es diferente simplemente para borrar la salida utilizando un retorno de carro.

Esto es porque no compitiendo los I, D, C, y Rlas instrucciones son más jóvenes que el reto. Probablemente esto sea posible sin esas instrucciones, pero sería muy difícil / largo.

Editar: en realidad logré eliminar un byte, pero también noté que medí el tamaño incorrectamente, así que en realidad gané un byte.

Haré todo lo posible para desglosar los pasos y explicar lo que está sucediendo aquí ...

Explicación

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

Tabla de contenido

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)

Inicialización

Aquí construimos las 6 líneas que construyen las olas. Necesitamos repetir cada cuerda 5 veces para tener la longitud correcta.

Comenzamos con 6 de estos, uno para cada línea de la onda:

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

Y entramos en el bucle principal después de la inicialización 09..

Copiar pila actual 4 veces

Esta es una función simple que simplemente toma la pila actual y la copia 4 veces. Entonces "a" se convertiría en "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

Copiar pila

Esto copia la pila actual, agregando la copia a la pila actual.

Preparar

Saltará la inicial <e invertirá la primera línea para que se convierta, l:&0vya que es el orden en que se ejecuta después de que <cambia la dirección de la 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

De aquí en adelante, la longitud se denominará como ny 0como i.

Lazo

>                        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

Limpiar

>                        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

Bucle principal

Aquí es donde el código se ejecuta para siempre, redibujando constantemente las olas entre 100 ms duerme.

Preparar

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 

Lazo

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

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];

No puede animar más de una línea, pero se desplaza.
Agregue ,0a la matriz una línea vacía entre iteraciones. Corre con -r.

Mathematica, 213 bytes

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

No veo ninguna forma de jugar golf en el patrón de onda en Mathematica que no sea simplemente comenzar con una lista de cadenas para cada línea. Inicializo iser 0y programo una tarea para incrementarla cada 0.1segundo. Me Dynamicaliado mostrará el resultado de lo siguiente:

1. StringRepeat cada línea 5 veces.
2. Convierta cada línea en una lista de sus Characters.
3. RotateRightcada lista de caracteres por i.
4. Mostrar la matriz resultante de caracteres como a Grid.

C (unix), 231 191 bytes

Esto solo funcionará en entornos Unix. Además, disculpe el hecho de que el sueño solo acepta números enteros ... por lo que en realidad demora 1 segundo entre fotogramas.

Versión sin golf:

#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);
    }
}

Versión de golf:

#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 bytes

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 bytes

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

Viejas soluciones:

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 bytes

_{-1 byte gracias a @redstarcoder}

_{-9 bytes gracias 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)

Raqueta 295 bytes

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

Sin golf:

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

Pruebas:

(f)

Salida:

(Esta visualización del archivo gif es más lenta que la salida real).

Python 2, 207 202 bytes

Por lo general, soy un desarrollador de C #, por lo que es posible que todavía no esté completamente desarrollado ...

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 bytes

Más o menos una versión portada de mi solución en 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 bytes

Requiere -Esin costo adicional. Este contiene caracteres no imprimibles.

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

Cree los datos anteriores utilizando el siguiente hexdump reversible. Ejecutar xxd -d > sea.plen un linux o terminal compatible, pegue el siguiente y presione Ctrl+ d, luego ejecute 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

Para copiar / pegar fácilmente, utilice lo siguiente:

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}'

Explicación

Una solución bastante sencilla que almacena la onda como una cadena al principio, que se unpackedita en binario, cada sección se quintuplica, los 0s se convierten en espacios y 1s se convierten en *s. Ahora tenemos la cadena completa, por lo que ingresamos un redobucle que imprime la cadena completa, luego esperamos por .1 segundos y para cada línea de la cadena, movemos el último carácter al comienzo de la cadena.

Mathematica 171 Bytes

La onda en sí es información, por lo que estoy almacenando una versión comprimida de toda la onda en mi código. Puedo almacenar una sola onda de forma mucho más compacta ya \fð߀ᣀ恠耟que utilizo su representación binaria, pero la sobrecarga de conteo de caracteres de descompresión es demasiado alta *.

Aquí está el código:

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

Aquí está el código que usé para crear la versión comprimida de los datos de la onda:

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

Aquí está el código que hubiera preferido usar para almacenar datos binarios repetidos comprimidos como esta onda:

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

Como puede ver, la sobrecarga para volver a convertir los datos comprimidos en una cadena es demasiado costosa para este problema en particular, aunque una sola onda se puede almacenar de esta manera con 7 caracteres UTF y 15 bytes.

Aquí estaba el código para determinar la secuencia de caracteres UTF para almacenar una sola onda (s como arriba).

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

Rubí 269 217 189 185 Bytes

-28 Bytes gracias a @manatwork

-5 Bytes gracias a @ropata

Normal

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 bytes

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>

El JavaScript simplemente cambia cada fila por 1 y cambia el texto cada 100 ms.