tło

Lato na półkuli północnej się kończy, a wielu z nas tęskni za słońcem, plażami, falami oceanu ... To wyzwanie ma na celu rozweselić ich, przypominając im o morzu.

Wyzwanie

Oto morze:

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

Morze składa się z 5 razy tego wzoru fali:

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

Pamiętaj, że wzór ma 16 znaków, a morze ma 5 razy więcej niż 80 znaków.

Które możesz wydrukować na terminalu za pomocą tego wiersza poleceń:

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

Albo ten :

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

(Drugi powinien ułatwić uzyskanie dokładnego wzoru)

Twoim zadaniem jest wyświetlanie morza w terminalu i wyglądanie, jakby fale poruszały się w prawo: musi przesuwać się w prawo z prędkością 1 znaku na każde 100 ms (= 10 razy co sekundę). Po 80. kolumnie nie należy drukować żadnego znaku, ale gdy zniknie prawa fala, po lewej pojawia się nowa.
Oto przykład wyniku:

czas = 0,0 s

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

czas = 0,1s

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

czas = 0,2 s

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

czas = 0,3 s

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

czas = 0,4 s

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

Oczywiście każde wyjście powinno zastąpić poprzednie.

Możesz uruchomić ten kod w terminalu unix, aby zobaczyć, jak powinien wyglądać z animacją:

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

(Należy pamiętać, że ten kod nie jest zbyt dobrze golfowany: właśnie uczyniłem go wystarczająco kompaktowym, aby można go było uruchomić w terminalu.)

Kryterium wygranej

To jest codegolf, więc wygrywa najkrótszy kod w bajtach.

MATL , 41 40 bajtów

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

Przykładowy przebieg:

Lub spróbuj w MATL Online! (rzeczywista prędkość może zależeć od obciążenia serwera).

Jak to działa

`                    % 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 bajtów

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 bajtów

Posługuje text-shadow, rtltekstowych i CSS klatek kluczowych animacji.

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 bajtów

399 bez, using System.Linq;ale jestem pewien, że to byłoby oszustwo ...

Edycja: Zapisano 25 bajtów dzięki @Cyoce

Gra w golfa:

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

Nie golfowany:

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 bajtów

Dzięki @ nmjcman101 za oszczędność 24 bajtów!

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

Zawiera wiele materiałów niedrukowalnych, więc oto zrzut heksowy 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...

Edytować

1. Używany y$zamiast<C-v>$y

2. Wiele zmian

   • Zamiast kopiować każdą linię i wklejać ją 4 razy, najpierw generuję falę, a następnie kopiuję całość i wklejam 4 razy
   • Używane {i }aby zaoszczędzić kilka bajtów
   • Używany òzamiast rejestrów do tworzenia nieskończonej pętli (z jakiegoś powodu muszę dołączyć òna końcu, aby to działało)
   • naprawiono statyczne *na dole

Mini objaśnienie

Używam <alt-n>do tworzenia kopii ciągów. Na przykład <alt-5>*(tak wygląda µ5) wykonuje 5kopie *w trybie wstawiania. Okazało się, że jest to krótsze niż kopiowanie ciągu i używanie wyrażenia regularnego do wykonania niezbędnych zamian. Po utworzeniu jednej fali wklejam ją, aby utworzyć inne fale. Na koniec zapętlam rekurencyjnie, używając òpętli nieskończonej (z opóźnieniem 100ms).

Gif

Większość kodu jest poświęcona tworzeniu fali, więc wciąż próbuję to zagrać w golfa. Zauważ, że ten kod nie będzie działał na TIO, ponieważ TIO wysyła dane wyjściowe dopiero po zakończeniu wykonywania kodu. Oto gif (przepraszam za niską jakość, musiałem użyć strony internetowej, aby przekonwertować .movna a .gif, a także >_, który pojawia się po prawej stronie, to ikona terminala w stacji dokującej mojego Maca):

Partia, 424 bajty

@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

Niektóre linie mają końcowe spacje. Wymaga standardowego terminala 80-kolumnowego. Czas nie jest bardzo dokładny, ale jest najlepszy, co możesz zrobić w partii.

Rakieta 395 374 373 367 364 351 bajtów

Używa zewnętrznej biblioteki do czyszczenia ekranu.
Edycja: Zapisano 21 bajtów, nie definiując wi nie wstawiając funkcji.
Edycja2: Zapisano 1 bajt, usuwając spację.
Edit3: Zapisano 6 bajtów, zmieniając nazwę loopna p, dzięki @rnso!
Edycja4: Umieszczanie podłańcucha w let, oszczędzając 3 bajty.
Edycja5: Usuń #lang racket, która nie jest potrzebna w tłumaczu .

Gra w golfa: 351 bajtów

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

Przewijanie (bez czyszczenia): 272 bajtów

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

Nie golfowany:

#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 bajtów

Wymaga PS 3.0 dla operatorów zmiany binarnej. Zmniejszony do 173 bajtów z pomocą 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 bajtów

24 bajty zapisane dzięki @zeppelin , wielkie dzięki

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

Pierwsza linia dekompresuje następujący wzór złożony z 6 kolejnych fal:

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

Następnie pętla przesuwa okno o szerokości 80 bajtów przez ten wzór.

*> <> , 251 250 251 bajtów (niekonkurujące)

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

^{Uwaga: "H;0["ma mieć ASCII 27po [.}

Wypróbuj tutaj! (ustaw opóźnienie na 0ms)

Nie mogę uwierzyć, że udało mi się to zrobić. Korzysta z instrukcji Ii D, które zwiększają lub zmniejszają wybrany stos. To pokazuje, że prawdopodobnie można to zrobić w czystej> <> (bez snu) lub w konkurencyjnej *> <> odpowiedzi, choć prawdopodobnie jest to o wiele trudniejsze.

Wersja tłumacza online różni się po prostu, aby usunąć dane wyjściowe za pomocą znaku powrotu karetki.

To nie konkurują, ponieważ I, D, Coraz Rinstrukcje są młodsze niż wyzwanie. Jest to prawdopodobnie możliwe bez tych instrukcji, ale byłoby to bardzo trudne / długie.

Edycja: Naprawdę udało mi się usunąć bajt, ale zauważyłem również, że źle zmierzyłem rozmiar, więc faktycznie uzyskałem bajt.

Zrobię co w mojej mocy, aby podzielić kroki i wyjaśnić, co się tutaj dzieje ...

Wyjaśnienie

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

Spis treści

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)

Inicjalizacja

Tutaj budujemy 6 linii, które tworzą fale. Musimy powtórzyć każdy ciąg 5 razy, aby mieć prawidłową długość.

Zaczynamy od 6 z nich, po jednym dla każdej linii fali:

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

I po inicjalizacji wchodzimy do głównej pętli 09..

Skopiuj bieżący stos 4 razy

Jest to prosta funkcja, która po prostu pobiera bieżący stos i kopiuje go 4 razy. Zatem „a” stałoby się „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

Kopiuj stos

Spowoduje to skopiowanie bieżącego stosu, dołączając kopię do bieżącego stosu.

Ustawiać

Pominie początkową <i odwróci pierwszą linię, aby stała się l:&0vw takiej kolejności, w jakiej jest wykonywana po <zmianie kierunku adresu 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

Odtąd długość będzie określana jako ni 0jako i.

Pętla

>                        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

Sprzątać

>                        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

Główna pętla

Tutaj kod działa wiecznie, nieustannie przerysowując fale pomiędzy 100 ms snu.

Ustawiać

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 

Pętla

>                          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 bajtów

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

Nie można animować więcej niż jednej linii, ale przewija się.
Dodaj ,0do tablicy pustą linię między iteracjami. Uruchom z -r.

Mathematica, 213 bajtów

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

Nie widzę żadnego sposobu gry w golfa na fali w Mathematica oprócz rozpoczęcia od listy ciągów dla każdej linii. Inicjuję isię 0i planuję zadanie, aby zwiększać je co 0.1sekundę. I Dynamicsojusznikiem wyświetli wynik z następujących powodów:

1. StringRepeat każda linia 5 razy.
2. Konwertuj każdą linię na jej listę Characters.
3. RotateRightkażda lista znaków według i.
4. Wyświetl wynikową tablicę znaków jako Grid.

C (unix), 231 191 bajtów

Działa to tylko w środowiskach unix. Proszę również usprawiedliwić fakt, że tryb uśpienia akceptuje tylko liczby całkowite ... więc w rzeczywistości opóźnia 1 sekundę między ramkami.

Wersja bez golfa:

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

Wersja golfowa:

#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 bajtów

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 120 bajtów

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

Stare rozwiązania:

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 bajtów

_{-1 bajt dzięki @redstarcoder}

_{-9 bajtów dzięki @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)

Rakieta 295 bajtów

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

Nie golfowany:

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

Testowanie:

(f)

Wynik:

(Wyświetlanie pliku gif jest wolniejsze niż rzeczywiste wyjście).

Python 2, 207 202 bajtów

Zwykle jestem programistą C #, więc to może nie być jeszcze gra w golfa ...

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 bajtów

Mniej więcej przeniesiona wersja mojego rozwiązania w Pythonie ...

_=>{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 bajtów

Wymaga -Ebez dodatkowych kosztów. Zawiera znaki niedrukowalne.

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

Utwórz powyższe dane za pomocą poniższego odwracalnego zrzutu heksadecymalnego. Uruchom xxd -d > sea.plw Linuksie lub kompatybilnym terminalu, wklej poniżej i naciśnij Ctrl+ d, a następnie uruchom 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}

Stosowanie

Aby ułatwić kopiowanie / wklejanie, skorzystaj z poniższych:

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

Wyjaśnienie

Dość proste rozwiązanie, które przechowuje falę na początku jako ciąg znaków, który jest unpackedytowany do postaci binarnej, każda sekcja jest pięciokrotna, 0s są konwertowane na spacje, a 1s są konwertowane na *s. Teraz mamy cały ciąg, więc wchodzimy w redopętlę, która wypisuje cały ciąg, a następnie czekamy .1 sekundy i dla każdej linii w ciągu przesuwamy ostatni znak na początek łańcucha.

Mathematica 171 bajtów

Sama fala to dane, więc przechowuję skompresowaną wersję całej fali w moim kodzie. Mogę zapisać pojedynczą falę o wiele bardziej zwartą, niż \fð߀ᣀ恠耟przy użyciu jej reprezentacji binarnej, ale narzut związany z rozpakowywaniem jest zbyt wysoki *.

Oto kod:

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

Oto kod, którego użyłem do stworzenia skompresowanej wersji danych fali:

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

Oto kod, którego wolałbym używać do przechowywania skompresowanych powtarzających się danych binarnych, takich jak ta fala:

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

Jak widać, narzut związany z zamianą skompresowanych danych z powrotem na ciąg jest zbyt kosztowny dla tego konkretnego problemu, chociaż w ten sposób można zapisać jedną falę z 7 znakami UTF i 15 bajtami.

Oto kod określający sekwencję znaków UTF do przechowywania pojedynczej fali (jak wyżej).

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

Rubinowy 269 217 189 185 bajtów

-28 Bajtów dzięki @manatwork

-5 bajtów dzięki @ropata

Normalna

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

Grał w golfa

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 bajty

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 przesuwa każdy wiersz o 1 i zmienia tekst co 100 ms.