Morze w twoim terminalu

46

tło

Lato na półkuli północnej się kończy, a wielu z nas tęskni za słońcem, plażami, falami oceanu ... To wyzwanie ma na celu rozweselić ich, przypominając im o morzu.

Wyzwanie

Oto morze:

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

Morze składa się z 5 razy tego wzoru fali:

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

Pamiętaj, że wzór ma 16 znaków, a morze ma 5 razy więcej niż 80 znaków.

Które możesz wydrukować na terminalu za pomocą tego wiersza poleceń:

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

Albo ten :

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

(Drugi powinien ułatwić uzyskanie dokładnego wzoru)

Twoim zadaniem jest wyświetlanie morza w terminalu i wyglądanie, jakby fale poruszały się w prawo: musi przesuwać się w prawo z prędkością 1 znaku na każde 100 ms (= 10 razy co sekundę). Po 80. kolumnie nie należy drukować żadnego znaku, ale gdy zniknie prawa fala, po lewej pojawia się nowa.
Oto przykład wyniku:

czas = 0,0 s

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

czas = 0,1s

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

czas = 0,2 s

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

czas = 0,3 s

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

czas = 0,4 s

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

Oczywiście każde wyjście powinno zastąpić poprzednie.

Możesz uruchomić ten kod w terminalu unix, aby zobaczyć, jak powinien wyglądać z animacją:

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

(Należy pamiętać, że ten kod nie jest zbyt dobrze golfowany: właśnie uczyniłem go wystarczająco kompaktowym, aby można go było uruchomić w terminalu.)

Kryterium wygranej

To jest codegolf, więc wygrywa najkrótszy kod w bajtach.

Dada
źródło
2
Czy możemy rozpocząć animację w dowolnej klatce?
Arnauld,
2
05ab1e.tryitonline.net/… szkoda 05AB1E nie może animować, to by było krótkie.
Magic Octopus Urn
2
@Arnauld Tak, możesz.
Dada,
2
Masz rację! To są prawdziwe lambdas
Luis Mendo,
14
„Lato już się skończyło”, to bardzo półkuli północnej.
MikeTheLiar,

Odpowiedzi:

18

MATL , 41 40 bajtów

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

Przykładowy przebieg:

wprowadź opis zdjęcia tutaj

Lub spróbuj w MATL Online! (rzeczywista prędkość może zależeć od obciążenia serwera).

Jak to działa

`                    % 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
źródło
19

JavaScript (ES6) + HTML, 151 143 + 10 = 161 153 bajtów

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
źródło
Jaka jest funkcja zmiennej a?
Kritixi Lithos
@KritixiLithos aprzechowuje wzorzec fali kodowany binarnie i jest obracany na każdej ramce. Tak więc nie można go zakodować na stałe: musi być przechowywany w zmiennej.
Arnauld,
16

HTML + CSS, 70 + 181 175 = 245 bajtów

Posługuje text-shadow, rtltekstowych i CSS klatek kluczowych animacji.

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
źródło
9

C # 450 444 425 417 bajtów

399 bez, using System.Linq;ale jestem pewien, że to byłoby oszustwo ...

Edycja: Zapisano 25 bajtów dzięki @Cyoce

Gra w golfa:

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

Nie golfowany:

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

wprowadź opis zdjęcia tutaj

Pete Arden
źródło
1
Myślę, że możesz usunąć nawiasy (a)=>. I while(true)może byćfor(;;)
Cyoce,
1
W przypadku slambda myślę, że można usunąć {}ireturn
Cyoce
Pracowałem nad obiema, dając mi 25 bajtów oszczędności, dzięki! :)
Pete Arden,
Możesz uczynić całą swoją funkcję lambda. Myślę, że możesz także usunąć \rz string.Join(przynajmniej w systemie Windows to działa, ale nie przetestowałem go za pomocą Mono). Możesz również zapisać 1 bajt, umieszczając p++w forpętli w ten sposóbfor(;;p++)
Stefan
Aby usunąć kontrolę granicy na dole ( if (p==16)...), możesz również umieścić ją w nagłówku pętli for w ten sposób for(;;p=++p%16). Oszczędź jeszcze 1 bajt, deklarując pw pętli ( for(int p=0;;p=++p%16))
Stefan
7

V, 98 97 73 bajtów

Dzięki @ nmjcman101 za oszczędność 24 bajtów!

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

Zawiera wiele materiałów niedrukowalnych, więc oto zrzut heksowy 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...

Edytować

  1. Używany y$zamiast<C-v>$y

  2. Wiele zmian

    • Zamiast kopiować każdą linię i wklejać ją 4 razy, najpierw generuję falę, a następnie kopiuję całość i wklejam 4 razy
    • Używane {i }aby zaoszczędzić kilka bajtów
    • Używany òzamiast rejestrów do tworzenia nieskończonej pętli (z jakiegoś powodu muszę dołączyć òna końcu, aby to działało)
    • naprawiono statyczne *na dole

Mini objaśnienie

Używam <alt-n>do tworzenia kopii ciągów. Na przykład <alt-5>*(tak wygląda µ5) wykonuje 5kopie *w trybie wstawiania. Okazało się, że jest to krótsze niż kopiowanie ciągu i używanie wyrażenia regularnego do wykonania niezbędnych zamian. Po utworzeniu jednej fali wklejam ją, aby utworzyć inne fale. Na koniec zapętlam rekurencyjnie, używając òpętli nieskończonej (z opóźnieniem 100ms).

Gif

Większość kodu jest poświęcona tworzeniu fali, więc wciąż próbuję to zagrać w golfa. Zauważ, że ten kod nie będzie działał na TIO, ponieważ TIO wysyła dane wyjściowe dopiero po zakończeniu wykonywania kodu. Oto gif (przepraszam za niską jakość, musiałem użyć strony internetowej, aby przekonwertować .movna a .gif, a także >_, który pojawia się po prawej stronie, to ikona terminala w stacji dokującej mojego Maca):

fala gif

Kritixi Lithos
źródło
Nie mam pojęcia, jak działają twoje funky powtarzające się liczby, ale jeśli wykonasz jedną falę, a następnie zablokujesz kopiowanie / wklejanie, możesz zapisać znaki (zamiast kopiować wklejając każdą linię 4 razy) Link do TryItOnline
nmjcman101
Mniej pomocne, myślę, że twój 5j(w kontekście $<C-V>5j) może po prostu być }, a ppo nim |powinno być to, Pco naprawi statyczne *w lewym dolnym rogu.
nmjcman101,
1
Wreszcie (przepraszam za komentarz do spamu, najwyraźniej można je edytować przez 5 minut), możesz zamienić qm[CODE]@mq@mna końcu na just ò[CODE]. Kod między òbędzie się zapętlał do momentu złamania (podobnie jak twoje makro), a na końcu programu òzostanie domyślnie zamknięty.
nmjcman101,
@ nmjcman101 Dzięki za pomoc! (to nie jest komentarz spam, jeśli pomagasz mi w grze w golfa kilka bajtów :)
Kritixi Lithos
6

Partia, 424 bajty

@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

Niektóre linie mają końcowe spacje. Wymaga standardowego terminala 80-kolumnowego. Czas nie jest bardzo dokładny, ale jest najlepszy, co możesz zrobić w partii.

Neil
źródło
6

Rakieta 395 374 373 367 364 351 bajtów

Używa zewnętrznej biblioteki do czyszczenia ekranu.
Edycja: Zapisano 21 bajtów, nie definiując wi nie wstawiając funkcji.
Edycja2: Zapisano 1 bajt, usuwając spację.
Edit3: Zapisano 6 bajtów, zmieniając nazwę loopna p, dzięki @rnso!
Edycja4: Umieszczanie podłańcucha w let, oszczędzając 3 bajty.
Edycja5: Usuń #lang racket, która nie jest potrzebna w tłumaczu .

Gra w golfa: 351 bajtów

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

Przewijanie (bez czyszczenia): 272 bajtów

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

Nie golfowany:

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

Fale

Ultimate Hawk
źródło
Aby zmniejszyć liczbę bajtów, można zmienić nazwy na krótsze (np. P zamiast pętli). Jakiego oprogramowania użyłeś do przechwytywania wideo do pliku gif?
rnso
@rnso: Oh masz rację! Nie myślałem o tym. Użyłem simplescreenrecorderz avconvdo konwersji MP4 na gif.
Ultimate Hawk,
Możesz wstawić (g podciąg) w let, dzięki czemu możesz użyć g zamiast 2 słów kluczowych podciągu w późniejszym kodzie. To powinno ci zaoszczędzić kolejne 5 bajtów. Co też „lst” robi w twojej wersji bez golfa?
rnso
@rnso: Usunąłem go, był pozostałością po rotmulfaktycznym wprzyjęciu jako parametr.
Ultimate Hawk
Możesz również usunąć „#lang rakieta” z wersji golfowej. Większość kodu rakiety na tej stronie nie uwzględnia go podczas liczenia bajtów.
rnso
4

PowerShell 3.0, 183 182 173 bajtów

Wymaga PS 3.0 dla operatorów zmiany binarnej. Zmniejszony do 173 bajtów z pomocą 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
źródło
Niezła odpowiedź! Niektóre gry w golfa - zamiast specyfikatora formatu dziesiętnego.PadLeft przenieś $odeklarację do [convert]wywołania i wyeliminuj cudzysłowy wokół liczb w -replaceoperacjach. Sprowadza Cię do 175 -for(){0..5|%{("{0:D16}"-f+[Convert]::ToString(([uint16]$o=$w[$_]),2))*5-replace0,' '-replace1,'*'
AdmBorkBork
@AdmBorkBork Dzięki! Przepraszamy, że aktualizacja odpowiedzi zajęła mi sporo czasu. Czy możesz to wyjaśnić +w "{0:D16}"-f+[Convert]? Bez niego to nie działa, ale nie mogę sobie wyobrazić, co robi.
beatcracker
[convert]::ToString()Zwraca ciąg znaków. Te +siły oddanych do [int]tak, że -fodbiera odpowiedni typ parametru dla D16do pracy.
AdmBorkBork
1
@AdmBorkBork to znaczy, że traktuje PS +'1'jak ważnej operacji arytmetycznej bez uprzedniego do składnika, odlewy stringdo inti zwraca wynik? Świetny Scott!
beatcracker
3

Bash + coreutils, 172 148 bajtów

24 bajty zapisane dzięki @zeppelin , wielkie dzięki

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

Pierwsza linia dekompresuje następujący wzór złożony z 6 kolejnych fal:

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

Następnie pętla przesuwa okno o szerokości 80 bajtów przez ten wzór.

yoann
źródło
Narzędzie Coreutils base64 nie obsługuje flagi -D (zamiast tego powinno być -d, małe litery).
zeppelin,
Możesz zapisać ~ 10 bajtów, używając surowego LZMA (xz) zamiast gzip (kompresuj za pomocą lzma -Fraw , dekompresuj za pomocą xz -qdFraw ).
zeppelin,
Możesz również użyć starszej arytmetycznej składni rozszerzającej $ [] zamiast $ (()) , aby zaoszczędzić 4 dodatkowe bajty
zeppelin
Zera wiodącego można pominąć w poleceniu uśpienia, tzn. Sen .1 powinien działać dobrze
zeppelin
Możesz także pozbyć się wyraźnej deklaracji i = 0
zeppelin,
3

*> <> , 251 250 251 bajtów (niekonkurujące)

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

Uwaga: "H;0["ma mieć ASCII 27po [.

Wypróbuj tutaj! (ustaw opóźnienie na 0ms)

Nie mogę uwierzyć, że udało mi się to zrobić. Korzysta z instrukcji Ii D, które zwiększają lub zmniejszają wybrany stos. To pokazuje, że prawdopodobnie można to zrobić w czystej> <> (bez snu) lub w konkurencyjnej *> <> odpowiedzi, choć prawdopodobnie jest to o wiele trudniejsze.

Wersja tłumacza online różni się po prostu, aby usunąć dane wyjściowe za pomocą znaku powrotu karetki.

To nie konkurują, ponieważ I, D, Coraz Rinstrukcje są młodsze niż wyzwanie. Jest to prawdopodobnie możliwe bez tych instrukcji, ale byłoby to bardzo trudne / długie.

Edycja: Naprawdę udało mi się usunąć bajt, ale zauważyłem również, że źle zmierzyłem rozmiar, więc faktycznie uzyskałem bajt.


Zrobię co w mojej mocy, aby podzielić kroki i wyjaśnić, co się tutaj dzieje ...

Wyjaśnienie

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

Spis treści

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)

Inicjalizacja

Tutaj budujemy 6 linii, które tworzą fale. Musimy powtórzyć każdy ciąg 5 razy, aby mieć prawidłową długość.

Zaczynamy od 6 z nich, po jednym dla każdej linii fali:

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

I po inicjalizacji wchodzimy do głównej pętli 09..

Skopiuj bieżący stos 4 razy

Jest to prosta funkcja, która po prostu pobiera bieżący stos i kopiuje go 4 razy. Zatem „a” stałoby się „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

Kopiuj stos

Spowoduje to skopiowanie bieżącego stosu, dołączając kopię do bieżącego stosu.

Ustawiać

Pominie początkową <i odwróci pierwszą linię, aby stała się l:&0vw takiej kolejności, w jakiej jest wykonywana po <zmianie kierunku adresu 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

Odtąd długość będzie określana jako ni 0jako i.

Pętla

>                        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

Sprzątać

>                        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

Główna pętla

Tutaj kod działa wiecznie, nieustannie przerysowując fale pomiędzy 100 ms snu.

Ustawiać

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 

Pętla

>                          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
źródło
2

PHP, 128 bajtów

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

Nie można animować więcej niż jednej linii, ale przewija się.
Dodaj ,0do tablicy pustą linię między iteracjami. Uruchom z -r.

Tytus
źródło
2

Mathematica, 213 bajtów

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

Nie widzę żadnego sposobu gry w golfa na fali w Mathematica oprócz rozpoczęcia od listy ciągów dla każdej linii. Inicjuję isię 0i planuję zadanie, aby zwiększać je co 0.1sekundę. I Dynamicsojusznikiem wyświetli wynik z następujących powodów:

  1. StringRepeat każda linia 5 razy.
  2. Konwertuj każdą linię na jej listę Characters.
  3. RotateRightkażda lista znaków według i.
  4. Wyświetl wynikową tablicę znaków jako Grid.

wprowadź opis zdjęcia tutaj

ngenisis
źródło
Jakiego oprogramowania użyłeś do utworzenia przechwytywania i pliku gif?
rnso
Użyłem ScreenToGif.
ngenisis,
2

C (unix), 231 191 bajtów

Działa to tylko w środowiskach unix. Proszę również usprawiedliwić fakt, że tryb uśpienia akceptuje tylko liczby całkowite ... więc w rzeczywistości opóźnia 1 sekundę między ramkami.

Wersja bez golfa:

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

Wersja golfowa:

#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
źródło
1
To C w twoim terminalu.
Robert Fraser
2

JavaScript (ES6), 152 147 145 bajtów

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
źródło
Możesz także zapisać 2 bajty setInterval(a=>{...},100,6)i 4 kolejne f+=" *"[[...][a]&1<<(i+x)%16].
ETHproductions
Dzięki za sugestie! Ale czy jesteś pewien, że możesz otrzymać swoją drugą sugestię do działania? Nadal będziesz musiał przymusić tę wartość do wartości logicznej, aby pobrać indeks tablicy 0-1. Zastanawiałem się nad dalszym bitmapowaniem fali ascii na pojedynczą wartość szesnastkową: 0x801F606018C007C000F0000C, ale JavaScript może przesunąć bitowo maksymalnie 31 bitów w dowolnym kierunku! Uczysz się czegoś każdego dnia!
ajxs
2

Perl 6, 140 138 137 123 120 120 bajtów

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

Stare rozwiązania:

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
źródło
1

Python 3, 240 239 230 bajtów

-1 bajt dzięki @redstarcoder

-9 bajtów dzięki @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
źródło
print("\x1b[0;H")działa również dla mnie dla -1 bajtów.
redstarcoder,
Można wymienić ' **'ze ' '*13+'**'można mieć 1 wcięcia postać w czasie, nie ma potrzeby, aby była ona 4 znaków.
PascalVKooten,
@PascalvKooten dzięki. Podczas wklejania wcięcia zostały przekształcone w spacje od znaków tabulatorów. Postaram się na to uważać.
dfernan
1

Rakieta 295 bajtów

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

Nie golfowany:

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

Testowanie:

(f)

Wynik:

wprowadź opis zdjęcia tutaj

(Wyświetlanie pliku gif jest wolniejsze niż rzeczywiste wyjście).

rnso
źródło
1

Python 2, 207 202 bajtów

Zwykle jestem programistą C #, więc to może nie być jeszcze gra w golfa ...

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
źródło
1

C #, 327 bajtów

Mniej więcej przeniesiona wersja mojego rozwiązania w Pythonie ...

_=>{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
źródło
1

Perl, 110 bajtów

Wymaga -Ebez dodatkowych kosztów. Zawiera znaki niedrukowalne.

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

Utwórz powyższe dane za pomocą poniższego odwracalnego zrzutu heksadecymalnego. Uruchom xxd -d > sea.plw Linuksie lub kompatybilnym terminalu, wklej poniżej i naciśnij Ctrl+ d, a następnie uruchom 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}

Stosowanie

Aby ułatwić kopiowanie / wklejanie, skorzystaj z poniższych:

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

Wyjaśnienie

Dość proste rozwiązanie, które przechowuje falę na początku jako ciąg znaków, który jest unpackedytowany do postaci binarnej, każda sekcja jest pięciokrotna, 0s są konwertowane na spacje, a 1s są konwertowane na *s. Teraz mamy cały ciąg, więc wchodzimy w redopętlę, która wypisuje cały ciąg, a następnie czekamy .1 sekundy i dla każdej linii w ciągu przesuwamy ostatni znak na początek łańcucha.

Dom Hastings
źródło
1

Mathematica 171 bajtów

Sama fala to dane, więc przechowuję skompresowaną wersję całej fali w moim kodzie. Mogę zapisać pojedynczą falę o wiele bardziej zwartą, niż \fð߀ᣀ恠耟przy użyciu jej reprezentacji binarnej, ale narzut związany z rozpakowywaniem jest zbyt wysoki *.

Oto kod:

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

Oto kod, którego użyłem do stworzenia skompresowanej wersji danych fali:

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

Oto kod, którego wolałbym używać do przechowywania skompresowanych powtarzających się danych binarnych, takich jak ta fala:

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

Jak widać, narzut związany z zamianą skompresowanych danych z powrotem na ciąg jest zbyt kosztowny dla tego konkretnego problemu, chociaż w ten sposób można zapisać jedną falę z 7 znakami UTF i 15 bajtami.

Oto kod określający sekwencję znaków UTF do przechowywania pojedynczej fali (jak wyżej).

StringReplace[#,{" "->"0","*"->"1"}]&/@s
ToExpression/@%
IntegerDigits/@%
FromDigits[#,2]&/@%
FromCharacterCode/@%
StringJoin@%
Kelly Lowder
źródło
1

Rubinowy 269 217 189 185 bajtów

-28 Bajtów dzięki @manatwork

-5 bajtów dzięki @ropata

Normalna

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

Grał w golfa

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
źródło
Chociaż Twój kod działa poprawnie, pamiętaj, że zgodnie z zasadami witryny nie jest to jeszcze poprawne rozwiązanie: „Wszystkie rozwiązania wyzwań powinny: (…) Być poważnym konkurentem dla zastosowanych zwycięskich kryteriów. Na przykład, należy wziąć udział w konkursie golfa kodowego, (…) ”- centrum pomocy Zobacz Wskazówki dotyczące gry w Ruby .
manatwork
W każdym razie krótka lista: usuń wcięcie; do … end{ … }i usuń nowe linie po {i przed }; usuń spację między systemi jej parametr; usuń ,ostatni element literału po tablicy; .each.mapi usuń spację między nim a jego blokiem kodu; usuń przestrzeń przed puts; 0..800,80(jest to również błąd, ponieważ wyrażenie powoduje, że łańcuch składa się z 81 znaków); p=p+1==16?0: p+1p=-~p%16.
manatwork
Tak, głupie wyjaśnienie maniactwa znów uderza. Nawet zmieniając do … end→ słowo kluczowe { … }wciąż jest potrzebne loop. To jest najkrótszy, jaki dostaję: pastebin.com/cg3gxnm4
manatwork
Można zapisać 5 lub 6 bajtów, ustawiając b=' '(5 pustych spacji) u góry, a następnie zmieniając wyrażenie wyjściowe na ' '*12+'** ', ' '*8+'**** ',b+'***** '+b,' ** ** '+b,' ** **'+b,'*'+b+b+'*****'... (ale SE nie wyświetla poprawnie powtarzających się spacji w tym komentarzu!)
roblogic
0

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

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 przesuwa każdy wiersz o 1 i zmienia tekst co 100 ms.

FireCubez
źródło