Contexte

L’été est bien terminé dans l’hémisphère Nord et le soleil, les plages, les vagues de l’océan nous manquent à beaucoup… Ce défi consiste à leur remonter le moral en leur rappelant la mer.

Le défi

Voici la mer:

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

La mer est composée de 5 fois ce type de vagues:

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

Notez que le modèle comporte 16 caractères et la mer 5 fois plus que celui-ci = 80 caractères.

Que vous pouvez imprimer dans un terminal en utilisant cette ligne de commande:

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

Ou celui-ci:

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

(Le second devrait vous aider à obtenir le motif exact)

Votre tâche consiste à afficher la mer dans un terminal et à donner l’impression que les vagues se déplacent vers la droite: elle doit se déplacer vers la droite à une vitesse de 1 caractère toutes les 100 ms (= 10 fois par seconde). Aucun caractère ne doit être imprimé après la 80e colonne, mais comme la vague la plus à droite disparaît, une nouvelle apparaît à gauche.
Voici un exemple de sortie:

temps = 0.0s

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

temps = 0.1s

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

temps = 0.2s

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

temps = 0.3s

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

temps = 0.4s

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

Bien entendu, chaque sortie devrait remplacer la précédente.

Vous pouvez exécuter ce code dans un terminal Unix pour voir comment il devrait ressembler à l'animation:

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

(Notez que ce code n'est pas très bien joué au golf: je l'ai juste rendu assez compact pour qu'il soit pratique de fonctionner dans un terminal.)

Critère gagnant

C'est codegolf, donc le code le plus court en octets gagne.

MATL , 41 à 40 octets

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

Exemple d'exécution:

Ou essayez-le sur MATL Online! (la vitesse réelle peut dépendre de la charge du serveur).

Comment ça fonctionne

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

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 octets

Il emploie text-shadow, rtltextes et animations CSS keyframe.

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 octets

399 sans using System.Linq;mais je suis sûr que ce serait tricher ...

Edit: 25 octets sauvés grâce à @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;}}

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 octets

Merci à @ nmjcman101 pour avoir économisé 24 octets!

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

Cela contient beaucoup de choses non imprimables, alors voici un 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...

Modifier

1. Utilisé y$au lieu de<C-v>$y

2. Beaucoup de changements

   • Au lieu de copier chaque ligne et de les coller 4 fois, je génère d'abord la vague, puis je copie le tout et je la colle 4 fois.
   • Utilisé {et }économiser quelques octets
   • Utilisé à la òplace de registres pour créer la boucle infinie (pour une raison quelconque, je dois en inclure un òà la fin pour que cela fonctionne)
   • fixe le statique *en bas

Mini-explication

J'utilise <alt-n>pour créer des copies de chaînes. Par exemple, <alt-5>*(cela ressemble à µ5) fait des 5copies de *en mode insertion. J'ai trouvé que cela était plus court que de copier la chaîne et d'utiliser un regex pour faire les remplacements nécessaires. Après avoir créé une vague, je la colle pour créer les autres vagues. Enfin, je boucle récursivement en utilisant òpour créer la boucle infinie (avec un délai de 100ms).

Gif

La plupart du code est dédié à la création de la vague, donc j'essaie toujours de jouer au golf. Notez que ce code ne fonctionnera pas sur TIO car ce dernier ne sort la sortie que lorsque le code est terminé. Alors , voici un gif (désolé pour la mauvaise qualité, je devais utiliser un site Web pour convertir un .movà un .gif, aussi >_qui ne cesse d' apparaître dans le droit est l'icône du terminal sur le quai de mon mac):

Lot, 424 octets

@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

Certaines lignes ont des espaces de fin. Nécessite un terminal standard à 80 colonnes. Le timing n'est pas très précis, mais c'est le mieux que vous puissiez faire dans Batch.

Raquette 395 374 373 367 364 351 octets

Utilise une bibliothèque externe pour effacer l'écran
Edit: 21 octets enregistrés en ne définissant pas wet en alignant la fonction.
Edit2: 1 octet enregistré en supprimant un espace.
Edit3: Saved 6 octets en renommant loopà p, merci @rnso!
Edit4: Mettre la sous-chaîne dans le let en sauvegardant 3 octets.
Edit5: Remove #lang racket, ce qui n’est pas nécessaire dans l’interprète.

Golfé: 351 octets

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

Défilement (non effacé): 272 octets

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

Requiert PS 3.0 pour les opérateurs de décalage binaire. Réduit à 173 octets avec l' aide d' 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 octets

24 octets enregistrés grâce à @zeppelin , merci beaucoup

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

La première ligne décompresse le motif suivant en 6 vagues consécutives:

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

Ensuite, la boucle fait glisser une fenêtre large de 80 octets sur ce modèle.

*> <> , 251 250 251 octets (non concurrents)

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

^{Remarque: "H;0["est censé avoir ascii 27après [.}

Essayez-le ici! (régler le délai à 0ms)

Je n'arrive pas à croire que j'ai réussi à faire ça. Celui - ci utilise les Iet des Dinstructions, qui incrémente ou décrémente la pile sélectionnée. Ceci démontre qu'il est probablement possible de le faire en pure> <> (moins le sommeil) ou en une réponse compétitive *> <>, bien que ce soit probablement beaucoup plus difficile à faire.

La version d'interprète en ligne est différente simplement pour effacer la sortie à l'aide d'un retour chariot.

Ceci est non-concurrence parce que les I, D, Cet les Rinstructions sont plus jeunes que le défi. C'est probablement possible de se passer de ces instructions, mais ce serait très difficile / long.

Edit: j’ai réussi à supprimer un octet, mais j’ai aussi remarqué que j’avais mal mesuré la taille et que j’ai donc gagné un octet.

Je ferai de mon mieux pour briser les marches et expliquer ce qui se passe ici ...

Explication

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

Table des matières

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)

Initialisation

Ici nous construisons les 6 lignes qui construisent les vagues. Nous devons répéter chaque chaîne 5 fois pour avoir la longueur correcte.

Nous commençons par 6 d'entre eux, un pour chaque ligne de la vague:

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

Et nous entrons dans la boucle principale après l’initialisation 09..

Copier la pile actuelle 4 fois

C'est une fonction simple qui prend simplement la pile actuelle et la copie 4 fois. Alors "a" deviendrait "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

Copier pile

Ceci copie la pile actuelle, en ajoutant la copie à la pile actuelle.

Installer

Aller ignorer l'initiale <et inverser la première ligne pour devenir l:&0vcomme c'est l'ordre dans lequel il est exécuté après les <changements de direction de l'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

A partir de là, la longueur sera désignée sous nle 0nom de i.

Boucle

>                        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

Nettoyer

>                        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

Boucle principale

C'est ici que le code fonctionne à l'infini, en redessinant constamment les vagues entre 100 ms.

Installer

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 

Boucle

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

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

Impossible d'animer plus d'une ligne, mais le défilement est activé.
Ajouter ,0au tableau pour une ligne vide entre les itérations. Courez avec -r.

Mathematica, 213 octets

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

Je ne vois pas d'autre moyen de reproduire le motif d'onde dans Mathematica que de commencer par une liste de chaînes pour chaque ligne. J'initialise ipour être 0et programme une tâche pour l'incrémenter toutes les 0.1secondes. DynamicJ'affichage allié le résultat de ce qui suit:

1. StringRepeat chaque ligne 5 fois.
2. Convertir chaque ligne en une liste de ses Characters.
3. RotateRightchaque liste de personnages par i.
4. Affichez le tableau de caractères résultant en tant que Grid.

C (unix), 231 191 octets

Cela ne fonctionnera que sur les environnements Unix. Aussi, veuillez excuser le fait que le sommeil n'accepte que les entiers ... il retarde donc réellement d'une seconde entre les images.

Version non-golfée:

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

Version golfée:

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

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 octets

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

Anciennes solutions:

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 octets

_{-1 octet grâce à @redstarcoder}

_{-9 octets grâce à @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)

Raquette 295 octets

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

Essai:

(f)

Sortie:

(Cet affichage de fichier gif est plus lent que la sortie réelle).

Python 2, 207 202 octets

Habituellement, je suis un développeur C #, donc cela ne sera peut-être pas encore complètement joué au 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 octets

Plus ou moins une version portée de ma solution en 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 octets

Requiert -Esans frais supplémentaires. Cela contient des caractères non imprimables.

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

Créez les données ci-dessus en utilisant l'hexdump réversible ci-dessous. Exécutez xxd -d > sea.pldans un terminal Linux ou compatible, collez le ci-dessous et appuyez sur Ctrl+ d, puis exécutez 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}

Usage

Pour un copier / coller facile, veuillez utiliser ce qui suit:

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

Explication

Une solution assez simple qui stocke l'onde sous forme de chaîne au début, qui est unpackéditée en binaire, chaque section est quintupliquée, les 0s sont convertis en espaces et les 1s sont convertis en *s. Maintenant que nous avons toute la chaîne, nous entrons dans une redoboucle qui affiche toute la chaîne, puis nous attendons pendant 0,1 seconde et, pour chaque ligne de la chaîne, nous déplaçons le dernier caractère au début de la chaîne.

Mathematica 171 octets

La vague elle-même est constituée de données, je stocke donc une version compressée de la totalité de la vague dans mon code. Je peux stocker une onde beaucoup plus compacte que si j'utilisais \fð߀ᣀ恠耟sa représentation binaire, mais le décompte de caractères nécessaire à la décompression est trop élevé *.

Voici le code:

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

Voici le code que j'ai utilisé pour créer la version compressée des données wave:

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

Voici le code que j'aurais préféré utiliser pour stocker des données binaires répétées compressées comme cette onde:

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

Comme vous pouvez le constater, le temps système nécessaire pour reconvertir les données compressées en chaîne est trop onéreux pour ce problème particulier, bien qu’une seule vague puisse être stockée de cette manière avec 7 caractères UTF et 15 octets.

Voici le code permettant de déterminer la séquence de caractères UTF pour stocker une seule onde (comme ci-dessus).

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

Ruby 269 217 189 185 octets

-28 octets grâce à @manatwork

-5 octets grâce à @ropata

Ordinaire

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 octets

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 décale juste chaque ligne de 1 et change le texte toutes les 100 ms.