背景

北半球的夏天已经过去了，我们很多人想念阳光，海滩，海浪……这一挑战的目的是通过使他们联想起大海来振作起来。

挑战

这是大海：

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

海洋是这种波形的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"'

（第二个应该使您更容易获得确切的模式）

您的任务是在终端中显示大海，并使波浪看起来像向右移动：它需要以每100ms 1个字符的速度向右移动（=每秒钟10次）。在第80列之后，不应再打印任何字符，但是随着最右边的波形消失，左侧将出现一个新的波形。
这是输出示例：

时间= 0.0秒

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

时间= 0.1秒

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

时间= 0.2秒

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

时间= 0.3秒

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

时间= 0.4s

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

当然，每个输出都应替换先前的输出。

您可以将此代码运行到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 + 181175 = 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;但我相信那会骗人...

编辑：由于@Cyoce，节省了25个字节

打高尔夫球：

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十六进制转储：

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次的方式，而是先生成wave，然后复制整个内容并将其粘贴4次
   • 用于{并}节省一些字节
   • 用于ò代替寄存器来创建无限循环（出于某种原因，我必须ò在末尾添加一个才能使其工作）
   • 将静电固定*在底部

迷你说明

我<alt-n>用来创建字符串的副本。例如，<alt-5>*（看起来像µ5）在插入模式下制作的5副本*。我发现这比复制字符串和使用正则表达式进行必要的替换要短。创建一个波形后，我将其粘贴以创建其他波形。最后，我使用递归循环ò创建无限循环（延迟为100ms）。

Gif

大部分代码都专门用于创建波浪，因此我仍在尝试。请注意，此代码不适用于TIO，因为TIO仅在代码执行完毕后才输出输出。因此，这是一个gif（对不起，质量很低，我不得不使用一个网站将a转换.mov为a .gif，同时>_在右边不断弹出的是Mac基座上的Terminal图标）：

批处理，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字节

使用外部库进行屏幕清除
编辑：未定义w和内联函数，节省了21个字节。
Edit2：通过删除空格节省了1个字节。
Edit3：通过重命名loop为节省了6个字节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]]]

取消高尔夫：

#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。在AdmBorkBork的帮助下减少到173个字节！

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

击+的coreutils，172个 148字节的

@zeppelin节省了24个字节，非常感谢

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后[。}

在这里尝试！（将延迟设置为0ms）

我不敢相信我最终成功做到了这一点。这使用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次。因此，“ a”将变为“ 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

复制堆栈

这将复制当前堆栈，并将副本附加到当前堆栈。

设定

跳过首字母<并反转第一行，以使其成为更改IP方向l:&0v后执行的顺序<。

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

主循环

这是代码永远运行的地方，在100ms睡眠之间不断重绘波形。

设定

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环境。另外，请原谅睡眠只接受整数的事实，因此它实际上在帧之间延迟了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}'

说明

一个相当简单的解决方案，将wave作为字符串存储在开头，将其unpack编辑为二进制，将每个部分都进行五倍复制，将0s转换为空格，将1s转换为*s。现在我们有了整个字符串，因此我们进入一个redo循环，打印出整个字符串，然后等待0.1秒，对于字符串中的每一行，我们将最后一个字符移到字符串的开头。

Mathematica 171字节

wave本身就是数据，因此我在代码中存储了整个wave的压缩版本。我可以像\fð߀ᣀ恠耟使用二进制表示形式一样紧凑地存储单个wave ，但是解压缩的字符计数开销太高*。

这是代码：

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

这是我用来创建wave数据的压缩版本的代码：

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

这是我更喜欢用来存储压缩的重复二进制数据的代码，例如以下波形：

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

如您所见，对于此特定问题，将压缩后的数据转换为字符串的开销太高了，尽管可以用7个UTF字符和15个字节来存储单个wave。

这是确定UTF字符序列以存储单个wave（如上）的代码。

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 ms更改文本。