배경

여름은 북반구에서 끝나고 우리 중 많은 사람들이 태양, 해변, 바다의 파도를 그리워합니다 ...이 도전은 바다를 상기 시켜서 그들을 격려하는 것을 목표로합니다.

도전

바다는 다음과 같습니다.

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

바다는이 파도 패턴의 5 배로 구성됩니다.

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

패턴의 길이는 16 자이고 바다의 길이는이 패턴의 80 배입니다.

이 명령 행을 사용하여 터미널에 인쇄 할 수 있습니다.

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

또는 이것 :

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

(두 번째는 정확한 패턴을 쉽게 얻을 수 있도록해야합니다)

당신의 임무는 터미널에 바다를 표시하고 파도가 오른쪽으로 움직이는 것처럼 보이게하는 것입니다 .100ms마다 1 문자 속도로 = 오른쪽으로 이동해야합니다 (초당 10 번). 80 번째 열 이후에는 문자를 인쇄 할 수 없지만 가장 오른쪽의 물결이 사라지면 왼쪽에 새로운 물결이 나타납니다.
다음은 출력 예입니다.

시간 = 0.0 초

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

시간 = 0.1 초

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

시간 = 0.2 초

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

시간 = 0.3 초

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

시간 = 0.4 초

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

물론 각 출력은 이전 출력을 대체해야합니다.

이 코드를 유닉스 터미널에서 실행하여 애니메이션과 어떻게 보이는지 확인할 수 있습니다.

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

(이 코드는 잘 작동하지 않는다는 점에 유의하십시오. 터미널에서 쉽게 실행할 수있을 정도로 컴팩트하게 만들었습니다.)

승리 기준

이것은 codegolf이므로 바이트 단위로 가장 짧은 코드가 승리합니다.

MATL , 41 40 바이트

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

예제 실행 :

또는 MATL Online 에서 사용해보십시오 ! 실제 속도는 서버로드에 따라 달라질 수 있습니다.

작동 원리

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

자바 스크립트 (ES6) + HTML, 151 143 + 10 = 161 153 바이트

a=[48,15,57347,6147,1542,504];setInterval("a=a.map(n=>{for(x=-1;++x<80;)s+=' *'[n>>x%16&1];s+=`\n`;return n>>>15|n<<1},s='');O.innerHTML=s",99)

<pre id=O>

HTML + CSS, 70 + 181175 = 245 바이트

차종은의 사용 text-shadow, rtl텍스트와 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>**
  ****
    *****
    **   **
   **      **
***          ***

C 번호 450 444 425 417 바이트

399 없이는 using System.Linq;부정 행위가 될 것입니다 ...

편집 : @Cyoce 덕분에 25 바이트 절약

골프 :

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

언 골프 드 :

public void S()
{
  Func<string, string> r = a => string.Concat(Enumerable.Repeat(a, 5));
  Func<string, int, string> s = (b, i) => (b.Substring(16 - i) + b).Substring(0, 80);

  int p = 0;
  for(;;)
  {
    Console.Clear();
    Console.WriteLine(
      string.Join("\r\n", new string[]
    {
      s(r("            **  "), p),
      s(r("        ****    "), p),
      s(r("     *****      "), p),
      s(r(" **      **     "), p),
      s(r("*          *****"), p),})
      );
    Thread.Sleep(100);
    p++;

    if (p == 16)
      p = 0;
  }
}

V, 98 97 73 바이트

24 바이트를 절약 한 @ nmjcman101에게 감사합니다!

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

여기에는 많은 인쇄 불가능한 것이 포함되어 있으므로 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...

편집하다

1. 사용하는 y$대신<C-v>$y

2. 많은 변화

   • 각 줄을 복사하여 4 번 붙여 넣는 대신 먼저 웨이브를 생성 한 다음 전체를 복사하여 4 번 붙여 넣습니다.
   • 사용 {하고 }몇 바이트를 절약하기 위해
   • ò무한 루프를 만들기 위해 레지스터 대신 사용 (어떤 이유로 ò작동하려면 끝에 포함시켜야 함 )
   • *바닥에 정전기 를 고정

미니 설명

<alt-n>문자열 복사본을 만드는 데 사용 하고 있습니다. 예를 들어 <alt-5>*(이것은 µ5)는 삽입 모드에서 5복사본을 만듭니다 *. 이것은 문자열을 복사하고 정규식을 사용하여 필요한 교체를 수행하는 것보다 짧은 것으로 나타났습니다. 하나의 웨이브를 만든 후 다른 웨이브를 만들기 위해 붙여 넣습니다. 마지막으로 ò무한 루프를 만드는 데 재귀 적으로 반복합니다 (지연 100ms).

GIF

대부분의 코드는 웨이브를 만드는 데 전념하기 때문에 여전히 골프를 치려고합니다. TIO는 코드 실행이 완료된 후에 만 ​​출력을 출력하므로이 코드는 TIO에서 작동하지 않습니다. 그래서 여기에 gif가 있습니다 (낮은 품질로 죄송합니다. 웹 사이트를 사용하여를로 변환 .mov해야했습니다 .gif. 또한 >_오른쪽에 계속 팝업되는 것은 내 맥 도크의 터미널 아이콘입니다).

배치, 424 바이트

@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

일부 줄에는 후행 공백이 있습니다. 표준 80 열 터미널이 필요합니다. 타이밍은 정확하지 않지만 Batch에서 할 수있는 최선입니다.

라켓 395 374 373 367 364 351 바이트

화면 지우기를 위해 외부 라이브러리를 사용합니다.
편집 : w기능을 정의 하고 인라인 하지 않고 21 바이트를 절약했습니다 .
Edit2 : 공백을 제거하여 1 바이트를 저장했습니다.
Edit3 : @rnso 덕분 에로 이름 loop을 바꾸어 6 바이트를 p절약했습니다!
Edit4 : 3 바이트를 절약 할 수있는 부분 문자열을 넣습니다.
Edit5 : Remove #lang racket, 인터프리터에는 필요하지 않습니다.

골프 : 351 바이트

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

스크롤 (클리어 없음) : 272 바이트

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

언 골프 드 :

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

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

PowerShell을 3.0 183 182 173 바이트

이진 이동 연산자에는 PS 3.0이 필요합니다. AdmBorkBork 의 도움 으로 173 바이트로 줄었습니다 !

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

배시로 coreutils +, 172 148 바이트

@zeppelin 덕분에 24 바이트 절약 , 많은 감사

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

첫 번째 줄은 6 개의 연속파로 구성된 다음 패턴을 압축 해제합니다.

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

그런 다음 루프는 해당 패턴을 통해 80 바이트 너비의 창을 슬라이드합니다.

*> <> , 251 (250) 251 바이트 (비경쟁)

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

^{참고 : 후 "H;0["ascii가 있어야합니다 .27[}

여기 사용해보십시오! (지연을 0ms로 설정)

나는 이것을 성공적으로 만드는 것을 믿을 수 없다. 선택한 스택을 늘리거나 줄이는 I및 D명령어를 사용합니다 . 이것은 순수한> <> (잠자 빼기) 또는 경쟁력있는 *> <> 대답 으로이 작업을 수행하는 것이 가능하지만 아마도 훨씬 더 어렵다는 것을 보여줍니다.

온라인 인터프리터 버전은 캐리지 리턴을 사용하여 출력을 지우는 것과 다릅니다.

때문에 비 경쟁 I, D, C, 및 R지침은 도전 미만이다. 이러한 지침이 없으면 가능할 수 있지만 매우 어렵거나 길 수 있습니다.

편집 : 실제로 바이트를 제거했지만 크기가 잘못 측정되어 실제로 바이트를 얻었습니다.

나는 단계를 분해하고 여기서 일어나는 일을 설명하기 위해 최선을 다할 것입니다 ...

설명

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

목차

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)

초기화

여기서 우리는 파도를 구성하는 6 개의 선을 만듭니다. 올바른 길이가되도록 각 문자열을 5 번 반복해야합니다.

우리는 웨이브의 각 라인마다 하나씩 6 개로 시작합니다 :

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

그리고 우리는 초기화를 통해 메인 루프에 들어갑니다 09..

현재 스택을 4 번 복사

이것은 현재 스택을 가져 와서 4 번 복사하는 간단한 기능입니다. 따라서 "a"는 "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

복사 스택

현재 스택에 사본을 추가하여 현재 스택을 복사합니다.

설정

초기 방향을 건너 뛰고 <첫 번째 줄을 뒤집어서 IP 방향을 변경 l:&0v한 후에 실행되는 순서가되도록합니다 <.

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

여기서부터 길이는 n및 로 언급 0됩니다 i.

고리

>                        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

대청소

>                        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

메인 루프

여기 코드가 영원히 실행되는 곳이 있으며 100ms 수면 사이의 파도를 지속적으로 다시 그려냅니다.

설정

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 

고리

>                          move the IP to the right
 l?u     O                 if the stack is empty ...
    1S                       sleep for 100ms
      09.                    jump to main loop initialisation
          {                shift the stack left
           54Cl2,[         copy the current stack to a new stack
                  a        append a newline to the stack
                   }       shift the stack to the right
                    4cC    call "output stack"
                       ]   close the stack
                        I  select one stack higher

PHP, 128 바이트

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

둘 이상의 줄에 애니메이션을 적용 할 수 없지만 스크롤됩니다. 반복 사이에 빈 줄을 배열에
추가하십시오 ,0. 로 실행하십시오 -r.

수학, 213 바이트

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

Mathematica에서 각 줄의 문자열 목록으로 시작하는 것 외에는 웨이브 패턴을 골퍼하는 방법이 없습니다. 나는 초기화 i할 0과마다 증가하는 작업을 예약 0.1초. 나는 Dynamic동맹국 다음의 결과를 표시 :

1. StringRepeat 각 줄은 5 번.
2. 각 행을의 목록으로 변환하십시오 Characters.
3. RotateRight로 각 문자 목록 i.
4. 결과 문자 배열을로 표시합니다 Grid.

C (UNIX) 231 191 바이트

이것은 유닉스 환경에서만 작동합니다. 또한 sleep은 정수만 허용한다는 사실을 변명하십시오. 실제로 프레임 사이에서 1 초 지연됩니다.

언 골프 버전 :

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

골프 버전 :

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

자바 (ES6), 152 (147) 145 바이트

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

펄 6 140 138 137 123 120 바이트

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

오래된 솔루션 :

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

파이썬 3, 240 239230 바이트

_{@redstarcoder 덕분에 -1 바이트}

_{@PascalvKooten 덕분에 -9 바이트}

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)

라켓 295 바이트

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

언 골프 드 :

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

테스트 :

(f)

산출:

(이 gif 파일 표시는 실제 출력보다 느립니다).

파이썬 2, 207202 바이트

일반적으로 저는 C # 개발자이므로 아직 완전히 골프되지 않았을 수 있습니다 ...

import time;i=0
while 5:
    print"\033[;H"
    for l in[" "*12+"**  "," "*8+"*"*4+" "*4," "*5+"*"*5+" "*6,"   **   **"+" "*6," **     "*2,"*"+" "*10+"*"*5]:print(l[16-i:]+l*5)[:80]
    time.sleep(.1);i=(i+1)%16

C #, 327 바이트

파이썬으로 내 포팅 된 버전의 솔루션 ...

_=>{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);}}

펄, 110 바이트

-E추가 비용없이 필요합니다 . 인쇄 할 수없는 문자가 포함되어 있습니다.

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

아래의 뒤집을 수있는 16 진 덤프를 사용하여 위의 데이터를 작성하십시오. xxd -d > sea.plLinux 또는 호환 터미널에서 실행 하고 아래를 붙여넣고 Ctrl+ d를 누른 다음를 실행하십시오 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}

용법

복사 / 붙여 넣기를 쉽게하려면 다음을 사용하십시오.

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

설명

웨이브를 시작 부분에 문자열로 저장하는 매우 간단한 솔루션으로, unpack이진 0으로 변환되고 각 섹션은 이중화되고 s는 공백 1으로 변환 되고 s는 s로 변환됩니다 *. 이제 우리는 전체 문자열을 가지고 있으므로 전체 문자열 redo을 출력 하는 루프를 입력 한 다음 0.1 초 동안 기다렸다가 문자열의 각 줄마다 마지막 문자를 문자열의 시작 부분으로 옮깁니다.

Mathematica 171 바이트

웨이브 자체는 데이터이므로 전체 웨이브의 압축 버전을 코드에 저장하고 있습니다. \fð߀ᣀ恠耟이진 표현 을 사용할 때 단일 웨이브를 훨씬 더 컴팩트하게 저장할 수 있지만 압축 해제의 문자 수 오버 헤드가 너무 높습니다 *.

코드는 다음과 같습니다.

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

다음은 웨이브 데이터의 압축 버전을 생성하는 데 사용한 코드입니다.

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

이 웨이브와 같은 압축 반복 이진 데이터를 저장하는 데 선호하는 코드는 다음과 같습니다.

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

보시다시피, 압축 된 데이터를 다시 문자열로 변환하는 오버 헤드는이 특정 문제에 비해 너무 비싸지 만 단일 웨이브는 7 UTF 문자와 15 바이트로이 방식으로 저장할 수 있습니다.

다음은 단일 웨이브를 저장하기위한 UTF 문자 시퀀스를 결정하는 코드입니다 (위와 같이).

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

루비 269 217 189 185 바이트

@manatwork 덕분에 -28 바이트

@ropata 덕분에 -5 바이트

표준

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

골프

p=0
b=' '
loop{system'clear'
[b*12+'**  ',b*8+'****    ',b*5+'*****'+b*6,'   **   **'+b*6,' **      **     ',"*#{b*10}*****"].map{|i|puts ((i*5)[16-p..-1]+i)[0,79]}
p=-~p%16
sleep 0.1}

HTML + JS + jQuery, 10 + 233 = 243 바이트

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는 각 행을 1 씩 시프트하고 100ms마다 텍스트를 변경합니다.