El mar en tu terminal

46

Antecedentes

El verano ha terminado en el hemisferio norte, y muchos de nosotros extrañamos el sol, las playas, las olas del océano ... Este desafío tiene como objetivo animarlos recordándoles el mar.

El reto

Aquí está el mar:

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

El mar está hecho de 5 veces este patrón de onda:

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

Tenga en cuenta que el patrón tiene 16 caracteres de longitud y el mar tiene 5 veces este patrón = 80 caracteres de longitud.

Que puede imprimir en un terminal usando esta línea de comando:

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

O este :

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

(El segundo debería facilitarle obtener el patrón exacto)

Su tarea es mostrar el mar en una terminal y hacer que parezca que las olas se mueven hacia la derecha: debe desplazarse hacia la derecha a una velocidad de 1 carácter cada 100 ms (= 10 veces cada segundo). No se debe imprimir ningún carácter después de la columna 80, pero a medida que desaparece la onda más a la derecha, aparece una nueva a la izquierda.
Aquí hay un ejemplo de salida:

tiempo = 0.0s

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

tiempo = 0.1s

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

tiempo = 0.2s

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

tiempo = 0.3s

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

tiempo = 0.4s

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

Por supuesto, cada salida debe reemplazar a la anterior.

Puede ejecutar este código en un terminal Unix para ver cómo debería verse con la animación:

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

(Tenga en cuenta que este código no está muy bien desarrollado: solo lo hice lo suficientemente compacto como para que sea conveniente ejecutarlo en una terminal).

Criterio ganador

Esto es codegolf, por lo que gana el código más corto en bytes.

Dada
fuente
2
¿Podemos comenzar la animación en cualquier marco?
Arnauld
2
05ab1e.tryitonline.net/... lástima 05AB1E no puede animar, eso habría sido corto.
Urna de pulpo mágico
2
@Arnauld Sí, puedes.
Dada
2
Oh tienes razon! Estas son verdaderas lambdas
Luis Mendo
14
"El verano ha terminado", eso es muy del hemisferio norte.
MikeTheLiar

Respuestas:

18

MATL , 41 40 bytes

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

Ejemplo de ejecución:

ingrese la descripción de la imagen aquí

¡O pruébalo en MATL Online! (la velocidad real puede depender de la carga del servidor).

Cómo funciona

`                    % 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
fuente
19

JavaScript (ES6) + HTML, 151 143 + 10 = 161 153 bytes

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
fuente
¿Cuál es la función de la variable a?
Kritixi Lithos
@KritixiLithos acontiene el patrón de onda codificado en binario y se gira en cada cuadro. Por lo tanto, no se puede codificar: debe almacenarse en una variable.
Arnauld
16

HTML + CSS, 70 + 181 175 = 245 bytes

Hace uso de text-shadow, rtlanimaciones de texto y de fotogramas clave CSS.

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
fuente
9

C # 450 444 425 417 Bytes

399 sin using System.Linq;pero estoy seguro de que sería trampa ...

Editar: 25 bytes guardados gracias a @Cyoce

Golfizado:

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

Sin golf:

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

ingrese la descripción de la imagen aquí

Pete Arden
fuente
1
Creo que puedes quitar los paréntesis (a)=>. Y while(true)puede serfor(;;)
Cyoce
1
Para el slambda, creo que puedes eliminar el {}yreturn
Cyoce
Trabajé en ambos, dándome un ahorro de 25 bytes en total, ¡gracias! :)
Pete Arden
Puede hacer que toda su función sea una lambda. Creo que también puede eliminar el \rde string.Join(al menos en Windows funciona, aunque no lo probó con Mono) También puede guardar 1 byte al ponerlo p++en el forbucle de esta manerafor(;;p++)
Stefan
Para eliminar la verificación de límites en la parte inferior ( if (p==16)...), también puede colocarla en el encabezado del bucle for de esta manera for(;;p=++p%16). Ahorre 1 byte más declarando pen el bucle ( for(int p=0;;p=++p%16))
Stefan
7

V, 98 97 73 bytes

¡Gracias a @ nmjcman101 por guardar 24 bytes!

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

Esto contiene muchos no imprimibles, así que aquí hay 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...

Editar

  1. Usado en y$lugar de<C-v>$y

  2. Muchos cambios

    • En lugar de copiar cada línea y pegarlas 4 veces, primero genero la onda y luego copio todo y lo pego 4 veces
    • Usado {y }para guardar algunos bytes
    • Se usa en òlugar de registros para crear el bucle infinito (por alguna razón tengo que incluir un òal final para que funcione)
    • arregló la estática *en la parte inferior

Mini-Explicación

Estoy usando <alt-n>para crear copias de cadenas. Por ejemplo, <alt-5>*(esto parece µ5) hace 5copias de *en modo de inserción. Esto me pareció más corto que copiar la cadena y usar una expresión regular para hacer los reemplazos necesarios. Después de crear una ola, la pego para crear las otras olas. Finalmente, realizo un ciclo recursivo òpara crear el ciclo infinito (con un retraso de 100ms).

GIF

La mayor parte del código está dedicado a crear la ola, por lo que todavía estoy intentando jugar golf. Tenga en cuenta que este código no funcionará en TIO ya que TIO solo genera la salida una vez que el código ha finalizado la ejecución. Así que aquí hay un gif (perdón por la baja calidad, tuve que usar un sitio web para convertir un .mova .gif, también el >_que sigue apareciendo a la derecha es el ícono de Terminal en el muelle de mi Mac):

ola gif

Kritixi Lithos
fuente
Tengo muy poca idea sobre cómo funcionan los números que se repiten, pero si haces una onda y luego bloqueas copiar / pegar, puedes guardar caracteres (en lugar de copiar pegando cada línea 4 veces) Enlace a TryItOnline
nmjcman101
Menos útil, creo que su 5j(en el contexto de $<C-V>5j) podría ser }, y pdespués de eso |debería ser un Pque reparará la estática *en la parte inferior izquierda.
nmjcman101
1
Finalmente (perdón por los comentarios no deseados, aparentemente son editables durante 5 minutos) puede reemplazarlos qm[CODE]@mq@mal final con solo ò[CODE]. El código entre se òrepetirá hasta que se rompa (de manera similar a su macro), y al final de un programa òse cierra implícitamente.
nmjcman101
@ nmjcman101 ¡Gracias por toda su ayuda! (no es spam de comentarios si me está ayudando a jugar al golf unos pocos bytes :)
Kritixi Lithos
6

Lote, 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

Algunas líneas tienen espacios finales. Requiere un terminal estándar de 80 columnas. El momento no es muy preciso, pero es lo mejor que puedes hacer en Batch.

Neil
fuente
6

Raqueta 395 374 373 367 364 351 bytes

Utiliza una biblioteca externa para borrar la pantalla
Editar: guardado 21 bytes al no definir we incluir la función.
Edit2: guardado 1 byte eliminando un espacio.
Edit3: guardado 6 bytes cambiando el nombre loopa p, gracias @rnso!
Edit4: colocando la subcadena en dejar de guardar 3 bytes.
Edit5: Eliminar #lang racket, que no es necesario en el intérprete.

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

Desplazamiento (sin borrar): 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]]]

Sin golf:

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

Olas

Halcón supremo
fuente
Se puede cambiar el nombre de los nombres más cortos (como p en lugar de bucle) para reducir los bytes. ¿Qué software usaste para capturar video en un archivo gif?
rnso
@rnso: ¡Oh, tienes razón! No pensé en eso. He utilizado simplescreenrecordercon avconvconvertir mp4 a GIF.
Ultimate Hawk
Puede poner (g subcadena) en let para que pueda usar g en lugar de 2 palabras clave de subcadena más adelante en el código. Eso debería ahorrarte otros 5 bytes. Además, ¿qué está haciendo 'lst' en tu versión sin golf?
rnso
@rnso: eliminado, era un remanente de cuando rotmulrealmente se tomó wcomo parámetro.
Ultimate Hawk
También puede eliminar "#lang racket" de la versión de golf. La mayoría del código de Racket en este sitio no lo incluye al contar bytes.
rnso 12/12/2016
4

PowerShell 3.0, 183 182 173 bytes

Requiere PS 3.0 para operadores de desplazamiento binario. ¡Reducido a 173 bytes con la ayuda de 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
fuente
¡Buena respuesta! Algunos campos de golf: utilizando el especificador de formato decimal en lugar de .PadLeftmover la $odeclaración a la [convert]llamada y eliminar las comillas alrededor de los números en las -replaceoperaciones. Te for(){0..5|%{("{0:D16}"-f+[Convert]::ToString(([uint16]$o=$w[$_]),2))*5-replace0,' '-replace1,'*'
lleva
@AdmBorkBork ¡Gracias! Lamento que me haya llevado bastante tiempo actualizar la respuesta. ¿Podrías explicar +en el "{0:D16}"-f+[Convert]? No funciona sin él, pero no puedo entender lo que hace.
beatcracker
El [convert]::ToString()devuelve una cadena. Las +fuerzas de un molde a una [int]para que los -frecoge el tipo de parámetro correcto para la D16que trabajo.
AdmBorkBork
1
@AdmBorkBork ¿Quiere decir que trata PS +'1'como una operación aritmética válida sin primer sumando, vaciados stringa inty devuelve un resultado? ¡Gran Scott!
beatcracker
3

Bash + Coreutils 172 148 bytes

24 bytes guardados gracias a @zeppelin , muchas gracias

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

La primera línea descomprime el siguiente patrón formado por 6 ondas consecutivas:

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

Luego, el bucle desliza una ventana de 80 bytes de ancho a través de ese patrón.

yoann
fuente
La utilidad baseutils de Coreutils no admite el indicador -D (debería ser -d, en minúscula).
zeppelin
Puede guardar ~ 10 bytes utilizando LZMA sin procesar (xz), en lugar de gzip (comprimir con lzma -Fraw , descomprimir con xz -qdFraw ).
zepelín
También puede usar una sintaxis de expansión aritmética anterior $ [] , en lugar de $ (()) , para guardar 4 bytes más
zeppelin
Se puede omitir un cero inicial en el comando de suspensión, es decir, la suspensión .1 debería funcionar bien
zeppelin
También puede deshacerse de la declaración explícita i = 0
zeppelin
3

*> <> , 251 250 251 bytes (no competitivos)

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

Nota: "H;0["se supone que tiene ascii 27después [.

Pruébalo aquí! (establecer retraso a 0 ms)

No puedo creer que terminé haciendo esto con éxito. Utiliza las instrucciones Iy D, que aumentan o disminuyen la pila seleccionada. Esto demuestra que probablemente sea posible hacer esto en puro> <> (menos el sueño) o una respuesta competitiva *> <>, aunque probablemente sea mucho más difícil de hacer.

La versión del intérprete en línea es diferente simplemente para borrar la salida utilizando un retorno de carro.

Esto es porque no compitiendo los I, D, C, y Rlas instrucciones son más jóvenes que el reto. Probablemente esto sea posible sin esas instrucciones, pero sería muy difícil / largo.

Editar: en realidad logré eliminar un byte, pero también noté que medí el tamaño incorrectamente, así que en realidad gané un byte.


Haré todo lo posible para desglosar los pasos y explicar lo que está sucediendo aquí ...

Explicación

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

Tabla de contenido

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)

Inicialización

Aquí construimos las 6 líneas que construyen las olas. Necesitamos repetir cada cuerda 5 veces para tener la longitud correcta.

Comenzamos con 6 de estos, uno para cada línea de la onda:

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

Y entramos en el bucle principal después de la inicialización 09..

Copiar pila actual 4 veces

Esta es una función simple que simplemente toma la pila actual y la copia 4 veces. Entonces "a" se convertiría en "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

Copiar pila

Esto copia la pila actual, agregando la copia a la pila actual.

Preparar

Saltará la inicial <e invertirá la primera línea para que se convierta, l:&0vya que es el orden en que se ejecuta después de que <cambia la dirección de la 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

De aquí en adelante, la longitud se denominará como ny 0como i.

Lazo

>                        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

Limpiar

>                        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

Bucle principal

Aquí es donde el código se ejecuta para siempre, redibujando constantemente las olas entre 100 ms duerme.

Preparar

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 

Lazo

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

No puede animar más de una línea, pero se desplaza.
Agregue ,0a la matriz una línea vacía entre iteraciones. Corre con -r.

Titus
fuente
2

Mathematica, 213 bytes

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

No veo ninguna forma de jugar golf en el patrón de onda en Mathematica que no sea simplemente comenzar con una lista de cadenas para cada línea. Inicializo iser 0y programo una tarea para incrementarla cada 0.1segundo. Me Dynamicaliado mostrará el resultado de lo siguiente:

  1. StringRepeat cada línea 5 veces.
  2. Convierta cada línea en una lista de sus Characters.
  3. RotateRightcada lista de caracteres por i.
  4. Mostrar la matriz resultante de caracteres como a Grid.

ingrese la descripción de la imagen aquí

ngenisis
fuente
¿Qué software usaste para crear captura y crear archivos gif?
rnso
Usé ScreenToGif.
ngenisis
2

C (unix), 231 191 bytes

Esto solo funcionará en entornos Unix. Además, disculpe el hecho de que el sueño solo acepta números enteros ... por lo que en realidad demora 1 segundo entre fotogramas.

Versión sin golf:

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

Versión de golf:

#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
fuente
1
Esa es la C en tu 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
fuente
También puede guardar 2 bytes con setInterval(a=>{...},100,6)y 4 más con f+=" *"[[...][a]&1<<(i+x)%16].
ETHproductions
Gracias por las sugerencias! ¿Pero está seguro de que puede hacer que su segunda sugerencia funcione? Aún tendrá que forzar ese valor a un valor booleano para recuperar el índice de matriz 0-1. Estaba pensando en un mapa de bits adicional de la onda ascii en un solo valor hexadecimal: 0x801F606018C007C000F0000C, ¡pero Javascript solo puede cambiar bit a bit un máximo de 31 bits en cualquier dirección! ¡Aprendes algo cada día!
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}

Viejas soluciones:

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
fuente
1

Python 3, 240 239 230 bytes

-1 byte gracias a @redstarcoder

-9 bytes gracias a @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
fuente
print("\x1b[0;H")También funciona para mí por -1 byte.
redstarcoder
Puede reemplazar ' **'con ' '*13+'**'y puede tener sangrías de 1 carácter mientras tanto, no es necesario que sea de 4 caracteres.
PascalVKooten
@PascalvKooten gracias. Las sangrías se transformaron en espacios de caracteres de tabulación durante el pegado. Me aseguraré de tener cuidado con eso.
dfernan
1

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

Sin golf:

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

Pruebas:

(f)

Salida:

ingrese la descripción de la imagen aquí

(Esta visualización del archivo gif es más lenta que la salida real).

rnso
fuente
1

Python 2, 207 202 bytes

Por lo general, soy un desarrollador de C #, por lo que es posible que todavía no esté completamente desarrollado ...

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
fuente
1

C #, 327 bytes

Más o menos una versión portada de mi solución 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
fuente
1

Perl, 110 bytes

Requiere -Esin costo adicional. Este contiene caracteres no imprimibles.

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

Cree los datos anteriores utilizando el siguiente hexdump reversible. Ejecutar xxd -d > sea.plen un linux o terminal compatible, pegue el siguiente y presione Ctrl+ d, luego ejecute 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}

Uso

Para copiar / pegar fácilmente, utilice lo siguiente:

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

Explicación

Una solución bastante sencilla que almacena la onda como una cadena al principio, que se unpackedita en binario, cada sección se quintuplica, los 0s se convierten en espacios y 1s se convierten en *s. Ahora tenemos la cadena completa, por lo que ingresamos un redobucle que imprime la cadena completa, luego esperamos por .1 segundos y para cada línea de la cadena, movemos el último carácter al comienzo de la cadena.

Dom Hastings
fuente
1

Mathematica 171 Bytes

La onda en sí es información, por lo que estoy almacenando una versión comprimida de toda la onda en mi código. Puedo almacenar una sola onda de forma mucho más compacta ya \fð߀ᣀ恠耟que utilizo su representación binaria, pero la sobrecarga de conteo de caracteres de descompresión es demasiado alta *.

Aquí está el código:

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

Aquí está el código que usé para crear la versión comprimida de los datos de la onda:

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

Aquí está el código que hubiera preferido usar para almacenar datos binarios repetidos comprimidos como esta onda:

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

Como puede ver, la sobrecarga para volver a convertir los datos comprimidos en una cadena es demasiado costosa para este problema en particular, aunque una sola onda se puede almacenar de esta manera con 7 caracteres UTF y 15 bytes.

Aquí estaba el código para determinar la secuencia de caracteres UTF para almacenar una sola onda (s como arriba).

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

Rubí 269 217 189 185 Bytes

-28 Bytes gracias a @manatwork

-5 Bytes gracias a @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

Golfed

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
fuente
Aunque su código funciona bien, tenga en cuenta que, de acuerdo con las reglas del sitio, todavía no es una solución válida: “Todas las soluciones a los desafíos deberían: (...) Ser un competidor serio para los criterios ganadores en uso. Por ejemplo, una entrada a un concurso de golf de código debe ser golfizada, (...) "- centro de ayuda Vea Consejos para jugar golf en Ruby para obtener algunos consejos.
manatwork
De todos modos, una breve lista: eliminar sangría; do … end{ … }y elimine las nuevas líneas después {y antes }; eliminar el espacio entre systemy su parámetro; eliminar el ,último elemento del literal de matriz posterior; .each.mapy elimine el espacio entre este y su bloque de código; quitar el espacio en frente de puts; 0..800,80(esto también es un error ya que la expresión da como resultado una cadena larga de 81 caracteres); p=p+1==16?0: p+1p=-~p%16.
manatwork
Sí, la tonta explicación de Manatwork ataca de nuevo. Incluso cambiando do … end{ … }, todavía se necesita la looppalabra clave. Este es el más corto que obtengo: pastebin.com/cg3gxnm4
manatwork
Puede guardar 5 o 6 bytes configurando b=' '(5 espacios en blanco) en la parte superior y luego cambiando la expresión de salida a ' '*12+'** ', ' '*8+'**** ',b+'***** '+b,' ** ** '+b,' ** **'+b,'*'+b+b+'*****'... (¡pero SE no muestra espacios repetidos correctamente en este comentario!)
roblogic
0

HTML + JS + jQuery, 10 + 233 = 243 bytes

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>

El JavaScript simplemente cambia cada fila por 1 y cambia el texto cada 100 ms.

FireCubez
fuente