พื้นหลัง

ฤดูร้อนจบไปแล้วในซีกโลกเหนือและพวกเราหลายคนคิดถึงแสงอาทิตย์ชายหาดคลื่นทะเล ... ความท้าทายนี้มุ่งหวังที่จะเชียร์พวกเขาด้วยการเตือนพวกเขาถึงทะเล

ความท้าทาย

นี่คือทะเล:

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

ทะเลทำจาก 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 ตัวอักษรต่อ 100ms (= 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 ดังนั้นรหัสที่สั้นที่สุดในการชนะ byte

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

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ò

สิ่งนี้มี unprintables จำนวนมากดังนั้นนี่คือ 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 òท้ายเพื่อให้ทำงาน)
   • คง*ที่ด้านล่างคงที่

Mini-คำอธิบาย

ฉันใช้<alt-n>เพื่อสร้างสำเนาของสตริง ตัวอย่างเช่น<alt-5>*(ดูเหมือนว่าµ5) ทำ5สำเนา*ในโหมดแทรก ฉันพบว่าสั้นกว่าการคัดลอกสตริงและใช้ regex เพื่อทำการแทนที่ที่จำเป็น หลังจากสร้างคลื่นหนึ่งฉันวางมันเพื่อสร้างคลื่นอื่น ในที่สุดฉันวนซ้ำใช้òเพื่อสร้างวงวนไม่สิ้นสุด (ด้วยความล่าช้า100ms)

Gif

รหัสส่วนใหญ่มีความมุ่งมั่นในการสร้างคลื่นดังนั้นฉันยังคงพยายามตีกอล์ฟนี้ โปรดทราบว่ารหัสนี้จะไม่ทำงานบน TIO เนื่องจาก TIO จะส่งออกเฉพาะผลลัพธ์หลังจากที่รหัสทำงานเสร็จสิ้น ดังนั้นนี่คือ gif (ขออภัยสำหรับคุณภาพต่ำฉันต้องใช้เว็บไซต์เพื่อแปลง a .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 คอลัมน์มาตรฐาน เวลาไม่แม่นยำมาก แต่เป็นวิธีที่ดีที่สุดที่คุณสามารถทำได้ในแบทช์

แร็กเก็ต395 374 373 367 364 351 ไบต์

ใช้ไลบรารีภายนอกสำหรับการล้างหน้าจอ
แก้ไข: บันทึกแล้ว 21 ไบต์โดยไม่กำหนดwและฝังฟังก์ชัน
แก้ไข 2: บันทึก 1 ไบต์โดยลบช่องว่าง
แก้ไข 3: บันทึก 6 ไบต์โดยเปลี่ยนชื่อloopเป็นpขอบคุณ @rnso!
Edit4: การใส่สตริงย่อยในการอนุญาตให้บันทึก 3 ไบต์
แก้ไข 5: ลบ#lang racketซึ่งไม่จำเป็นในล่าม

Golfed: 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คำแนะนำซึ่งจะเพิ่มหรือลดสแต็กที่เลือก นี่แสดงให้เห็นว่าอาจเป็นไปได้ที่จะทำสิ่งนี้ด้วยความบริสุทธิ์> <> (ลบด้วยการนอนหลับ) หรือคำตอบแบบ competetive *> <> แม้ว่าอาจจะทำได้ยากกว่ามาก

รุ่นล่ามออนไลน์นั้นแตกต่างกันเพียงเพื่อล้างเอาต์พุตโดยใช้การคืนค่าขนส่ง

นี่คือที่ไม่ใช่การแข่งขันเพราะ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

คัดลอกสแต็ก

สิ่งนี้จะคัดลอกสแต็กปัจจุบันผนวกการคัดลอกไปยังสแต็กปัจจุบัน

ติดตั้ง

จะข้ามเริ่มต้น<และกลับบรรทัดแรกเพื่อให้เป็นไป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และเป็น0i

ห่วง

>                        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. RotateRightiรายการของตัวอักษรแต่ละ
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);
    }
}

รุ่น Golfed:

#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ในลินุกซ์หรือขั้วเข้ากันได้วางด้านล่างและกดCtrl+ วิ่งแล้วdperl -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 -> "*"})

อย่างที่คุณเห็นค่าโสหุ้ยในการแปลงข้อมูลที่บีบอัดกลับมาเป็นสตริงนั้นแพงเกินไปสำหรับปัญหาเฉพาะนี้แม้ว่าจะสามารถจัดเก็บคลื่นเดียวด้วยวิธีนี้ด้วยอักขระ UTF 7 ตัวและ 15 ไบต์

นี่คือรหัสเพื่อกำหนดลำดับอักขระ UTF เพื่อเก็บ wave เดียว (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 มิลลิวินาที