O mar no seu terminal

46

fundo

O verão acabou no Hemisfério Norte, e muitos de nós sentimos falta do sol, das praias, das ondas do oceano ... Esse desafio visa animá-los, lembrando-os do mar.

O desafio

Aqui está o mar:

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

O mar é constituído por 5 vezes esse padrão de onda:

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

Observe que o padrão tem 16 caracteres e o mar tem 5 vezes esse padrão = 80 caracteres.

Que você pode imprimir em um terminal usando esta linha de comando:

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

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

(O segundo deve facilitar a obtenção do padrão exato)

Sua tarefa é exibir o mar em um terminal e parecer que as ondas estão se movendo para a direita: ele precisa mudar para a direita a uma velocidade de 1 caractere a cada 100ms (= 10 vezes a cada segundo). Nenhum caractere deve ser impresso após a coluna 80, mas, à medida que a onda mais à direita desaparece, um novo aparece à esquerda.
Aqui está um exemplo de saída:

time = 0.0s

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

time = 0.1s

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

time = 0.2s

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

time = 0.3s

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

time = 0.4s

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

Obviamente, cada saída deve substituir a anterior.

Você pode executar esse código em um terminal unix para ver como deve ficar com a animação:

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

(Observe que este código não é muito bom para golfe: eu apenas o compacto o suficiente para ser conveniente para rodar em um terminal.)

Critério de vitória

Este é o codegolf, e o código mais curto em bytes ganha.

dada
fonte
2
Podemos iniciar a animação em qualquer quadro?
Arnauld
2
05ab1e.tryitonline.net/… muito ruim 05AB1E não pode animar, isso teria sido curto.
Magic Octopus Urn
2
@ Arnauld Sim, você pode.
Dada
2
Oh, você está certo! Estes são verdadeiros lambdas
Luis Mendo
14
"O verão acabou", isso é muito o seu hemisfério norte.
9789 Mike #

Respostas:

18

MATL , 41 40 bytes

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

Exemplo de execução:

insira a descrição da imagem aqui

Ou tente no MATL Online! (a velocidade real pode depender da carga do servidor).

Como 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
fonte
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
fonte
Qual é a função da variável a?
Kritixi Lithos
O @KritixiLithos amantém o padrão de onda codificado em binário e é rotacionado em cada quadro. Portanto, não pode ser codificado: ele precisa ser armazenado em uma variável.
Arnauld
16

HTML + CSS, 70 + 181 175 = 245 bytes

Faz uso de text-shadow, rtltexto e quadro-chave CSS animações.

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

C # 450 444 425 417 bytes

399 sem, using System.Linq;mas tenho certeza que seria trapaça ...

Edit: Saved 25 Bytes graças a @Cyoce

Golfe:

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

insira a descrição da imagem aqui

Pete Arden
fonte
1
Eu acho que você pode remover os parênteses (a)=>. E while(true)pode serfor(;;)
Cyoce
1
Para o slambda, acho que você pode remover o {}ereturn
Cyoce 9/16
Trabalhei em ambos, me dando uma economia de 25 bytes no total, obrigado! :)
Pete Arden
Você pode tornar sua função inteira uma lambda. Eu acho que você também pode remover a \rpartir do string.Join(pelo menos no Windows funciona, não testá-lo com Mono embora) Você também pode salvar 1 byte, colocando p++no forloop como estefor(;;p++)
Stefan
Para remover a verificação de limite na parte inferior ( if (p==16)...), você também pode colocá-la no cabeçalho do loop for como este for(;;p=++p%16). Economize mais 1 byte, declarando pno loop ( for(int p=0;;p=++p%16))
Stefan
7

V, 98 97 73 bytes

Obrigado a @ nmjcman101 por salvar 24 bytes!

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

Isso contém muitos imprimíveis, então aqui está um hexdump do xxd:

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 em y$vez de<C-v>$y

  2. Muitas mudanças

    • Em vez de copiar cada linha e colá-las 4 vezes, primeiro giro a onda e, em seguida, copio a coisa toda e colo-a 4 vezes
    • Usado {e }para economizar alguns bytes
    • Usado em òvez de registradores para criar o loop infinito (por algum motivo, preciso incluir um òno final para que ele funcione)
    • fixou a estática *na parte inferior

Mini-explicação

Estou usando <alt-n>para criar cópias de strings. Por exemplo, <alt-5>*(isso parece µ5) faz 5cópias *no modo de inserção. Achei isso mais curto do que copiar a string e usar um regex para fazer as substituições necessárias. Depois de criar uma onda, colo-a para criar as outras ondas. Por fim, faço um loop recursivamente usando òpara criar o loop infinito (com um atraso de 100ms).

Gif

A maior parte do código é dedicada à criação da onda, então ainda estou tentando jogar isso. Observe que esse código não funcionará no TIO, pois o TIO somente gera a saída após o término da execução. Então, aqui está um gif (desculpe pela baixa qualidade, eu tive que usar um site para converter um .movpara um .gif, também o >_que continua aparecendo à direita é o ícone do Terminal no dock do meu mac):

gif de onda

Kritixi Lithos
fonte
Eu tenho muito pouca idéia sobre como seus funky repetindo números trabalho, mas se você fizer uma onda, e, em seguida, cópia de bloco / colá-lo, você pode economizar caracteres (em vez de cópia colando cada linha 4 vezes) Link para TryItOnline
nmjcman101
Menos útil, acho que o seu 5j(no contexto de $<C-V>5j) poderia ser apenas }, e o pdepois do |deve ser um Pque fixará a estática *no canto inferior esquerdo.
nmjcman101
1
Finalmente (desculpe pelo spam de comentários, aparentemente eles são editáveis ​​por 5 minutos), você pode substituir o qm[CODE]@mq@mno final por apenas ò[CODE]. O código entre òserá executado em loop até a quebra (de maneira semelhante à sua macro) e, no final de um programa, um òé implicitamente fechado.
nmjcman101
@ nmjcman101 Obrigado por tudo que você ajuda! (não é spam de comentários se você está me ajudando golf alguns 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

Algumas linhas têm espaços à direita. Requer um terminal padrão de 80 colunas. O tempo não é muito preciso, mas é o melhor que você pode fazer no Lote.

Neil
fonte
6

Raquete 395 374 373 367 364 351 bytes

Usa uma biblioteca externa para limpar a tela
Editar: salvou 21 bytes por não definir we incluir a função.
Edit2: salvou 1 byte removendo um espaço.
Edit3: salvou 6 bytes renomeando looppara p, obrigado @rnso!
Edit4: Colocando substring na lista, economizando 3 bytes.
Edit5: Remove #lang racket, o que não é necessário no intérprete.

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

Rolagem (sem limpeza): 272 bytes

[let p([n 1])[for([i'["            **  ""        ****    ""     *****      ""   **   **      "" **      **     ""*          *****"]])[let([g substring][x[string-join[make-list 5 i]""]])[displayln[string-append[g x[- 16 n]][g x 0[- 16 n]]]]]][sleep .1][p[modulo[+ n 1]16]]]

Ungolfed:

#lang racket
[require [planet neil/charterm:3:0]]
[define w
'[
"            **  "
"        ****    "
"     *****      "
"   **   **      "
" **      **     "
"*          *****"]]
[define (rotmul count)
  [for ([i w])
    [let ([x [string-join [make-list 5 i] ""]])
      [displayln [string-append [substring x count]
                                [substring x 0 count]]]]]]

[let loop ([n 1])
  [with-charterm
   [void [charterm-clear-screen]]]
  [rotmul [- 16 n]]
  [sleep .1]
  [loop [modulo [+ n 1] 16]]]

Ondas

Ultimate Hawk
fonte
Renomear nomes para nomes mais curtos (como p em vez de loop) pode ser feito para reduzir bytes. Qual software você usou para capturar vídeo em arquivo gif?
Decreto
@rnso: Oh, você está certo! Não pensei nisso. Eu usei simplescreenrecordercom avconvpara converter mp4 para gif.
Ultimate Hawk
Você pode colocar (g substring) em let para poder usar g no lugar de duas palavras-chave de substring posteriormente no código. Isso deve economizar mais 5 bytes. Além disso, o que 'lst' está fazendo na sua versão não-destruída?
rnso
@rnso: Removido, era um remanescente de quando rotmulrealmente foi capturado wcomo parâmetro.
Ultimate Hawk
Você também pode remover "#lang raquete" da versão em golfe. A maioria dos códigos de raquete deste site não o inclui durante a contagem de bytes.
rnso
4

PowerShell 3.0, 183 182 173 bytes

Requer PS 3.0 para operadores de turno binário. Reduziu para 173 bytes com a ajuda do 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
fonte
Boa resposta! Alguns jogadores de golfe - usando o especificador de formato decimal em vez de .PadLeft, mova a $odeclaração para a [convert]chamada e elimine as aspas ao redor dos números nas -replaceoperações. Obtém-lo para baixo para 175 -for(){0..5|%{("{0:D16}"-f+[Convert]::ToString(([uint16]$o=$w[$_]),2))*5-replace0,' '-replace1,'*'
AdmBorkBork
@AdmBorkBork Thanks! Desculpe, demorei bastante para atualizar a resposta. Você poderia explicar +no "{0:D16}"-f+[Convert]? Ele não funciona sem ele, mas não consigo entender o que faz.
Beatcracker
O [convert]::ToString()retorna uma string. As +forças de um elenco para um [int]modo que -fpega o tipo de parâmetro correto para o D16ao trabalho.
AdmBorkBork 8/17/17
1
@AdmBorkBork Você quer dizer que trata PS +'1'como uma operação aritmética válida sem primeiro summand, moldes stringpara inte retorna o resultado? Grande Scott!
Beatcracker
3

Bash + coreutils, 172 148 bytes

24 bytes salvos graças a @zeppelin , muito obrigado

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

A primeira linha descomprime o seguinte padrão composto por 6 ondas consecutivas:

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

Em seguida, o loop desliza uma janela de 80 bytes de largura por esse padrão.

yoann
fonte
O utilitário Coreutils base64 não suporta sinalizador -D (deve ser -d, em minúsculas).
Zeppelin
Você pode salvar ~ 10 bytes usando LZMA bruto (xz), em vez de gzip (comprima com lzma -Fraw , descompacte com xz -qdFraw ).
Zeppelin
Você também pode usar uma sintaxe de expansão aritmética mais antiga $ [] , em vez de $ (()) , para economizar mais 4 bytes
zeppelin
Um zero à esquerda podem ser omitidos no comando sono, ou seja sono .1 deve funcionar muito bem
zeppelin
Você também pode se livrar da declaração i = 0 explícita
zeppelin
3

*> <> , 251 250 251 bytes (não concorrente)

" **             "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["é suposto ter ascii 27depois [.

Experimente aqui! (defina o atraso para 0 ms)

Não acredito que acabei fazendo isso com sucesso. Isso usa as instruções Ie D, que aumentam ou diminuem a pilha selecionada. Isso demonstra que provavelmente é possível fazer isso em pura> <> (menos o sono) ou em uma resposta competitiva *> <>, embora provavelmente seja muito mais difícil de fazer.

A versão do intérprete on-line é diferente simplesmente para limpar a saída usando um retorno de carro.

Isto é não concorrentes, porque os I, D, C, e Rinstruções são mais jovens do que o desafio. Provavelmente isso é possível sem essas instruções, mas seria muito difícil / longo.

Edit: Eu realmente consegui remover um byte, mas também notei que medi o tamanho errado, então, na verdade, ganhei um byte.


Eu farei o meu melhor para quebrar as etapas e explicar o que está acontecendo aqui ...

Explicação

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

Índice

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)

Inicialização

Aqui construímos as 6 linhas que constroem as ondas. Precisamos repetir cada corda 5 vezes para ter o comprimento correto.

Começamos com 6, um para cada linha da onda:

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

E entramos no loop principal após a inicialização 09..

Copiar pilha atual 4 vezes

Esta é uma função simples que simplesmente pega a pilha atual e a copia 4 vezes. Então "a" se tornaria "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

Pilha de cópias

Isso copia a pilha atual, acrescentando a cópia à pilha atual.

Configuração

Ir para pular a inicial <e inverter a primeira linha para se tornar, l:&0vpois é a ordem em que é executada após as <alterações na direção do 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

Daqui em diante, o comprimento será referido como ne o 0as i.

Ciclo

>                        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

Limpar

>                        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

Loop principal

Aqui é onde o código funciona para sempre, redesenhando constantemente as ondas entre 100ms e dorme.

Configuração

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 

Ciclo

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

Não é possível animar mais de uma linha, mas ela rola.
Adicione ,0à matriz uma linha vazia entre iterações. Corra com -r.

Titus
fonte
2

Mathematica, 213 bytes

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

Não vejo nenhuma maneira de jogar golfe no padrão de ondas do Mathematica além de começar com uma lista de strings para cada linha. I inicializar iser 0e agendar uma tarefa para incrementá-lo a cada 0.1segundos. Eu também Dynamicexibo o resultado do seguinte:

  1. StringRepeat cada linha 5 vezes.
  2. Converta cada linha em uma lista dele Characters.
  3. RotateRightcada lista de caracteres por i.
  4. Exiba a matriz de caracteres resultante como a Grid.

insira a descrição da imagem aqui

ngenisis
fonte
Qual software você usou para criar capturar e criar um arquivo gif?
rnso
Eu usei ScreenToGif.
Ngenisis
2

C (unix), 231191 bytes

Isso funcionará apenas em ambientes unix. Além disso, desculpe o fato de que o sono aceita apenas números inteiros ... para atrasar 1 segundo entre os quadros.

Versão não destruída:

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

Versão Golfed:

#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
fonte
1
Esse é o C no seu 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
fonte
Você também pode salvar 2 bytes com setInterval(a=>{...},100,6)e mais 4 com f+=" *"[[...][a]&1<<(i+x)%16].
ETHproductions
Obrigado pelas sugestões! Mas você tem certeza de que pode fazer sua segunda sugestão funcionar? Você ainda precisará coagir esse valor a um booleano para recuperar o índice de matriz 0-1. Eu estava pensando em um bitmap adicional do ascii de onda em um único valor hexadecimal: 0x801F606018C007C000F0000C, mas o Javascript pode apenas mudar bit a bit um máximo de 31 bits em qualquer direção! Você aprende algo todo dia!
ajxs
2

Perl 6, 140 138 137 137 120 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}

Soluções antigas:

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

Python 3, 240 239 230 bytes

-1 byte graças a @redstarcoder

-9 bytes graças 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
fonte
print("\x1b[0;H")também funciona para mim para -1 byte.
Reddarcoder
Você pode substituir ' **'por ' '*13+'**'e pode ter 1 recuos de caracteres enquanto isso, sem a necessidade de ter 4 caracteres.
PascalVKooten
@PascalvKooten thanks. Os recuos foram transformados em espaços a partir de caracteres de tabulação durante a colagem. Eu vou ter cuidado com isso.
dfernan
1

Raquete 295 bytes

(let*((g string-append)(h substring)(d displayln)(j(λ(l)(map(λ(x)(g(h x 1)(h x 0 1)))l))))(let p((l(map(λ(x)(apply g(for/list((i 5))x)))'("            **  ""         ****   ""      *****     ""    **   **     ""  **      **    ""*          *****"))))(for((i l))(d i))(d"")(sleep .1)(p(j l))))

Ungolfed:

(define(f)
 (define (lf l)
    (map (λ (x) (string-append (substring x 1) (substring x 0 1)))
         l))
  (let loop ((l (map (λ (x) (apply string-append (for/list ((i 5)) x)) )
                     (list 
                      "            **  "
                      "         ****   "
                      "      *****     "
                      "    **   **     "
                      "  **      **    "
                      "*          *****"))))
    (for ((i l))
      (displayln i))
    (displayln "")
    (sleep 0.1)
    (loop (lf l))))

Testando:

(f)

Resultado:

insira a descrição da imagem aqui

(Essa exibição do arquivo gif é mais lenta que a saída real).

rnso
fonte
1

Python 2, 207 202 bytes

Normalmente, sou desenvolvedor de C #, portanto, talvez ainda não esteja completamente interessado nisso ...

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

C #, 327 bytes

Mais ou menos uma versão portada da minha solução em 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
fonte
1

Perl, 110 bytes

Requer -Esem custo extra. Isso contém caracteres não imprimíveis.

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

Crie os dados acima usando o hexdump reversível abaixo. Execute xxd -d > sea.plem um linux ou terminal compatível, cole o abaixo e pressione Ctrl+ d, depois execute 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 facilitar a cópia / colagem, use o seguinte:

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

Explicação

Uma solução bastante simples que armazena a onda como uma string no início, que é unpackeditada em binária, cada seção é quintuplicada, 0s são convertidos em espaços e 1s são convertidos em *s. Agora temos a string inteira, então inserimos um redoloop que imprime a string inteira, depois esperamos 0,1 segundos e, para cada linha da string, movemos o último caractere para o início da string.

Dom Hastings
fonte
1

Mathematica 171 Bytes

A onda em si é um dado, então estou armazenando uma versão compactada de toda a onda no meu código. Eu posso armazenar uma única onda de maneira muito mais compacta, \fð߀ᣀ恠耟usando a representação binária, mas a sobrecarga de contagem de caracteres da descompressão é muito alta *.

Aqui está o código:

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

Aqui está o código que eu usei para criar a versão compactada dos dados da onda:

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

Aqui está o código que eu preferiria usar para armazenar dados binários repetidos compactados como esta onda:

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

Como você pode ver, a sobrecarga para transformar os dados compactados novamente em uma sequência é muito cara para esse problema específico, embora uma única onda possa ser armazenada dessa maneira com 7 caracteres UTF e 15 bytes.

Aqui estava o código para determinar a sequência de caracteres UTF para armazenar uma única onda (s como acima).

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

Ruby 269 217 189 185 Bytes

-28 Bytes graças a @manatwork

-5 Bytes graças 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

Golfe

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
fonte
Embora seu código funcione bem, observe que, de acordo com as regras do site, ela ainda não é uma solução válida: “Todas as soluções para os desafios devem: (…) Ser um candidato sério aos critérios vencedores em uso. Por exemplo, uma entrada para um concurso de código de golfe precisa ser disputada, (...) ”- Central de Ajuda Veja dicas para jogar golfe em Ruby para obter algumas dicas.
manatwork
Enfim, uma breve lista: remova o recuo; do … end{ … }e remova as novas linhas {antes e depois }; remova o espaço entre systeme seu parâmetro; remova o ,último elemento do literal depois da matriz; .each.mape remova o espaço entre ele e seu bloco de código; remova o espaço na frente de puts; 0..800,80(isso também é um erro, pois a expressão resulta em 81 caracteres); p=p+1==16?0: p+1p=-~p%16.
manatwork
Sim, a explicação idiota da manatwork ataca novamente. Mesmo mudando do … end{ … }, ainda há necessidade da looppalavra - chave. Este é o mais curto que recebo: pastebin.com/cg3gxnm4
manatwork
Pode salvar 5 ou 6 bytes por definição b=' '(5 espaços em branco) no topo, em seguida, alterando a expressão de saída para ' '*12+'** ', ' '*8+'**** ',b+'***** '+b,' ** ** '+b,' ** **'+b,'*'+b+b+'*****'... (mas SE não está mostrando espaços repetidos corretamente em este comentário!)
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>

O JavaScript apenas muda cada linha por 1 e altera o texto a cada 100 ms.

FireCubez
fonte