Latar Belakang

Musim panas telah berakhir di belahan bumi utara, dan banyak dari kita merindukan matahari, pantai, ombak lautan ... Tantangan ini bertujuan menyemangati mereka dengan mengingatkan mereka pada laut.

Tantangan

Inilah laut:

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

Lautan terbuat dari 5 kali pola gelombang ini:

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

Perhatikan bahwa polanya adalah 16 karakter, dan laut adalah 5 kali polanya = 80 karakter.

Yang dapat Anda cetak ke terminal menggunakan baris perintah ini:

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

Atau yang ini:

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

(Yang kedua harus memudahkan Anda untuk mendapatkan pola yang tepat)

Tugas Anda adalah menampilkan laut di terminal, dan menjadikannya seperti ombak bergerak ke kanan: ia perlu bergeser ke kanan dengan kecepatan 1 karakter masing-masing 100 ms (= 10 kali setiap detik). Tidak ada karakter yang harus dicetak setelah kolom ke-80, tetapi ketika gelombang paling kanan menghilang, yang baru muncul di sebelah kiri.
Ini adalah contoh dari output:

waktu = 0,0s

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

waktu = 0,1s

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

waktu = 0.2s

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

waktu = 0,3 detik

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

waktu = 0,4 dtk

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

Tentu saja, setiap output harus menggantikan yang sebelumnya.

Anda dapat menjalankan kode ini ke terminal unix untuk melihat bagaimana tampilannya dengan animasi:

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

(Perhatikan bahwa kode ini tidak golf dengan sangat baik: Saya baru saja membuatnya cukup ringkas untuk nyaman dijalankan di terminal.)

Kriteria menang

Ini codegolf, jadi kode terpendek dalam byte menang.

MATL , 41 40 byte

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

Contoh dijalankan:

Atau coba di MATL Online! (kecepatan aktual mungkin tergantung pada beban server).

Bagaimana itu bekerja

`                    % 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

Merek penggunaan text-shadow, rtlteks dan CSS keyframe animasi.

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 Bytes

399 tanpa using System.Linq;tapi saya yakin itu akan curang ...

Sunting: Disimpan 25 Bytes berkat @Cyoce

Golf:

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

Tidak Disatukan:

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

Terima kasih kepada @ nmjcman101 untuk menghemat 24 byte!

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

Ini mengandung banyak unsintables, jadi inilah xdd 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...

Sunting

1. Digunakan y$sebagai ganti<C-v>$y

2. Banyak perubahan

   • Alih-alih menyalin setiap baris dan menempelkannya 4 kali, saya pertama-tama menghasilkan gelombang dan kemudian menyalin semuanya dan menempelnya 4 kali
   • Digunakan {dan }untuk menyimpan beberapa byte
   • Digunakan òalih-alih register untuk membuat loop tak terbatas (untuk beberapa alasan saya harus menyertakan a òpada akhirnya agar bisa bekerja)
   • memperbaiki statis *di bagian bawah

Mini-Penjelasan

saya menggunakan <alt-n> untuk membuat salinan string. Misalnya, <alt-5>*(sepertinya ini µ5) membuat 5salinan *dalam mode sisipkan. Ini saya temukan lebih pendek daripada menyalin string dan menggunakan regex untuk melakukan penggantian yang diperlukan. Setelah membuat satu gelombang, saya tempel untuk membuat gelombang lainnya. Akhirnya, saya menggunakan loop secara rekursif òuntuk membuat infinite loop (dengan penundaan 100ms).

Gif

Sebagian besar kode didedikasikan untuk menciptakan gelombang, jadi saya masih mencoba golf ini. Perhatikan bahwa kode ini tidak akan berfungsi pada TIO karena TIO hanya menampilkan output setelah kode selesai dieksekusi. Jadi, inilah gif (maaf untuk kualitas rendah, saya harus menggunakan situs web untuk mengonversi .movmenjadi .gif, juga >_yang terus muncul di sebelah kanan adalah ikon Terminal di dok mac saya):

Batch, 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

Beberapa garis memiliki spasi tambahan. Membutuhkan terminal 80 kolom standar. Waktunya tidak terlalu akurat, tetapi itu yang terbaik yang dapat Anda lakukan di Batch.

Racket 395 374 373 367 364 351 byte

Menggunakan perpustakaan eksternal untuk pembersihan layar
Edit: Disimpan 21 byte dengan tidak mendefinisikan wdan menggarisbawahi fungsi.
Sunting2: Disimpan 1 byte dengan menghapus spasi.
Sunting3: Disimpan 6 byte dengan mengganti nama loopmenjadi p, terima kasih @rnso!
Sunting4: Menempatkan substring di biarkan menyimpan 3 byte.
Sunting5: Hapus #lang racket, yang tidak diperlukan dalam juru bahasa.

Golf: 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]]]

Menggulir (tidak jelas): 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]]]

Tidak Disatukan:

#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

Membutuhkan PS 3.0 untuk operator shift biner. Ramping menjadi 173 byte dengan bantuan 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

24 byte disimpan berkat @zeppelin , terima kasih banyak

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

Baris pertama mendekompres pola berikut yang terbuat dari 6 gelombang berurutan:

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

Kemudian, loop slide jendela lebar 80-byte melalui pola itu.

*> <> , 251 250 251 byte (tidak bersaing)

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

^{Catatan: "H;0["seharusnya memiliki ascii 27setelahnya [.}

Coba di sini! (setel penundaan ke 0ms)

Saya tidak percaya akhirnya berhasil membuat ini. Ini menggunakan Idan Dinstruksi, yang menambah atau mengurangi tumpukan yang dipilih. Ini menunjukkan bahwa mungkin saja melakukan ini dengan murni> <> (kurang tidur) atau jawaban kompetitif>> <>, meskipun mungkin jauh lebih sulit untuk dilakukan.

Versi penerjemah online berbeda hanya untuk menghapus output menggunakan carriage return.

Ini adalah non-bersaing karena I, D, C, danR petunjuk lebih muda dari tantangan. Ini mungkin dapat dilakukan tanpa instruksi tersebut, tetapi akan sangat sulit / lama.

Sunting: Saya sebenarnya berhasil menghapus satu byte, tetapi saya juga perhatikan saya mengukur ukuran yang salah, jadi saya benar-benar mendapatkan satu byte.

Saya akan melakukan yang terbaik untuk memecah langkah dan menjelaskan apa yang terjadi di sini ...

Penjelasan

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

Daftar Isi

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)

Inisialisasi

Di sini kita membangun 6 garis yang membangun gelombang. Kita harus mengulangi setiap string 5 kali untuk menjadi panjang yang benar.

Kita mulai dengan 6 ini, satu untuk setiap baris gelombang:

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

Dan kita memasuki loop utama setelah inisialisasi melalui 09..

Salin Stack Saat Ini 4 Kali

Ini adalah fungsi sederhana yang hanya mengambil tumpukan saat ini, dan menyalinnya 4 kali. Jadi "a" akan menjadi "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

Salin Tumpukan

Ini menyalin tumpukan saat ini, menambahkan salinan ke tumpukan saat ini.

Mempersiapkan

Akan melewati awal <dan membalikkan baris pertama menjadi l:&0vseperti itu urutan dieksekusi setelah <perubahan arah 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

Dari sini panjangnya akan disebut sebagai ndan 0sebagai i.

Loop

>                        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

Membersihkan

>                        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

Loop Utama

Di sinilah kode berjalan selamanya, terus-menerus menggambar ulang gelombang di antara 100ms tidur.

Mempersiapkan

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 

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

Tidak dapat menganimasikan lebih dari satu baris, tetapi menggulir.
Tambahkan ,0ke array untuk baris kosong di antara iterasi. Jalankan dengan -r.

Mathematica, 213 byte

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

Saya tidak melihat cara apa pun untuk bermain golf pola gelombang di Mathematica selain hanya mulai dengan daftar string untuk setiap baris. Saya mulai ijadi 0dan menjadwalkan tugas untuk menambahnya setiap 0.1detik. Saya Dynamicsekutu menampilkan hasil sebagai berikut:

1. StringRepeat setiap baris 5 kali.
2. Ubah setiap baris menjadi daftar Characters.
3. RotateRightsetiap daftar karakter oleh i.
4. Tampilkan array karakter yang dihasilkan sebagai a Grid.

C (unix), 231 191 byte

Ini hanya akan berfungsi pada lingkungan unix. Juga, mohon alasan bahwa tidur hanya menerima bilangan bulat ... jadi sebenarnya penundaan 1 detik antara frame.

Versi tidak disatukan:

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

Versi golf:

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

Solusi lama:

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 terima kasih kepada @redstarcoder}

_{-9 byte terima kasih kepada @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)

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

Tidak Disatukan:

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

Pengujian:

(f)

Keluaran:

(Tampilan file gif ini lebih lambat dari output aktual).

Python 2, 207 202 byte

Biasanya saya adalah pengembang C #, jadi ini mungkin belum sepenuhnya golf ...

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

Kurang lebih versi porting dari solusi saya di 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

Membutuhkan -Etanpa biaya tambahan. Ini mengandung karakter yang tidak patut dicetak.

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

Buat data di atas menggunakan hexdump reversibel di bawah ini. Jalankan xxd -d > sea.pldi linux atau terminal yang kompatibel, rekatkan di bawah ini dan tekan Ctrl+ d, kemudian jalankan 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}

Pemakaian

Untuk menyalin / menempel dengan mudah, silakan gunakan di bawah ini:

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

Penjelasan

Solusi yang cukup mudah yang menyimpan gelombang sebagai string di awal, yaitu unpack diedit ke biner, setiap bagian digabungkan, 0s dikonversi menjadi spasi dan 1s dikonversi menjadi *s. Sekarang kita memiliki seluruh string sehingga kita memasukkan satu redolingkaran yang mencetak seluruh string, lalu kita menunggu 0,1 detik dan untuk setiap baris dalam string, kita memindahkan karakter terakhir ke awal string.

Mathematica 171 Bytes

Gelombang itu sendiri adalah data, jadi saya menyimpan versi terkompresi dari seluruh gelombang dalam kode saya. Saya dapat menyimpan satu gelombang dengan lebih kompak\fð߀ᣀ恠耟 menggunakan representasi biner itu, tetapi jumlah karakter overhead dari uncompressing terlalu tinggi *.

Ini kodenya:

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

Berikut adalah kode yang saya gunakan untuk membuat versi terkompresi dari data wave:

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

Berikut adalah kode yang saya lebih suka gunakan untuk menyimpan data biner berulang terkompresi seperti gelombang ini:

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

Seperti yang Anda lihat, overhead untuk mengubah data terkompresi kembali menjadi string terlalu mahal untuk masalah khusus ini, meskipun satu gelombang dapat disimpan dengan cara ini dengan 7 karakter UTF dan 15 byte.

Berikut adalah kode untuk menentukan urutan karakter UTF untuk menyimpan satu gelombang (seperti di atas).

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

Ruby 269 217 189 185 Bytes

-28 Bytes berkat @manatwork

-5 Bytes berkat @ropata

Normal

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

Golf

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 hanya menggeser setiap baris dengan 1 dan mengubah teks setiap 100 ms.