Hintergrund

Der Sommer ist in der nördlichen Hemisphäre schon lange vorbei und viele von uns vermissen die Sonne, die Strände, die Wellen des Ozeans ... Diese Herausforderung zielt darauf ab, sie aufzuheitern, indem sie an das Meer erinnert werden.

Die Herausforderung

Hier ist das Meer:

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

Das Meer besteht aus dem 5-fachen dieses Wellenmusters:

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

Beachten Sie, dass das Muster 16 Zeichen lang ist und das Meer das Fünffache dieses Musters = 80 Zeichen lang ist.

Was Sie über diese Befehlszeile in ein Terminal drucken können:

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

Oder dieses :

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

(Die zweite sollte es Ihnen leichter machen, das genaue Muster zu finden.)

Ihre Aufgabe ist es, das Meer in einem Terminal anzuzeigen und es so aussehen zu lassen, als würden sich die Wellen nach rechts bewegen. Es muss sich mit einer Geschwindigkeit von 1 Zeichen pro 100 ms (= 10-mal pro Sekunde) nach rechts verschieben. Nach der 80. Spalte sollte kein Zeichen gedruckt werden, aber wenn die Welle ganz rechts verschwindet, erscheint links eine neue.
Hier ist ein Beispiel für die Ausgabe:

Zeit = 0,0s

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

Zeit = 0,1 s

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

Zeit = 0,2 s

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

Zeit = 0,3 s

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

Zeit = 0,4 s

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

Natürlich sollte jeder Ausgang den vorherigen ersetzen.

Sie können diesen Code in ein Unix-Terminal ausführen, um zu sehen, wie er mit der Animation aussehen soll:

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

(Beachten Sie, dass dieser Code nicht besonders gut funktioniert: Ich habe ihn so kompakt gestaltet, dass er bequem in einem Terminal ausgeführt werden kann.)

Gewinnkriterium

Das ist Codegolf, also gewinnt der kürzeste Code in Byte.

MATL , 41 bis 40 Bytes

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

Beispiellauf:

Oder probieren Sie es bei MATL Online! (Die tatsächliche Geschwindigkeit hängt möglicherweise von der Serverauslastung ab.)

Wie es funktioniert

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

Nutzt text-shadow, rtlText und CSS Keyframe - Animationen.

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 ohne using System.Linq;aber ich bin mir sicher das wäre schummeln ...

Bearbeiten: 25 Bytes dank @Cyoce gespeichert

Golf gespielt:

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 Bytes

Vielen Dank an @ nmjcman101 für das Speichern von 24 Bytes!

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

Dies enthält eine Menge nicht druckbarer Dateien. Hier ist ein 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...

Bearbeiten

1. Wird y$anstelle von verwendet<C-v>$y

2. Viele Veränderungen

   • Anstatt jede Zeile zu kopieren und viermal einzufügen, generiere ich zuerst die Welle und kopiere dann das Ganze und füge es viermal ein
   • Verwendet {und }um wenige Bytes zu sparen
   • Wird òanstelle von Registern verwendet, um die Endlosschleife zu erstellen (aus irgendeinem Grund muss òam Ende ein eingefügt werden, damit dies funktioniert.)
   • Die Statik *unten fixiert

Mini-Erklärung

Ich benutze <alt-n>, um Kopien von Zeichenfolgen zu erstellen. Zum Beispiel <alt-5>*(das sieht aus wie µ5) macht 5Kopien *im Einfügemodus. Dies war kürzer als das Kopieren der Zeichenfolge und die Verwendung eines regulären Ausdrucks, um die erforderlichen Ersetzungen vorzunehmen. Nachdem ich eine Welle erstellt habe, füge ich sie ein, um die anderen Wellen zu erstellen. Schließlich schleife ich rekursiv mit ò, um die Endlosschleife zu erstellen (mit einer Verzögerung von 100ms).

Gif

Der größte Teil des Codes ist der Erstellung der Welle gewidmet, daher versuche ich immer noch, Golf zu spielen. Beachten Sie, dass dieser Code auf TIO nicht funktioniert, da TIO die Ausgabe erst ausgibt, nachdem der Code ausgeführt wurde. Also hier ein GIF (Entschuldigung für die schlechte Qualität, ich musste eine Website verwenden, um ein .movin ein zu konvertieren .gif, außerdem >_ist das Terminal-Symbol auf dem Dock meines Macs immer wieder zu sehen):

Batch, 424 Bytes

@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

Einige Zeilen haben nachgestellte Leerzeichen. Erfordert ein Standardterminal mit 80 Spalten. Das Timing ist nicht sehr genau, aber es ist das Beste, was Sie in Batch tun können.

Schläger 395 374 373 367 364 351 Bytes

Verwendet eine externe Bibliothek für Bildschirm Clearing
Edit: 21 Bytes Gespeichert durch nicht definiert , wund inlining die Funktion.
Edit2: 1 Byte durch Entfernen eines Leerzeichens gespeichert.
Edit3: 6 Bytes durch Umbenennen loopin pgespeichert, danke @rnso!
Edit4: Einfügen eines Teilstrings in den Let, der 3 Bytes speichert.
Edit5: Entfernen #lang racket, was im Interpreter nicht benötigt wird.

Golf gespielt: 351 Bytes

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

Scrollen (nicht löschen): 272 Bytes

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

Benötigt PS 3.0 für binäre Shiftoperatoren. Mit Hilfe von AdmBorkBork auf 173 Bytes verkleinert !

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

24 Bytes gespart dank @zeppelin , vielen Dank

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

Die erste Zeile dekomprimiert das folgende Muster aus 6 aufeinanderfolgenden Wellen:

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

Dann schiebt die Schleife ein 80 Bytes breites Fenster durch dieses Muster.

*> <> , 251 250 251 Bytes (nicht konkurrierend)

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

^{Hinweis: "H;0["soll 27nachher ascii haben [.}

Probieren Sie es hier aus! (Verzögerung auf 0ms setzen)

Ich kann nicht glauben, dass ich es geschafft habe. Dabei werden die Anweisungen Iund verwendet D, mit denen der ausgewählte Stapel erhöht oder verringert wird. Dies zeigt, dass es wahrscheinlich möglich ist, dies in einer reinen> <> (minus dem Schlaf) oder einer kompetitiven *> <> Antwort zu tun, obwohl es wahrscheinlich viel schwieriger ist, dies zu tun.

Die Online-Interpreter-Version unterscheidet sich lediglich dadurch, dass die Ausgabe mit einem Wagenrücklauf gelöscht wird.

Dies ist nicht miteinander im Wettbewerb , weil das I, D, Cund RAnweisungen jünger als Herausforderung. Dies ist wahrscheinlich ohne diese Anweisungen möglich, aber es wäre sehr schwer / lang.

Bearbeiten: Ich habe es tatsächlich geschafft, ein Byte zu entfernen, aber ich habe auch bemerkt, dass ich die Größe falsch gemessen habe, also habe ich tatsächlich ein Byte gewonnen.

Ich werde mein Bestes tun, um die Schritte zu brechen und zu erklären, was hier passiert ...

Erläuterung

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

Inhaltsverzeichnis

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)

Initialisierung

Hier bauen wir die 6 Linien, die die Wellen konstruieren. Wir müssen jede Zeichenfolge fünfmal wiederholen, um die richtige Länge zu erhalten.

Wir beginnen mit 6 davon, eine für jede Zeile der Welle:

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

Und wir betreten die Hauptschleife nach der Initialisierung durch 09..

Aktuellen Stapel 4 Mal kopieren

Dies ist eine einfache Funktion, die einfach den aktuellen Stapel aufnimmt und ihn viermal kopiert. So würde "a" "aaaaa" werden.

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

Stapel kopieren

Dadurch wird der aktuelle Stapel kopiert und die Kopie an den aktuellen Stapel angehängt.

Konfiguration

Überspringe die Initiale <und kehre die erste Zeile um, um zu werden, l:&0vda dies die Reihenfolge ist, in der sie ausgeführt wird, nachdem <sich die Richtung der IP geändert hat.

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

Ab hier wird die Länge als nund die 0als bezeichnet i.

Schleife

>                        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

Aufräumen

>                        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

Hauptschleife

Hier läuft der Code für immer und zeichnet die Wellen zwischen 100 ms Schlafdauer ständig neu.

Konfiguration

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 

Schleife

>                          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 Bytes

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

Es kann nicht mehr als eine Zeile animiert werden, es wird jedoch ein Bildlauf ausgeführt.
Fügen Sie ,0dem Array eine leere Zeile zwischen den Iterationen hinzu. Laufen Sie mit -r.

Mathematica, 213 Bytes

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

Ich sehe in Mathematica keine andere Möglichkeit, das Wellenmuster zu spielen, als mit einer Liste von Zeichenfolgen für jede Zeile zu beginnen. Ich initialisiere i, um zu sein, 0und plane eine Aufgabe, um sie alle 0.1Sekunden zu erhöhen . Ich Dynamiczeige das Ergebnis von Folgendem an:

1. StringRepeat jede Zeile 5 mal.
2. Konvertieren Sie jede Zeile in eine Liste ihrer Characters.
3. RotateRightjede Liste von Zeichen von i.
4. Zeigen Sie das resultierende Array von Zeichen als an Grid.

C (Unix), 231 bis 191 Bytes

Dies funktioniert nur in Unix-Umgebungen. Bitte entschuldigen Sie auch die Tatsache, dass der Schlaf nur Ganzzahlen akzeptiert ... also verzögert er tatsächlich 1 Sekunde zwischen Frames.

Ungolfed-Version:

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

Golf Version:

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

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 Bytes

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

Alte Lösungen:

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 Bytes

_{-1 Byte dank @redstarcoder}

_{-9 Bytes dank @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)

Schläger 295 Bytes

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

Testen:

(f)

Ausgabe:

(Diese Anzeige der GIF-Datei ist langsamer als die tatsächliche Ausgabe).

Python 2, 207 202 Bytes

In der Regel bin ich ein C # -Entwickler, daher ist dies möglicherweise noch nicht vollständig erledigt.

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 Bytes

Mehr oder weniger eine portierte Version meiner Lösung in 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 Bytes

Benötigt -Ekeine zusätzlichen Kosten. Dies enthält nicht druckbare Zeichen.

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

Erstellen Sie die obigen Daten mit dem unten stehenden umkehrbaren Hexdump. Führen Sie xxd -d > sea.plein Linux- oder kompatibles Terminal aus, fügen Sie das Folgende ein, drücken Sie Ctrl+ dund führen Sie dann aus 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}

Verwendungszweck

Verwenden Sie zum einfachen Kopieren / Einfügen die folgenden Befehle:

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

Erläuterung

Eine relativ einfache Lösung, bei der die Welle am Anfang als Zeichenfolge gespeichert wird, die unpackin binär umgewandelt wird. Jeder Abschnitt wird verfünffacht, 0s wird in Leerzeichen und 1s in *s konvertiert . Jetzt haben wir die gesamte Zeichenfolge und geben eine redoSchleife ein, die die gesamte Zeichenfolge ausgibt. Dann warten wir 0,1 Sekunden und verschieben für jede Zeile in der Zeichenfolge das letzte Zeichen an den Anfang der Zeichenfolge.

Mathematica 171 Bytes

Die Wave selbst besteht aus Daten, daher speichere ich eine komprimierte Version der gesamten Wave in meinem Code. Ich kann eine einzelne Wave viel kompakter speichern, als wenn ich \fð߀ᣀ恠耟ihre Binärdarstellung verwende, aber der Aufwand für die Zeichenanzahl beim Dekomprimieren ist zu hoch *.

Hier ist der Code:

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

Hier ist der Code, mit dem ich die komprimierte Version der Wave-Daten erstellt habe:

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

Hier ist der Code, den ich am liebsten verwendet hätte, um komprimierte, sich wiederholende Binärdaten wie diese Welle zu speichern:

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

Wie Sie sehen, ist der Aufwand für die Umwandlung der komprimierten Daten in einen String für dieses spezielle Problem zu hoch, obwohl auf diese Weise eine einzelne Wave mit 7 UTF-Zeichen und 15 Byte gespeichert werden kann.

Hier war der Code zum Bestimmen der UTF-Zeichenfolge zum Speichern einer einzelnen Wave (s wie oben).

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

Ruby 269 217 189 185 Bytes

-28 Bytes dank @manatwork

-5 Bytes dank @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 gespielt

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>

Das JavaScript verschiebt nur jede Zeile um 1 und ändert den Text alle 100 ms.