Фон

Лето в Северном полушарии уже позади, и многие из нас скучают по солнцу, пляжам, волнам океана ... Задача состоит в том, чтобы взбодрить их, напомнив им о море.

Соревнование

Вот море:

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

Море состоит из 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

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

Спасибо @ 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 раза
   • Используется {и }для сохранения нескольких байтов
   • Используется òвместо регистров для создания бесконечного цикла (по некоторым причинам я должен включить òв конце, чтобы он работал)
   • исправил статичность *внизу

Мини-Разъяснение

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

Gif

Большая часть кода посвящена созданию волны, поэтому я все еще пытаюсь сыграть в эту игру. Обратите внимание, что этот код не будет работать на TIO, поскольку TIO выводит выходные данные только после того, как код завершит выполнение. Итак, вот gif (извините за низкое качество, мне пришлось использовать веб-сайт для преобразования .movв a .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-колоночный терминал. Время не очень точное, но это лучшее, что вы можете сделать в пакетном режиме.

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

Использует внешнюю библиотеку для очистки экрана.
Редактировать: Сохранено 21 байт, не определяя wи не вставляя функцию.
Edit2: 1 байт сохранен путем удаления пробела.
Edit3: Сохраненный 6 байт путем переименования loopв p, благодаря @rnso!
Edit4: положить подстроку в let, сохраняющую 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]]]

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

Требуется 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.

Mathematica, 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. Кроме того, прошу прощения за тот факт, что 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);
    }
}

Гольф версия:

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

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

Тестирование:

(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}"

Создайте вышеуказанные данные, используя приведенную ниже обратимую hexdump. Запустите 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цикл, который печатает всю строку, затем мы ждем 0,1 секунды и для каждой строки в строке мы перемещаем последний символ в начало строки.

Mathematica 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

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

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