Lý lịch

Mùa hè đã kết thúc ở Bắc bán cầu và rất nhiều người trong chúng ta nhớ mặt trời, bãi biển, sóng biển ... Thử thách này nhằm mục đích cổ vũ họ bằng cách nhắc nhở họ về biển.

Các thách thức

Đây là biển:

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

Biển được làm bằng 5 lần mô hình sóng này:

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

Lưu ý rằng mẫu dài 16 ký tự và biển gấp 5 lần mẫu này = 80 ký tự.

Mà bạn có thể in vào một thiết bị đầu cuối bằng dòng lệnh này:

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

Hoặc cái này:

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

(Cái thứ hai sẽ giúp bạn dễ dàng lấy được mẫu chính xác hơn)

Nhiệm vụ của bạn là hiển thị biển trong một thiết bị đầu cuối và trông giống như những con sóng đang di chuyển về phía bên phải: nó cần dịch chuyển sang phải với tốc độ 1 ký tự mỗi 100ms (= 10 lần mỗi giây). Không được in ký tự sau cột thứ 80, nhưng khi sóng ngoài cùng bên phải biến mất, một ký tự mới xuất hiện ở bên trái.
Dưới đây là một ví dụ về đầu ra:

thời gian = 0,0s

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

thời gian = 0,1s

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

thời gian = 0,2s

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

thời gian = 0,3 giây

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

thời gian = 0,4 giây

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

Tất nhiên, mỗi đầu ra nên thay thế trước đó.

Bạn có thể chạy mã này vào một thiết bị đầu cuối unix để xem nó sẽ trông như thế nào với hình ảnh động:

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

(Lưu ý rằng mã này không được chơi tốt lắm: Tôi chỉ làm cho nó đủ nhỏ gọn để thuận tiện để chạy trong một thiết bị đầu cuối.)

Tiêu chí chiến thắng

Đây là codegolf, vì vậy mã ngắn nhất trong byte thắng.

MATL , 41 40 byte

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

Chạy ví dụ:

Hoặc dùng thử tại MATL Online! (tốc độ thực tế có thể phụ thuộc vào tải máy chủ).

Làm thế nào nó hoạt động

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

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

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

<pre id=O>

HTML + CSS, 70 + 181 175 = 245 byte

Làm cho việc sử dụng text-shadow, rtlvăn bản và hoạt hình keyframe CSS.

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

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

C # 450 444 425 417 byte

399 mà không có using System.Linq;nhưng tôi chắc chắn rằng đó sẽ là gian lận ...

Chỉnh sửa: Đã lưu 25 byte nhờ @Cyoce

Chơi gôn

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

Ung dung:

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

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

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

V, 98 97 73 byte

Cảm ơn @ nmjcman101 vì đã tiết kiệm 24 byte!

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

Điều này chứa rất nhiều không thể in được, vì vậy đây là một hexdump xxd:

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

Biên tập

1. Được sử dụng y$thay vì<C-v>$y

2. Rất nhiều thay đổi

   • Thay vì sao chép từng dòng và dán chúng 4 lần, trước tiên tôi tạo sóng và sau đó sao chép toàn bộ và dán 4 lần
   • Được sử dụng {và }để lưu vài byte
   • Được sử dụng òthay vì các thanh ghi để tạo vòng lặp vô hạn (vì một số lý do tôi phải bao gồm một òở cuối để nó hoạt động)
   • cố định tĩnh *ở phía dưới

Giải thích nhỏ

Tôi đang sử dụng <alt-n>để tạo các bản sao của chuỗi. Ví dụ: <alt-5>*(trông như thế này µ5) tạo các 5bản sao *trong chế độ chèn. Điều này tôi thấy là ngắn hơn so với sao chép chuỗi và sử dụng biểu thức chính quy để thực hiện các thay thế cần thiết. Sau khi tạo một wave, tôi dán nó để tạo các wave khác. Cuối cùng, tôi lặp theo cách đệ quy bằng cách sử dụng òđể tạo vòng lặp vô hạn (với độ trễ là 100ms).

Ảnh động

Hầu hết các mã được dành riêng cho việc tạo sóng, vì vậy tôi vẫn đang cố gắng đánh gôn này. Lưu ý rằng mã này sẽ không hoạt động trên TIO vì TIO chỉ xuất đầu ra sau khi mã đã thực hiện xong. Vì vậy, đây là một gif (xin lỗi vì chất lượng thấp, tôi đã phải sử dụng một trang web để chuyển đổi .movthành a .gif, cũng là >_cái liên tục xuất hiện ở bên phải là biểu tượng Terminal trên dock của máy mac của tôi):

Hàng loạt, 424 byte

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

Một số dòng có dấu cách. Yêu cầu thiết bị đầu cuối 80 cột tiêu chuẩn. Thời gian không chính xác lắm, nhưng đó là điều tốt nhất bạn có thể làm trong Batch.

Vợt 395 374 373 367 364 351 byte

Sử dụng một thư viện bên ngoài để xóa màn hình
Chỉnh sửa: Đã lưu 21 byte bằng cách không xác định wvà nội tuyến hàm.
Edit2: Đã lưu 1 byte bằng cách xóa khoảng trắng.
Edit3: Đã lưu 6 byte bằng cách đổi tên loopthành p, cảm ơn @rnso!
Edit4: Đưa chuỗi con vào để tiết kiệm 3 byte.
Chỉnh sửa5: Xóa #lang racket, không cần thiết trong trình thông dịch.

Đã đánh gôn: 351 byte

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

Cuộn (không rõ): 272 byte

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

Ung dung:

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

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

PowerShell 3.0, 183 182 173 byte

Yêu cầu PS 3.0 cho các toán tử dịch chuyển nhị phân. Được làm mỏng thành 173 byte với sự giúp đỡ của admBorkBork !

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

Bash + coreutils, 172 148 byte

Đã lưu 24 byte nhờ @zeppelin , cảm ơn rất nhiều

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

Dòng đầu tiên giải nén mẫu sau được tạo bởi 6 sóng liên tiếp:

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

Sau đó, vòng lặp trượt một cửa sổ rộng 80 byte thông qua mẫu đó.

*> <> , 251 250 251 byte (không cạnh tranh)

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

^{Lưu ý: "H;0["được cho là có ascii 27sau [.}

Hãy thử nó ở đây! (đặt độ trễ thành 0ms)

Tôi không thể tin rằng tôi đã kết thúc thành công việc này. Điều này sử dụng Ivà Dhướng dẫn, làm tăng hoặc giảm ngăn xếp đã chọn. Điều này chứng tỏ rằng có thể thực hiện điều này một cách thuần túy> <> (trừ đi giấc ngủ) hoặc một câu trả lời cạnh tranh *> <>, mặc dù có lẽ khó thực hiện hơn nhiều.

Phiên bản thông dịch viên trực tuyến khác nhau chỉ đơn giản là để xóa đầu ra bằng cách sử dụng trả lại vận chuyển.

Đây là phi cạnh tranh bởi vì I, D, C, và Rhướng dẫn trẻ hơn những thách thức. Điều này có thể được thực hiện mà không cần những hướng dẫn đó, nhưng nó sẽ rất khó / dài.

Chỉnh sửa: Tôi thực sự đã quản lý để loại bỏ một byte, nhưng tôi cũng nhận thấy rằng tôi đã đo kích thước sai, vì vậy tôi thực sự đã đạt được một byte.

Tôi sẽ làm hết sức mình để chia nhỏ các bước và giải thích những gì đang xảy ra ở đây ...

Giải trình

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

Mục lục

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)

Khởi tạo

Ở đây chúng tôi xây dựng 6 dòng tạo sóng. Chúng ta cần lặp lại mỗi chuỗi 5 lần để có độ dài chính xác.

Chúng tôi bắt đầu với 6 trong số này, một cho mỗi dòng của sóng:

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

Và chúng ta vào vòng lặp chính sau khi khởi tạo thông qua 09..

Sao chép Stack hiện tại 4 lần

Đây là một chức năng đơn giản chỉ cần lấy stack hiện tại và sao chép nó 4 lần. Vì vậy, "a" sẽ trở thành "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

Sao chép ngăn xếp

Điều này sao chép ngăn xếp hiện tại, nối thêm bản sao vào ngăn xếp hiện tại.

Thiết lập

Sẽ bỏ qua dòng đầu tiên <và đảo ngược dòng đầu tiên để trở thành l:&0vthứ tự nó được thực hiện sau khi <thay đổi hướng của 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

Từ đây trở đi, chiều dài sẽ được gọi là nvà 0như i.

Vòng

>                        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

Dọn dẹp

>                        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

Vòng lặp chính

Đây là nơi mã chạy mãi mãi, liên tục vẽ lại các sóng trong khoảng 100ms ngủ.

Thiết lập

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 

Vòng

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

PHP, 128 byte

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

Không thể hoạt hình nhiều hơn một dòng, nhưng nó cuộn.
Thêm ,0vào mảng cho một dòng trống giữa các lần lặp. Chạy với -r.

Toán học, 213 byte

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

Tôi không thấy bất kỳ cách nào để chơi mô hình sóng trong Mathicala ngoài việc bắt đầu với một danh sách các chuỗi cho mỗi dòng. Tôi khởi tạo iđể được 0và lên lịch một nhiệm vụ để tăng nó mỗi 0.1giây. Tôi Dynamicđồng minh hiển thị kết quả sau:

1. StringRepeat mỗi dòng 5 lần.
2. Chuyển đổi mỗi dòng thành một danh sách của nó Characters.
3. RotateRightmỗi danh sách các nhân vật bởi i.
4. Hiển thị mảng kết quả của các ký tự là a Grid.

C (unix), 231 191 byte

Điều này sẽ chỉ hoạt động trên môi trường unix. Ngoài ra, xin vui lòng thực tế rằng giấc ngủ chỉ chấp nhận số nguyên ... vì vậy nó thực sự trì hoãn 1 giây giữa các khung.

Phiên bản bị đánh cắp:

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

Phiên bản chơi gôn:

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

Javascript (ES6), 152 147 145 byte

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

Perl 6, 140 138 137 123 120 byte

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

Giải pháp cũ:

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

Python 3, 240 239 230 byte

_{-1 byte nhờ @redstarcoder}

_{-9 byte nhờ @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)

Vợt 295 byte

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

Ung dung:

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

Kiểm tra:

(f)

Đầu ra:

(Hiển thị tệp gif này chậm hơn so với đầu ra thực tế).

Python 2, 207 202 byte

Thông thường tôi là nhà phát triển C #, vì vậy điều này có thể chưa hoàn toàn được chơi gôn ...

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

C #, 327 byte

Ít nhiều phiên bản được chuyển của giải pháp của tôi trong Python ...

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

Perl, 110 byte

Yêu cầu -Ekhông có chi phí thêm. Điều này chứa các ký tự không thể in.

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

Tạo dữ liệu trên bằng cách sử dụng hexdump có thể đảo ngược dưới đây. Chạy xxd -d > sea.pltrong một thiết bị đầu cuối linux hoặc tương thích, dán bên dưới và nhấn Ctrl+ d, sau đó chạy 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}

Sử dụng

Để dễ dàng sao chép / dán, vui lòng sử dụng như sau:

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

Giải trình

Một giải pháp khá đơn giản lưu trữ sóng dưới dạng một chuỗi ở đầu, được unpackchuyển thành nhị phân, mỗi phần được lặp lại, 0s được chuyển đổi thành khoảng trắng và 1s được chuyển đổi thành *s. Bây giờ chúng ta có toàn bộ chuỗi, vì vậy chúng ta nhập một redovòng lặp in ra toàn bộ chuỗi, sau đó chúng ta đợi trong 1 giây và với mỗi dòng trong chuỗi, chúng ta di chuyển ký tự cuối cùng đến đầu chuỗi.

Toán học 171 byte

Bản thân sóng là dữ liệu, vì vậy tôi đang lưu trữ một phiên bản nén của toàn bộ sóng trong mã của mình. Tôi có thể lưu trữ một sóng đơn gọn hơn nhiều khi \fð߀ᣀ恠耟sử dụng biểu diễn nhị phân của nó, nhưng tổng số ký tự của việc giải nén quá cao *.

Đây là mã:

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

Đây là mã tôi đã sử dụng để tạo phiên bản nén của dữ liệu sóng:

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

Đây là mã tôi muốn sử dụng để lưu trữ dữ liệu nhị phân lặp lại được nén như làn sóng này:

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

Như bạn có thể thấy, chi phí để biến dữ liệu nén trở lại thành một chuỗi quá tốn kém cho vấn đề cụ thể này, mặc dù một sóng có thể được lưu trữ theo cách này với 7 ký tự UTF và 15 byte.

Đây là mã để xác định chuỗi ký tự UTF để lưu trữ một sóng đơn như trên).

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

Ruby 269 217 189 185 byte

-28 Byte nhờ @manatwork

-5 byte nhờ vào @ropata

Bình thường

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

Chơi gôn

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

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

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

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

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

JavaScript chỉ thay đổi mỗi hàng 1 và thay đổi văn bản cứ sau 100 ms.