Das Meer in Ihrem Terminal

46

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.

Dada
quelle
2
Können wir die Animation in jedem Frame starten?
Arnauld
2
05ab1e.tryitonline.net/… schade 05AB1E kann nicht animieren, das wäre kurz gewesen.
Magic Octopus Urn
2
@ Arnauld Ja, das kannst du.
Dada
2
Oh, du hast Recht! Dies sind echte Lambdas
Luis Mendo
14
"Der Sommer ist längst vorbei", das ist ganz Ihre nördliche Hemisphäre.
MikeTheLiar

Antworten:

18

MATL , 41 bis 40 Bytes

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

Beispiellauf:

Bildbeschreibung hier eingeben

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
Luis Mendo
quelle
19

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>

Arnauld
quelle
Was ist die Funktion der Variablen a?
Kritixi Lithos
@KritixiLithos aenthält das binär codierte Wellenmuster und wird bei jedem Frame gedreht. Daher kann es nicht fest codiert werden: Es muss in einer Variablen gespeichert werden.
Arnauld
16

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

darrylyeo
quelle
9

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

Bildbeschreibung hier eingeben

Pete Arden
quelle
1
Ich denke, Sie können die Klammern entfernen (a)=>. Und while(true)kann seinfor(;;)
Cyoce
1
Für den sLambda denke ich, können Sie die {}undreturn
Cyoce
Hat an beiden gearbeitet und insgesamt 25 Byte eingespart, danke! :)
Pete Arden
Sie können Ihre gesamte Funktion zu einem Lambda machen. Ich denke , man kann auch das Entfernen \rvon dem string.Join(zumindest unter Windows funktioniert es, nicht getestet es mit Mono obwohl) Sie können auch speichern 1 Byte , indem sie p++in die forwie diese Schleifefor(;;p++)
Stefan
Um die Begrenzungsüberprüfung unten ( if (p==16)...) zu entfernen , können Sie sie auch wie folgt in den for-Schleifenkopf einfügen for(;;p=++p%16). Speichern Sie 1 weiteres Byte, indem Sie pin der Schleife deklarieren ( for(int p=0;;p=++p%16))
Stefan
7

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

welle gif

Kritixi Lithos
quelle
Ich habe keine Ahnung, wie Ihre funky sich wiederholenden Zahlen funktionieren, aber wenn Sie eine Welle erzeugen und diese dann blockieren, können Sie Zeichen speichern (anstatt jede Zeile viermal einzufügen
nmjcman101
Weniger hilfreich, denke ich, könnte dein 5j(im Kontext von $<C-V>5j) gerade sein }, und das pnach dem |sollte ein sein, Pdas die Statik *in der unteren linken Ecke behebt .
nmjcman101
1
Schließlich (Entschuldigung für Kommentar-Spam, anscheinend sind sie für 5 Minuten bearbeitbar) können Sie das qm[CODE]@mq@mam Ende durch nur ersetzen ò[CODE]. Der Code zwischen òwird (ähnlich wie bei Ihrem Makro) bis zum Ende einer Schleife wiederholt und am Ende eines Programms òimplizit geschlossen.
nmjcman101
@ nmjcman101 Danke für all deine Hilfe! (es ist kein Kommentar-Spam, wenn Sie mir helfen, ein paar Bytes Golf zu spielen :)
Kritixi Lithos
6

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.

Neil
quelle
6

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

Wellen

Ultimate Hawk
quelle
Das Umbenennen von Namen in kürzere Namen (z. B. p anstelle von loop) kann durchgeführt werden, um die Anzahl der Bytes zu verringern. Mit welcher Software haben Sie Videos in eine GIF-Datei aufgenommen?
RNSO
@ rnso: Oh du hast recht! Daran habe ich nicht gedacht. Ich habe simplescreenrecordermit verwendet avconv, um mp4 in gif zu konvertieren.
Ultimate Hawk
Sie können (g substring) in let einfügen, damit Sie später im Code g anstelle von 2 Teilzeichenfolgen-Schlüsselwörtern verwenden können. Das sollte Ihnen weitere 5 Bytes ersparen. Was macht 'lst' auch in deiner ungolften Version?
RNSO
@rnso: Entfernt es, war ein Überbleibsel dessen, wann es rotmultatsächlich wals Parameter aufgenommen wurde.
Ultimate Hawk
Sie können "#lang Schläger" von der Golfversion auch entfernen. Der meiste Racket-Code auf dieser Site enthält ihn nicht, während die Bytes gezählt werden.
RNSO
4

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}

PoshWaves

Beatcracker
quelle
Gute Antwort! Einige Golf spielt - mit dem Dezimal - Formatbezeichner statt .PadLeft, bewegen Sie die $oErklärung in den [convert]Anruf, und die Beseitigung der Anführungszeichen um die Zahlen in den -replaceops. for(){0..5|%{("{0:D16}"-f+[Convert]::ToString(([uint16]$o=$w[$_]),2))*5-replace0,' '-replace1,'*'
Runter
@AdmBorkBork Danke! Es tut mir leid, dass ich einige Zeit gebraucht habe, um die Antwort zu aktualisieren. Könnten Sie erklären , +in der "{0:D16}"-f+[Convert]? Ohne geht es nicht, aber ich kann nicht fassen, was es macht.
Beatcracker
Das [convert]::ToString()gibt einen String zurück. Das +erzwingt eine Umwandlung in eine, [int]so dass -fder korrekte Parametertyp für die Funktion ausgewählt wird D16.
AdmBorkBork
1
@AdmBorkBork Du meinst, dass PS +'1'wie eine gültige arithmetische Operation ohne erste Summierung behandelt wird , stringin intdas Ergebnis umgewandelt wird und dieses zurückgibt? Großartiger Scott!
Beatcracker
3

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.

yoann
quelle
Das Dienstprogramm Coreutils base64 unterstützt das Flag -D nicht (sollte stattdessen -d in Kleinbuchstaben sein).
Zeppelin
Sie können ~ 10 Bytes speichern, indem Sie rohes LZMA (xz) anstelle von gzip verwenden (komprimieren Sie mit lzma -Fraw , dekomprimieren Sie mit xz -qdFraw ).
Zeppelin
Sie können auch eine ältere arithmetische Erweiterungssyntax $ [] anstelle von $ (()) verwenden , um 4 weitere Bytes zu sparen
Zeppelin
Eine führende Null kann im Befehl sleep weggelassen werden, dh sleep .1 sollte einwandfrei funktionieren
Zeppelin
Sie können auch explizite i = 0-Deklaration
Zeppelin
3

*> <> , 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
redstarcoder
quelle
2

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.

Titus
quelle
2

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.

Bildbeschreibung hier eingeben

Genisis
quelle
Mit welcher Software haben Sie das Capture und die GIF-Datei erstellt?
RNSO
Ich habe ScreenToGif verwendet.
Genisis
2

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);}}
Ajxs
quelle
1
Das ist das C in Ihrem Terminal.
Robert Fraser
2

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);
Ajxs
quelle
Sie können auch 2 Bytes mit setInterval(a=>{...},100,6)und 4 weitere mit speichern f+=" *"[[...][a]&1<<(i+x)%16].
ETHproductions
Danke für die Vorschläge! Aber sind Sie sicher, dass Sie Ihren zweiten Vorschlag umsetzen können? Sie müssen diesen Wert immer noch in einen Booleschen Wert umwandeln, um den Array-Index 0-1 abzurufen. Ich habe darüber nachgedacht, die Wellen-ASCII-Werte in einen einzelnen Hex-Wert umzuwandeln: 0x801F606018C007C000F0000C, aber Javascript kann maximal 31 Bits in beide Richtungen bitweise verschieben! Sie lernen jeden Tag etwas!
Ajxs
2

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;}
bb94
quelle
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)
dfernan
quelle
print("\x1b[0;H")funktioniert bei mir auch für -1 byte.
Redstarcoder
Sie können ersetzen ' **'mit ' '*13+'**'und Sie können 1 Zeichen Einzüge in der während haben, keine Notwendigkeit für sie 4 Zeichen zu sein.
PascalVKooten
@ PascalvKooten danke. Die Einrückungen wurden beim Einfügen in Leerzeichen aus Tabulatorzeichen umgewandelt. Ich werde darauf achten.
dfernan
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:

Bildbeschreibung hier eingeben

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

rnso
quelle
1

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
Stefan
quelle
1

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);}}
Stefan
quelle
1

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.

Dom Hastings
quelle
1

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@%
Kelly Lowder
quelle
1

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}
Tom Lazar
quelle
Obwohl Ihr Code einwandfrei funktioniert, beachten Sie bitte, dass er gemäß den Site-Regeln noch keine gültige Lösung ist: „Alle Lösungen für Herausforderungen sollten: (…) ein ernstzunehmender Konkurrent für die verwendeten Gewinnkriterien sein. Zum Beispiel muss ein Eintrag in einem Codegolf Wettbewerb zu golfed, (...)“- Hilfe Siehe Tipps für den Golfsport in Ruby für ein paar Tipps.
Handarbeit
Auf jeden Fall eine kurze Liste: Einrückung entfernen; do … end{ … }und entfernen Sie die Zeilenumbrüche nach {und vor }; entferne das Leerzeichen zwischen systemund seinem Parameter; Entfernen Sie das ,letzte Element des After-Array-Literal. .each.mapund das Leerzeichen zwischen ihm und seinem Codeblock entfernen; entferne das Feld vor puts; 0..800,80(dies ist auch ein Fehler, da der Ausdruck eine 81 Zeichen lange Zeichenfolge ergibt); p=p+1==16?0: p+1p=-~p%16.
Handarbeit
Yepp, die dumme Erklärung von manatwork schlägt wieder zu. Auch wenn sich do … end→ ändert { … }, wird das loopSchlüsselwort noch benötigt . Dies ist der kürzeste ich: pastebin.com/cg3gxnm4
Manatwork
Kann 5 oder 6 Bytes sparen, indem Sie b=' '(5 Leerzeichen) oben setzen und dann den Ausgabeausdruck auf ' '*12+'** ', ' '*8+'**** ',b+'***** '+b,' ** ** '+b,' ** **'+b,'*'+b+b+'*****'... ändern (aber SE zeigt wiederholte Leerzeichen in diesem Kommentar nicht richtig an!)
roblogic
0

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.

FireCubez
quelle