Фон

Влітку північна півкуля закінчилася, і багато з нас сумують за сонцем, пляжами, хвилями океану ... Цей виклик має на меті підбадьорити їх, нагадуючи їм море.

Змагання

Ось море:

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

Море складається в 5 разів більше цієї хвильової картини:

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

Зауважте, що візерунок має 16 символів, а море - у 5 разів більше за цей візерунок = 80 символів.

Який ви можете надрукувати в терміналі за допомогою цього командного рядка:

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

Або цей:

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

(Другий повинен полегшити точну схему)

Ваше завдання - відобразити море в терміналі і зробити так, щоб хвилі рухалися вправо: йому потрібно зрушувати вправо зі швидкістю 1 символ кожні 100 мс (= 10 разів на кожну секунду). Після 80-го стовпця не слід друкувати жодного символу, але, як зникає права права хвиля, зліва з’являється нова.
Ось приклад результату:

час = 0,0с

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

час = 0,1с

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

час = 0,2с

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

час = 0,3с

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

час = 0,4с

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

Звичайно, кожен вихід повинен замінити попередній.

Ви можете запустити цей код у термінал unix, щоб побачити, як він повинен виглядати з анімацією:

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

(Зауважте, що цей код не дуже добре гольф: я просто зробив його досить компактним, щоб було зручно працювати в терміналі.)

Критерій виграшу

Це codegolf, тому найкоротший код у байті виграє.

MATL , 41 40 байт

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

Приклад виконання:

Або спробуйте в MATL Online! (фактична швидкість може залежати від завантаження сервера).

Як це працює

`                    % 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 байт

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 байт

Використовує text-shadow, rtlтекст і 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 байт

399 без, using System.Linq;але я впевнений, що це було б обманом ...

Редагувати: Збережено 25 байт завдяки @Cyoce

Гольф:

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

Безголівки:

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 байт

Дякуємо @ nmjcman101 за економію 24 байтів!

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

Тут міститься багато недрукованих матеріалів, тому ось 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...

Редагувати

1. Використовується y$замість<C-v>$y

2. Дуже багато змін

   • Замість того, щоб копіювати кожен рядок і вставляти їх 4 рази, я спочатку генерую хвилю, а потім копіюю всю річ і вставляю її 4 рази
   • Використовується {і }для економії кількох байт
   • Використовується òзамість регістрів для створення нескінченного циклу (чомусь я повинен включити a òв кінці, щоб він працював)
   • зафіксували статику *внизу

Міні-пояснення

Я використовую <alt-n>для створення копій рядків. Наприклад, <alt-5>*(це виглядає так µ5) робить 5копії *в режимі вставки. Це я виявив коротше, ніж копіювання рядка та використання регулярного виразу, щоб зробити необхідні заміни. Після створення однієї хвилі я вставляю її для створення інших хвиль. Нарешті, я циклічно рекурсивно використовую òдля створення нескінченного циклу (із затримкою 100ms).

Gif

Більша частина коду присвячена створенню хвилі, тому я все ще намагаюся займатися цим. Зауважте, що цей код не працюватиме в TIO, оскільки TIO видає висновок лише після завершення виконання коду. Отож ось подарунок (вибачте за низьку якість, мені довелося скористатися веб-сайтом для конвертації в .movа .gif, також те, >_що постійно з'являється вгорі - це значок термінала на доці мого Mac):

Пакетна, 424 байт

@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

У деяких лініях є пробіли. Потрібен стандартний 80-стовпний термінал. Терміни не дуже точні, але це найкраще, що можна зробити в Batch.

Ракетка 395 374 373 367 364 351 байт

Використовує зовнішню бібліотеку для очищення екрана
Правка: Збережено 21 байт, не визначаючи wта не вкладаючи функції.
Edit2: збережено 1 байт, видаливши пробіл.
Edit3: Збережено 6 байт шляхом перейменування loopв p, завдяки @rnso!
Edit4: Введення підрядків у нехай зберігає 3 байти.
Edit5: Видаліть #lang racket, що не потрібно в перекладачі.

Гольф: 351 байт

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

Прокрутка (не ясно): 272 байти

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

Безголівки:

#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 байт

Потрібен PS 3.0 для операторів двійкового зсуву. Зменшено до 173 байт за допомогою 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 байт

24 байти збережено завдяки @zeppelin , багато спасибі

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

Перший рядок розгортає наступну схему, зроблену з 6 послідовних хвиль:

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

Потім цикл просуває вікно на 80 байт по цій схемі.

*> <> , 251 250 251 байт (не конкуруючий)

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

^{Примітка: після закінчення "H;0["передбачається мати ascii .27[}

Спробуйте тут! (встановити затримку в 0 мс)

Я не можу повірити, що я закінчила це успішно. Тут використовуються Iта Dінструкції, які збільшують або зменшують вибраний стек. Це свідчить про те, що це, ймовірно, можливо зробити чистим <<(мінус сном) або конкурентною *> <> відповіддю, хоча це, мабуть, набагато складніше.

Версія онлайн-перекладача відрізняється просто очищенням результатів за допомогою повернення каретки.

Це не конкуруюче , так як I, D, Cі Rінструкція молодше виклику. Це, мабуть, можна обійтися без цих інструкцій, але це було б дуже важко / довго.

Редагувати: мені фактично вдалося видалити байт, але я також помітив, що я неправильно виміряв розмір, тому я фактично набрав байт.

Я зроблю все можливе, щоб розбити кроки та пояснити, що тут відбувається ...

Пояснення

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

Зміст

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)

Ініціалізація

Тут ми будуємо 6 ліній, які будують хвилі. Нам потрібно повторити кожен рядок 5 разів, щоб бути правильної довжини.

Почнемо з 6 із них, по одному для кожної лінії хвилі:

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

І ми вводимо основний цикл після ініціалізації через 09..

Скопіюйте поточний стек 4 рази

Це проста функція, яка просто приймає поточний стек і копіює його 4 рази. Так "а" стане "ааааа".

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

Скопіювати стек

Це копіює поточний стек, додаючи копію до поточного стеку.

Налаштування

Переходимо до початкового <та інвертуємо перший рядок, щоб він став l:&0vтаким, як це буде виконуватися після <зміни напрямку 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

З цього моменту довжина буде називатися nі 0як i.

Петля

>                        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

Прибирати

>                        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

Основна петля

Ось, де код працює назавжди, постійно перемальовуючи хвилі між 100 м спить.

Налаштування

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 

Петля

>                          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 байт

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

Неможливо анімувати більше одного рядка, але він прокручується.
Додайте ,0до масиву порожній рядок між ітераціями. Бігайте з -r.

Математика, 213 байт

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

Я не бачу жодного способу гри в гольф хвильового малюнка в Mathematica, окрім як тільки починати зі списку рядків для кожного рядка. Я ініціалізую, iщоб бути, 0і планую завдання, щоб збільшувати його кожні 0.1секунди. Я Dynamicсоюзую результат наступного:

1. StringRepeat кожен рядок 5 разів.
2. Перетворіть кожен рядок у його список Characters.
3. RotateRightкожен список символів від i.
4. Показати отриманий масив символів як Grid.

C (unix), 231 191 байт

Це буде працювати тільки в unix середовищах. Крім того, вибачте, що сон приймає лише цілі числа ... тому він фактично затримує 1 секунду між кадрами.

Безгольова версія:

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

Версія для гольфу:

#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 байт

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 байт

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

Старі рішення:

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 байт

_{-1 байт завдяки @redstarcoder}

_{-9 байт завдяки @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)

Ракетка 295 байт

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

Безголівки:

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

Тестування:

(f)

Вихід:

(Відображення цього файлу gif повільніше, ніж фактичний вихід).

Python 2, 207 202 байт

Зазвичай я розробник C #, тому це ще не може бути повністю гольф ...

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 байт

Більш-менш перенесена версія мого рішення в 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 байт

Вимагає -Eбез зайвих витрат. Тут містяться символи, що не друкуються.

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

Створіть наведені вище дані, використовуючи нижній оборотний шестигранник. Запустіть xxd -d > sea.plв Linux або сумісний термінал, вставте нижче та натисніть Ctrl+ d, а потім запустіть 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}

Використання

Для легкої копіювання / вклеювання, будь ласка, скористайтеся нижче:

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

Пояснення

Досить просте рішення, яке зберігає хвилю у вигляді рядка на початку, яке піддається unpackбінарному, кожен розділ в'язаний, 0s перетворюються на пробіли, а 1s перетворюються на *s. Тепер у нас є цілий рядок, тому ми вводимо redoцикл, який виводить всю рядку, потім чекаємо .1 секунди і для кожного рядка в рядку переміщуємо останній символ на початок рядка.

Математика 171 байт

Сама хвиля - це дані, тому я зберігаю стиснуту версію всієї хвилі у своєму коді. Я можу зберігати одну хвилю набагато компактніше, оскільки \fð߀ᣀ恠耟використовую її двійкове представлення, але кількість символів накладних витрат на стискання занадто велика *.

Ось код:

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

Ось код, який я використав для створення стислої версії хвильових даних:

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

Ось код, який я волів би використовувати для зберігання стислих повторюваних двійкових даних, як ця хвиля:

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

Як бачимо, накладні витрати для повернення стислих даних назад у рядок є надто дорогими для цієї конкретної проблеми, хоча одна хвиля може зберігатися таким чином із 7 символами UTF та 15 байтами.

Тут був код для визначення послідовності символів UTF для зберігання однієї хвилі (s, як вище).

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

Рубін 269 217 189 185 байт

-28 байт завдяки @manatwork

-5 байт завдяки @ropata

Нормальний

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

Гольф

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 байти

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 просто зміщує кожен рядок на 1 і змінює текст кожні 100 мс.