Arka fon

Kuzey Yarımküre'de yaz sona ermiştir ve çoğumuz güneşi, plajları, okyanus dalgalarını özlüyoruz ... Bu zorluk, onları denizleri hatırlatarak neşelendirmeyi hedefliyor.

Meydan okuma

İşte deniz:

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

Deniz bu dalga düzeninin 5 katıdır:

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

Desenin 16 karakter uzunluğunda olduğunu ve denizin 5 kez denizde olduğunu unutmayın; bu desen = 80 karakter uzunluğundadır.

Bu komut satırını kullanarak bir terminale yazdırabilirsiniz:

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

Ya da bu :

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

(İkincisi, tam deseni elde etmenizi kolaylaştırması gerekir)

Senin görevin denizi bir terminalde görüntülemek ve dalgalar sağa doğru hareket ediyor gibi görünmesini sağlamak: her 100ms'de (= saniyede 10 kez) 1 karakter hızında sağa kayması gerekiyor. 80. sütundan sonra hiçbir karakter yazdırılmamalı, ancak en sağdaki dalga kaybolduğunda, solda yeni bir tane görünür.
İşte bir çıktı örneği:

süre = 0.0 sn

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

zaman = 0.1 sn

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

süre = 0.2 sn

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

zaman = 0.3 sn

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

süre = 0.4 s

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

Tabii ki, her çıktı öncekinin yerine geçmelidir.

Animasyonda nasıl görünmesi gerektiğini görmek için bu kodu bir unix terminalinde çalıştırabilirsiniz:

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

(Bu kodun çok iyi golf olmadığını unutmayın: Ben sadece bir terminalde çalışmaya uygun olacak kadar kompakt yaptım.)

Kazanma kriteri

Bu codegolf, bayt kazanma sayısındaki en kısa kod.

MATL , 41 40 bayt

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

Örnek çalışma:

Veya MATL Online'da deneyin ! (gerçek hız sunucu yüküne bağlı olabilir).

Nasıl çalışır

`                    % Do...while
  '3SJp/B@Tc`@+ara'  %   Compressed string (actually it's just a change of base)
  F                  %   Push false. Indicates base-95 input alphabet for decompression
  '* '               %   Push this string, which defines output alphabet
  Za                 %   Base conversion. This decompresses the string
  6e                 %   Reshape as a 6-row char array. This gives the basic pattern
  l&Xx               %   Pause 0.1 seconds and clear screen
  80:                %   Push array [1 2 ... 80] 
  @-                 %   Subtract iteration index to each element of that array. This
                     %    will produce the rotation via modular indexing
  Z)                 %   Use as column index. Indexing is modular, so this repeats
                     %   (and rotates) the pattern
  D                  %   Display
  T                  %   True. Loop condition for infinite loop
                     % Implicit end

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

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

<pre id=O>

HTML + CSS, 70 + 181 175 = 245 bayt

Markalar kullanımı text-shadow, rtlmetin ve CSS anahtar kare animasyonlar.

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 Bayt

399 olmadan using System.Linq;ama bunun hile yapacağına eminim ...

Düzenleme: @Cyoce sayesinde 25 bayt kaydedildi

golfed:

void S(){Func<string,string>r=a=>string.Concat(Enumerable.Repeat(a,5));Func<string,int,string>s=(b,i)=>(b.Substring(16-i)+b).Substring(0,80);int p=0;for(;;){Console.Clear();Console.WriteLine(string.Join("\r\n",new string[]{s(r("            **  "),p),s(r("        ****    "),p),s(r("     *****      "),p),s(r(" **      **     "),p),s(r("*          *****"),p),}));Thread.Sleep(100);p++;if(p==16)p=0;}}

Ungolfed:

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

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

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

V, 98 97 73 bayt

24 byte tasarruf için @ nmjcman101 teşekkürler!

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

Bu bir sürü yazdırılamaz, bu yüzden burada bir xxd hexdump var:

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

Düzenle

1. Yerine y$kullanılır<C-v>$y

2. Çok fazla değişiklik

   • Her satırı kopyalayıp 4 kez yapıştırmak yerine, önce dalgayı oluşturup, ardından her şeyi kopyalayıp 4 kez yapıştırıp yapıştırmak yerine
   • Kullanılan {ve }birkaç byte kaydetmek için
   • òSonsuz döngüyü oluşturmak için kayıtlar yerine kullanılır (nedense òçalışması için sonunda bir tane eklemeliyim)
   • *altta statik sabit

Mini Açıklama

<alt-n>Dizelerin kopyalarını oluşturmak için kullanıyorum . Örneğin, <alt-5>*(bu benziyor µ5) ekleme modunda 5kopyalarını alıyor *. Bu dize kopyalamak ve gerekli değişiklikleri yapmak için bir regex kullanarak daha kısa bulundu. Bir dalga oluşturduktan sonra diğer dalgaları oluşturmak için yapıştırabilirim. Sonunda, òsonsuz döngüyü oluşturmak için yinelemeli olarak döngü kullanıyorum (gecikmeli 100ms).

gif

Kodun çoğu dalgayı oluşturmaya adanmıştır, bu yüzden hala golf oynamaya çalışıyorum. Bu kodun TIO'da çalışmayacağına dikkat edin, çünkü TIO yalnızca kodun yürütülmesini tamamladıktan sonra çıkışı verir. Yani burada bir gif var (düşük kalite için üzgünüm, ben bir dönüştürmek için bir web sitesini kullanmak zorunda .movbir karşı .gifda, >_sağ haşhaş tutar benim mac en iskelede Terminali simgedir):

Toplu, 424 bayt

@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

Bazı satırlar sondaki boşluklara sahiptir. Standart bir 80 sütunlu terminal gerektirir. Zamanlama çok doğru değil, ama Batch'ta yapabileceğiniz en iyi şey.

Raket 395 374 373 367 364 351 bayt

Ekranı temizlemek için harici bir kütüphane kullanır.
Düzenle: wFonksiyonu tanımlayıp satırlarını çizerek 21 bayt kaydedildi .
Düzen2: Bir boşluğu kaldırarak 1 bayt kaydedildi.
Edit3: Kaydedilen yeniden adlandırarak 6 bayt loopiçin pteşekkürler @rnso!
Düzen4: Alt dize kaydetme 3 bayt koyarak.
Düzen5: #lang racketTercümanda gerekli olmayan çıkarın .

Golf: 351 bayt

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

Kaydırma (net değil): 272 bayt

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

Ungolfed:

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

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

PowerShell 3.0, 183 182 173 bayt

İkili vardiya operatörleri için PS 3.0 gerektirir. AdmBorkBork'un yardımıyla 173 bayta zayıfladı !

$w=12,240,1984,6336,24672,32799
for(){0..5|%{'{0:D16}'-f+[Convert]::ToString(([uint16]$o=$w[$_]),2)*5-replace0,' '-replace1,'*'
$w[$_]=$o-shr1-bor$o-shl15}
sleep -m 100
cls}

Bash + coreutils, 172 148 bayt

@Zeppelin sayesinde 24 bayt kaydedildi , çok teşekkürler

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

İlk satır, arka arkaya 6 dalgadan oluşan aşağıdaki deseni açar:

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

Ardından, döngü 80 bayt genişliğinde bir pencereyi bu desen boyunca kaydırır.

*> <> , 251 250 251 bayt (rekabet etmeyen)

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

^{Not: sonra "H;0["ascii olması gerekiyordu .27[}

Burada dene! (gecikmeyi 0ms'ye ayarlayın)

Bunu başarılı bir şekilde yaptığıma inanamıyorum. Bu , seçilen yığını artıran veya azaltan Ive Dyönergelerini kullanır . Bu muhtemelen muhtemelen daha zor olsa da, saf> <> (uyku eksi) veya rekabetçi bir *> <> cevapta yapmanın mümkün olduğunu göstermektedir.

Çevrimiçi tercüman sürümü, bir satırbaşı dönüşü kullanarak çıktıyı silmek için basitçe farklıdır.

Bunun nedeni olmayan rekabet I, D, C, ve Rtalimatlar mücadeleden daha gençtir. Bu, muhtemelen bu talimatlar olmadan yapılabilir, ancak çok uzun / zor olurdu.

Düzenleme: Aslında bir bayt kaldırmayı başardım, ancak aynı zamanda büyüklüğünü yanlış ölçtüğümü fark ettim, bu yüzden aslında bir bayt kazandım.

Adımları yıkmak ve burada neler olduğunu açıklamak için elimden geleni yapacağım ...

açıklama

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

İçindekiler

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)

Başlatma

Burada dalgaları oluşturan 6 çizgiyi inşa ediyoruz. Doğru uzunluk olması için her dizgiyi 5 kez tekrarlamamız gerekir.

Bunlardan 6'sı ile başlıyoruz, dalganın her satırı için bir tane:

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

Ve başlattıktan sonra ana döngüye giriyoruz 09..

Geçerli Yığını 4 Kez Kopyala

Bu basitçe geçerli yığını alan ve 4 kez kopyalayan basit bir fonksiyondur. Yani "a", "aaaaa" olur.

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

Yığını Kopyala

Bu, kopyayı geçerli yığına ekleyerek geçerli yığını kopyalar.

Kurmak

İlkini atlamak ve IP'nin yönünü değiştirdikten sonra uygulandığı sıraya <gelmek için ilk satırı tersine çevirmek .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

Burada uzunluğu üzerinden andan itibaren olarak anılacaktır edilecektir nve 0olarak i.

döngü

>                        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

Temizlemek

>                        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

Ana döngü

İşte kodun sonsuza dek çalıştığı yerde, 100ms arasındaki dalgaları sürekli yeniden çizer.

Kurmak

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 

döngü

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

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

Birden fazla satır canlandırılamıyor ancak kaydırılıyor. Yinelemeler arasında boş bir satır için diziye
ekleyin ,0. İle koş -r.

Mathematica, 213 bayt

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

Mathematica'da dalga paternini golf oynamanın bir yolunu görmüyorum, her satır için bir dizge listesi ile başlamaktan başka. Ben başlatmak iolmak 0ve bunu her artırmak için bir görev zamanlama 0.1saniye. Ben Dynamicmüttefiki Aşağıdakilerden sonucunu görüntüler:

1. StringRepeat Her satır 5 kez.
2. Her satırı bir listeye dönüştürün Characters.
3. RotateRightHer karakter listesi ile i.
4. Sonuçta ortaya çıkan karakter dizisini a olarak görüntüleyin Grid.

C (unix), 231 191 bayt

Bu sadece unix ortamlarında çalışacaktır. Ayrıca, uykunun sadece tamsayıları kabul ettiği gerçeğini affedersiniz ... bu yüzden aslında çerçeveler arasında 1 saniye geciktirir.

Ungolfed versiyonu:

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

Golf versiyonu:

#include <stdio.h>
int main(){int x=0,l,i,a[6]={32799,24672,6336,1984,240,12};while(l=6,++x){printf("\033[2J");while(i=128,l--){while(i--)putchar(a[l]&1<<(i+x)%16?42:32);puts("");}sleep(1);}}

Javascript (ES6), 152 147 145 bayt

x=0,c=console;setInterval(a=>{for(c.clear();f="",i=128,++x,a--;c.log(f))for(;i--;)f+=" *"[[32799,24672,6336,1984,240,12][a]>>(i+x)%16&1]},100,6);

Perl 6, 140 138 137 123 120 bayt

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

Eski çözümler:

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

Python 3, 240 239 230 bayt

_{@Redstarcoder sayesinde -1 bayt}

_{@PascalvKooten sayesinde -9 bayt}

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)

Raket 295 bayt

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

Test yapmak:

(f)

Çıktı:

(Bu gif dosya görüntüsü gerçek çıktıdan daha yavaştır).

Python 2,207 202 bayt

Genellikle ben bir C # geliştiricisiyim, bu yüzden henüz tamamen golf oynamamış olabilir ...

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 bayt

Python'daki çözümümün çoktan veya daha küçük bir sürümü ...

_=>{Func<string,int,string>t=(s,j)=>(s.Substring(16-j)+string.Concat(Enumerable.Repeat(s,5))).Substring(0,80);for(var i=0;;i=++i%16){Console.Clear();foreach(var q in "            **  ,        ****    ,     *****      ,   **   **      , **      **     ,*          *****".Split(','))Console.WriteLine(t(q,i));Thread.Sleep(100);}}

Perl, 110 bayt

-EEk ücret ödemeden gerektirir . Bu, yazdırılamayan karakterler içeriyor.

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

Aşağıdaki geri dönüşümlü hexdump kullanarak yukarıdaki verileri oluşturun. Run xxd -d > sea.plbir linux veya uyumlu terminalde aşağıdaki basın yapıştırın Ctrl+ dardından koşmak 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}

kullanım

Kolayca kopyalamak / yapıştırmak için lütfen aşağıdakileri kullanın:

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

açıklama

Dalgayı başlangıçta bir dize olarak depolayan, unpackikili olarak düzenlenmiş, her bölüm beş katına bölünmüş, 0boşluklara dönüştürülen ve 1s'ye dönüştürülen oldukça basit bir çözüm *. Şimdi tüm dizgiye sahibiz, bu yüzden dizgenin tamamını redobasan bir döngüye gireriz , sonra .1 saniye bekleriz ve dizgideki her satır için son karakteri dizginin başlangıcına taşırız.

Mathematica 171 Bayt

Dalganın kendisi veridir, bu yüzden tüm dalganın sıkıştırılmış bir sürümünü kodumda saklıyorum. Tek bir dalgayı \fð߀ᣀ恠耟, ikili gösterimini kullanırken olduğu gibi çok daha kompakt bir şekilde depolayabilirim , ancak sıkıştırılmamış sıkıştırmanın üzerindeki karakter sayısı çok yüksektir *.

İşte kod:

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

Dalga verilerinin sıkıştırılmış sürümünü oluşturmak için kullandığım kod:

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

İşte bu dalga gibi sıkıştırılmış yinelenen ikili verileri saklamak için kullanmayı tercih ettiğim kod:

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

Gördüğünüz gibi, sıkıştırılmış verileri bir dizgeye geri döndürmek için kullanılan masraf bu sorun için çok pahalıdır, ancak tek bir dalga bu şekilde 7 UTF karakteri ve 15 bayt ile saklanabilir.

Tek bir dalgayı (yukarıdaki gibi) depolamak için UTF karakter sırasını belirleyen kod buradaydı.

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

Ruby 269 217 189 185 Bayt

-28 Bayt @manatwork sayesinde

@5 Bayt @ropata sayesinde

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}

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

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 sadece her satırı 1'e kaydırır ve her 100 ms'de bir metni değiştirir.