La mer dans votre terminal

46

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.

Dada
la source
2
Pouvons-nous commencer l'animation à n'importe quelle image?
Arnauld
2
05ab1e.tryitonline.net/… tant pis 05AB1E ne peut pas animer, cela aurait été court.
Urne Magique Octopus
2
@Arnauld Oui, vous le pouvez.
Dada
2
Oh, tu as raison! Ce sont de vrais lambdas
Luis Mendo
14
"L'été est bien fini", c'est l'hémisphère nord de vous.
MikeTheLiar

Réponses:

18

MATL , 41 à 40 octets

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

Exemple d'exécution:

entrez la description de l'image ici

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
Luis Mendo
la source
19

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>

Arnauld
la source
Quelle est la fonction de la variable a?
Kritixi Lithos
@KritixiLithos acontient le motif d'onde codé en binaire et est pivoté sur chaque image. Donc, il ne peut pas être codé en dur: il doit être stocké dans une variable.
Arnauld
16

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

Darrylyeo
la source
9

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

entrez la description de l'image ici

Pete Arden
la source
1
Je pense que vous pouvez supprimer les parenthèses dans (a)=>. Et while(true)peut êtrefor(;;)
Cyoce
1
Pour le slambda, je pense que vous pouvez enlever le {}etreturn
Cyoce
Travaillé sur les deux, me donnant une économie totale de 25 octets, merci! :)
Pete Arden
Vous pouvez faire de votre fonction entière un lambda. Je pense que vous pouvez également supprimer \rdu string.Join(du moins sous Windows, cela ne fonctionne pas, mais ne l'avez pas testé avec Mono). Vous pouvez également enregistrer 1 octet en le mettant p++dans la forboucle comme cecifor(;;p++)
Stefan
Pour supprimer la vérification des limites au bas ( if (p==16)...), vous pouvez également la mettre dans l'en-tête de la boucle for, comme ceci for(;;p=++p%16). Économisez 1 octet de plus en déclarant pdans la boucle ( for(int p=0;;p=++p%16))
Stefan
7

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

vague gif

Kritixi Lithos
la source
J'ai très peu idée de la façon dont fonctionnent vos numéros répétés géniaux, mais si vous faites une vague, puis que vous bloquez le copier / coller, vous pouvez enregistrer les caractères (au lieu de copier-coller chaque ligne 4 fois). Lien vers TryItOnline
nmjcman101 12/12
De manière moins utile, je pense que votre 5j(dans le contexte de $<C-V>5j) pourrait bien être }, et que l’ paprès |devrait être un Pqui corrigera la statique *en bas à gauche.
nmjcman101
1
Enfin (désolé pour le commentaire spam, apparemment, ils sont modifiables pendant 5 minutes), vous pouvez remplacer le qm[CODE]@mq@mà la fin par juste ò[CODE]. Le code entre òva boucler jusqu'à la rupture (de la même manière que votre macro) et à la fin d'un programme, il òest implicitement fermé.
nmjcman101
@ nmjcman101 Merci pour votre aide! (ce n'est pas un spam de commentaire si vous
m'aidez à jouer au
6

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.

Neil
la source
6

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

Vagues

Ultimate Hawk
la source
Il est possible de renommer les noms en noms plus courts (comme p au lieu de boucle) pour réduire les octets. Quel logiciel avez-vous utilisé pour capturer une vidéo dans un fichier gif?
rnso
@ rnso: Oh tu as raison! Je n'ai pas pensé à celui-là. J'ai utilisé simplescreenrecorderavec avconvpour convertir MP4 en GIF.
Ultimate Hawk
Vous pouvez mettre (g substring) dans let afin que vous puissiez utiliser g à la place de 2 mots clés de sous-chaîne plus tard dans le code. Cela devrait vous faire économiser 5 octets supplémentaires. Aussi que fait 'lst' dans votre version sans-golf?
rnso
@rnso: Supprimé, était un vestige de quand rotmuleffectivement pris en wparamètre.
Ultimate Hawk
Vous pouvez également supprimer "raquette #lang" de la version avec golf. La plupart des codes de raquette de ce site ne l'incluent pas lors du décompte d'octets.
rnso
4

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}

PoshWaves

beatcracker
la source
Bonne réponse! Certains golfs - en utilisant le spécificateur de format décimal à la place de .PadLeft, déplacez la $odéclaration dans l' [convert]appel et éliminez les guillemets autour des nombres dans les -replaceop. Vous fait descendre à 175 -for(){0..5|%{("{0:D16}"-f+[Convert]::ToString(([uint16]$o=$w[$_]),2))*5-replace0,' '-replace1,'*'
AdmBorkBork
@AdmBorkBork Merci! Désolé d'avoir mis un certain temps à mettre à jour la réponse. Pourriez-vous expliquer +dans le "{0:D16}"-f+[Convert]? Ça ne marche pas sans ça, mais je ne peux pas dire ce que ça fait.
beatcracker
Le [convert]::ToString()retourne une chaîne. Le +force un transtypage sur une [int]sorte qui -fsélectionne le type de paramètre correct pour le D16travail.
AdmBorkBork
1
@AdmBorkBork Vous voulez dire que PS traite +'1'comme une opération valide sans arithmétique premier terme, moulages stringà intet renvoie le résultat? Super Scott!
beatcracker
3

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.

Yoann
la source
L' utilitaire Coreutils base64 ne prend pas en charge l'indicateur -D (doit être -d, minuscule à la place).
zeppelin
Vous pouvez économiser environ 10 octets en utilisant un fichier brut LZMA (xz) au lieu de gzip (compressez-le avec lzma -Fraw , décompressez-le avec xz -qdFraw ).
zeppelin
Vous pouvez également utiliser une syntaxe d'expansion arithmétique plus ancienne, $ [] , à la place de $ (()) , pour enregistrer 4 octets supplémentaires
zeppelin
Un zéro non significatif peut être omis dans la commande de veille, c'est-à-dire que sommeil .1 devrait fonctionner très bien
zeppelin
Vous pouvez également vous débarrasser de la déclaration explicite i = 0
zeppelin
3

*> <> , 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
Redstarcoder
la source
2

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.

Titus
la source
2

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.

entrez la description de l'image ici

ngenisis
la source
Quel logiciel avez-vous utilisé pour créer une capture et créer un fichier gif?
rnso
J'ai utilisé ScreenToGif.
ngenisis
2

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);}}
ajxs
la source
1
C'est le C dans votre terminal.
Robert Fraser
2

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);
ajxs
la source
Vous pouvez également enregistrer 2 octets avec setInterval(a=>{...},100,6)et 4 autres avec f+=" *"[[...][a]&1<<(i+x)%16].
ETHproductions
Merci pour les suggestions! Mais êtes-vous certain de pouvoir faire fonctionner votre deuxième suggestion? Vous devrez toujours contraindre cette valeur à un booléen pour récupérer l'index de tableau 0-1. Je pensais à un bitmapping plus poussé de la vague ascii en une seule valeur hexadécimale: 0x801F606018C007C000F0000C mais Javascript ne peut décaler de 31 bits au maximum dans un sens ou dans l’autre! Vous apprenez quelque chose tous les jours!
ajxs
2

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;}
bb94
la source
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)
Dfernan
la source
print("\x1b[0;H")travaille également pour moi pour -1 octet.
Redstarcoder
Vous pouvez remplacer ' **'par ' '*13+'**'et vous pouvez avoir 1 retrait de caractère dans le temps, pas besoin de 4 caractères.
PascalVKooten
@PascalvKooten merci. Les retraits ont été transformés en espaces à partir de caractères de tabulation lors du collage. Je veillerai à faire attention à cela.
dfernan
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:

entrez la description de l'image ici

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

rnso
la source
1

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
Stefan
la source
1

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

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.

Dom Hastings
la source
1

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

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}
Tom Lazar
la source
Bien que votre code fonctionne bien, veuillez noter que, selon les règles du site, ce n'est pas encore une solution valable: «Toutes les solutions aux défis doivent: (…) être un sérieux prétendant aux critères gagnants utilisés. Par exemple, une entrée à un concours de golf de code doit être jouée au golf, (…) ”- centre d'aide Voir Conseils pour jouer au golf en Ruby pour quelques conseils.
Manatwork
Quoi qu'il en soit, une brève liste: supprimez l'indentation; do … end{ … }et supprimez les nouvelles lignes après {et avant }; supprime l'espace entre systemet son paramètre; supprime le ,dernier élément du tableau après le tableau; .each.mapet supprimez l'espace entre celui-ci et son bloc de code; enlever l'espace devant puts; 0..800,80(il s'agit également d'un bogue, car votre expression génère une chaîne de 81 caractères); p=p+1==16?0: p+1p=-~p%16.
Manatwork
Yepp, l'explication stupide de manatwork a encore frappé. Même en changeant do … end{ … }, le loopmot - clé est toujours nécessaire . C'est le plus court que je reçoive: pastebin.com/cg3gxnm4
manatwork
Vous pouvez économiser 5 ou 6 octets en définissant b=' '(5 espaces vides) en haut, puis en modifiant l'expression de sortie en ' '*12+'** ', ' '*8+'**** ',b+'***** '+b,' ** ** '+b,' ** **'+b,'*'+b+b+'*****'... (mais SE
n'affiche
0

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.

FireCubez
la source