Twoim zadaniem jest stworzenie nieskończonego ekranu ładowania, który wygląda następująco:

Lub bardziej szczegółowo:

• Nie wkładaj żadnych danych.
• Wyjście Loading...z końcową spacją, ale bez końcowej linii nowej linii.
• Nieskończenie przechodzić zwęgla |, /, -i \: co 0.25 sekundy, zastąpienie ostatni z następnym w kolejności. Możesz zastąpić tylko ostatni znak lub usunąć i przepisać całą linię, o ile długo Loading...pozostanie niezmieniona.

Zasady

• Tekst wyjściowy musi wyglądać dokładnie tak, jak określono. Znaki końcowe / spacje są dopuszczalne.
• Należy nie czekaj 0,25 sekund przed początkowo przedstawiający wyjście - pierwsza klatka powinna być wydrukowane tak szybko, jak program zostanie uruchomiony.
• Twój program powinien być w stanie działać w nieskończoność.Na przykład, jeśli używasz licznika dla ramek, licznik nigdy nie powinien powodować błędu, przekraczając maksimum w twoim języku.
• Chociaż okres oczekiwania między każdą „ramką” powinien wynosić 0,25 sekundy, oczywiście nigdy nie będzie to dokładne - dopuszczalny margines błędu wynoszący około 10%.
• Możesz przesłać funkcję, ale musi ona zostać wydrukowana na stdout.
• Możesz przesłać odpowiedź w środowisku innym niż konsola (ale nadal oparte na tekście), o ile jest w stanie wygenerować animację ładowania.
• To jest golf golfowy , więc wygrywa najkrótsze rozwiązanie (w bajtach). Obowiązują standardowe luki w kodzie golfowym.
• Jeśli to możliwe, podaj gif ekranu ładowania w akcji.

Przykład

Oto kod C ++, którego użyłem do stworzenia przykładu (nie golf):

#include <iostream>
#include <string>
#include <thread>

using namespace std;

int main() {
    string cycle = "|/-\\";
    int i = 0;

    cout << "Loading... ";

    while (true) {
        // Print current character
        cout << cycle[i];

        // Sleep for 0.25 seconds
        this_thread::sleep_for(chrono::milliseconds(250));

        // Delete last character, then increase counter.
        cout << "\b";
        i = ++i % 4;
    }
}

Niech zwycięży najlepszy golfista!

HTML / CSS, 183 180 163 161 160 147 143 bajtów

a{display:inline-flex;overflow:hidden;width:1ch}c{animation:c 1s steps(4)infinite}@keyframes c{to{margin:0-4ch

<pre>Loading... <a><c>|/-\</pre>

Edycja: Zapisano 3 bajty dzięki @betseg. Zaoszczędź 17 bajtów dzięki @manatwork. Zapisano 1 bajt dzięki @Daniel. Zaoszczędź 13 bajtów dzięki @Ismael Miguel. Zaoszczędź 4 bajty dzięki @Fez Vrasta.

Vim, 43 , 41 bajtów

qqSLoading... |<esc>:sl250m
r/@:r-@:r\@:@qq@q

Dwa bajty zapisane dzięki @Udioica!

Oto (nieco nieaktualna) animacja tego, co dzieje się w czasie rzeczywistym!

A oto wyjaśnienie:

qq                              " Start recording into register 'q'
  SLoading... |<esc>            " Replace all of the text in the buffer with 'Loading... |'
                    :sl250m     " Sleep for 250 ms
r/                              " Replace the bar with a slash
  @:                            " Re-run the last ex command (sleeping)
    r-                          " Replace the slash with a dash
      @:                        " Re-run the last ex command (sleeping)
        r\                      " Replace the dash with a backslash
          @:                    " Re-run the last ex command (sleeping)
            @q                  " Run macro 'q' (the one we're recording)
              q                 " Stop recording
               @q               " Call macro 'q', which will run forever because it's recursive

HTML + JS (ES6), 20 + 51 50 = 70 bajtów

setInterval(_=>a.innerHTML='|/-\\'[i=-~i%4],i=250)

Loading... <a id=a>-

-1 bajt (Zachary T)

Sprawdź również moją 132-bajtową odpowiedź HTML / CSS .

Windows Batch, 121 114 84 80 79 78 bajtów

Wyrzucam to dla zabawy.

for %%b in (/ - \ ^|)do (cls
@echo Loading... %%b
ping 1.1 -n 1 -w 250>nul)
%0

Nie mogłem przypisać potoku (| ) do tablicy, więc musiałem ręcznie dodać ją z innym przypisaniem.Opóźnienie jest zakończone PING, co może nie być dokładne .

Wynik:

Edytować:

• Dzięki Roman Gräf za oszczędność 7 bajtów!
• Dzięki Neil za oszczędność 30 bajtów! Zmodyfikowałem to również trochę, aby zaoszczędzić bajty na nowych liniach.
• Dzięki phyrfox za oszczędność 4 bajtów!
• Dzięki YourDeathIsComing za zapisanie 2 bajtów!

Węzeł, 72 70 bajtów

f=i=>console.log('\x1BcLoading... '+'|/-\\'[setTimeout(f,250,i=-~i%4),i])

Zamień \x1Bna dosłowny znak zmiany znaczenia, aby uzyskać prawidłową liczbę bajtów. Zadzwoń, f()aby rozpocząć animację. Oto jak to wygląda w emulatorze terminali ConEmu na moim komputerze:

Kotlin, 67 66 bajtów

while(1>0)"|/-\\".map{print("\rLoading... $it");Thread.sleep(250)}

Dość oczywiste, używając \rdo wyczyszczenia linii i wykorzystując niesamowitą interpolację strun Kotlina.

EDYCJA: Zapisano 1 bajt dzięki @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu poprzez zmianę while(true)nawhile(1>0)

Vim, 35 bajtów

iLoading... \-/|<Esc>qqdb:sl250m<CR>p@qq@q

Nudna wersja. Oto niezgodne rozwiązanie, które jest lepsze:

Vim (1 sekunda uśpienia), 27 bajtów

idbgsp@@<C-U>Loading... \-/|<Esc>@.

Korzystanie gsnie tylko jest znacznie krótsze, ale nie musisz naciskać Enter. Oznacza to, że makro pasuje do linii, a ja mogę zapisać bajty, przełączając się na @.. (Ponieważ nic po wywołaniu rekurencyjnym nigdy się nie uruchomi, mogę pisać, co chcę.)

Pyth, 31 bajtów

Wm,p+"\rLoading... "d.d.25"|/-\

Tłumacz ustny tutaj .

Wyjaśnienie

Wm,p+"\rLoading... "d.d.25"|/-\
    +"\rLoading... "d              Concatenate the string "\rLoading... " and the variable d
   p                               Print the result without a newline
                     .d.25         Sleep for 0.25 seconds
  ,                                Form a two-element list with the results of the two statements above. This is only needed to execute both statements in a single lambda function.
 m                        "|/-\    Map the above statement over the characters in the string "|/-\", setting the variable d to the character for each iteration
W                                  While the result of the map statement is true, do nothing

PowerShell (v4), 57 56 54 53 58 57 bajtów

Wracając do Bytecount, od którego zacząłem!

for(){cls;"Loading... "+"|/-\"[($a=++$a%4)];sleep -m 250}

Interfejs CLI w programie PowerShell nieco się zepsuje na niektórych komputerach, więc nie wygląda idealnie, ale jest tak dobry, jak to tylko możliwe.

Przeniesiono $ a ++ do pętli for, aby zapisać jeden bajt, (nie ;)

Następnie przeniosłem go do indeksu macierzy, aby zapisać kolejne 2 bajty, dzięki Romanowi za wskazanie tego.

Zapisano także jeszcze 1 bajt ( ;), przenosząc część Wyczyść ekran ( cls) w pętlę for.

Wskazany przez TimmyD problem i poprawka do nieskończonego aspektu pytania, wymagane tylko +5 Bajtów, zmienione $a++%4na ($a=++$a%4)tak, aby nigdy nie przekroczyło 3.

Zaoszczędzono kolejny bajt, pozostawiając pętlę for całkowicie pustą, dzięki „cokolwiek” za wskazanie, że jest to rzeczywiście możliwe w Powershell Version 4!

Nowa zaktualizowana gif dla (ostatecznej?) Wersji tej odpowiedzi.

for(;;cls){"Loading... "+"|/-\"[($a=++$a%4)];sleep -m 250}

for(;;cls){"Loading... "+"|/-\"[$a++%4];sleep -m 250}

for(;;){"Loading... "+"|/-\"[$a++%4];sleep -m 250;cls}

for(;;$a++){"Loading... "+"|/-\"[$a%4];sleep -m 250;cls}

for(;;){$a++;"Loading... "+"|/-\"[$a%4];sleep -m 250;cls}

Pyth - 36 35 bajtów

#+"\033cLoading... "@"\|/-"~hZ.d.25

Oczywiście nie działa online.

Matlab, 78 75 bajtów

a='\|/-';while 1;clc;disp(['Loading... ',a(1)]);a=a([2:4,1]);pause(1/4);end

HTML / CSS, 23 + 109 = 132 bajty

Poprawiono na odpowiedź Neila .

pre{display:flex}a{overflow:hidden;animation:a 1s steps(4)infinite;width:1ch}@keyframes a{to{text-indent:-4ch

<pre>Loading... <a>|/-\

Mathematica, 74 67 bajtów

ListAnimate["Loading... "<>#&/@{"|","/","-","\\"},AnimationRate->4]

Ogromne 7 bajtów off dzięki @dahnoak

C #, 170 133 bajtów

void X(){Console.Write("Loading...  ");for(;;){foreach(var c in "|/-\\"){Console.Write("\b"+c);System.Threading.Thread.Sleep(250);}}}

Ogromne podziękowania dla Romana Gräfa i Raznagula, którzy uratowali mi 37 bajtów. (Zwłaszcza raznagul, który zauważył, że moje oryginalne rozwiązanie i tak było nieważne. Trochę mi tam coś brakowało, ale teraz jest naprawione i powinno spełniać wymagania :)

dość podobny do istniejącej odpowiedzi C # Pete Arden, ale z pewnymi ulepszeniami

np. „for (;;)” zamiast „while (true)”, char zamiast string

Skomentowałbym moje sugestie dotyczące jego odpowiedzi, ale tak naprawdę nie mam wystarczającej reputacji, aby to zrobić.

Nie golfowany:

static void X()
{
    Console.Write("Loading...  ");
    for (;;)
    {
        foreach (var c in "|/-\\")
        {
            Console.Write("\b" + c);
            System.Threading.Thread.Sleep(250);
        }
    }
}

Naprzód, 72, 73 bajty

EDYCJA :

• Dodano wersję tylko Gforth, 69 bajtów (Thanks @ninjalj!)
• Dodano brakujące białe znaki po „Ładowanie ...” (Thx @ Roman Gräf!), +1 bajt
• Zaktualizowano w celu dokładniejszego dopasowania reguł (w tej samej liczbie bajtów)

Grał w golfa

: L '| '/ '- '\ begin .\" \rLoading... " 3 roll dup emit 250 ms again ; L

Wersja Gforth

Wersję tylko dla GNU Forth można sprowadzić do 69 bajtów w następujący sposób:

'| '/ '- '\ [begin] .\" \rLoading... " 3 roll dup emit 250 ms [again]

Screencast

Wypróbuj online!

Python 2, 81 79 78 77 bajtów

import time
i=1
while 1:print'\rLoading...','\|/-'[i%4],;i+=1;time.sleep(.25)

Całkiem proste rozwiązanie, które śpi przy użyciu time.

Używam \r(powrót karetki), aby wrócić do początku linii, a następnie wydrukować wiadomość zastępującą linię.

Zaczynam od i=1unikania podwójnego ucieczki \(To jest '\|/-'zamiast '|/-\\').

W przeszłości miałem -~ina myśli i + 1unikanie nawiasów. (Dzięki @ Flp.Tkc za te -2 bajty!) (Było i=(i+1)%4vs.i=-~i%4 )

Teraz pozwalam licznikowi rosnąć na zawsze, ponieważ technicznie rzecz biorąc, Python intnie może się przepełnić. Dzięki @Zachary T za wskazanie tego i zapisanie bajtu!
Zatrzymuje się tylko na komputerze, ponieważ zabrakło mu pamięci, ale zajmuje to 9,7 generacji z 4 GB pamięci dla tego int.

Dzięki @Kade za bajt -1, w którym print a,bwydruki ai bprzestrzeń były oddzielone, więc nie potrzebuję własnego miejsca.

Oto gif pracy w systemie Windows:

Przetestowałem to również na maszynie wirtualnej z systemem Linux. Nie mogłem przetestować tego na komputerze Mac.

MATL , 36 bajtów

Usunięto 1 bajt przy użyciu idei @ flawr polegającej na okrągłym przesuwaniu łańcucha

'\-/|'`Xx1YS'Loading... 'y1)hD.25Y.T

Oto nagranie gif z kompilatora offline:

Lub spróbuj w MATL Online!Jeśli początkowo nie uruchomi się, odśwież stronę i ponownie naciśnij „Uruchom”.

Jak to działa

'\-/|'           % Push this string
`                % Do...while
  Xx             %   Clear screen
  1YS            %   Circularly shift thr string 1 step to the right
  'Loading... '  %   Push this string
  y              %   Duplicate the string of shifting symbols
  1)             %   Get the first character
  hD             %   Concatenate the two strings and display
  .25Y.          %   Pause for 0.25 seconds
  T              %   Push "true". This is used as loop condition, to it
                 %   generates an infinite loop
                 % End loop implicitly

Dyalog APL, 50 bajtów

Działa to tylko w wersji Windows, ponieważ w przeciwnym razie ⎕SMokno nie będzie wyświetlane, chyba że ⎕SRzostanie wywołane.

{⎕SM←1 1,⍨⊂⊃⍵⌽'Loading... '∘,¨'|/-\'⋄∇4|⍵+⌈⎕DL÷4}1

Wyjaśnienie:

• {... }1: uruchom funkcję zaczynając od⍵=1
• Loading... '∘,¨'|/-\': wygeneruj cztery możliwe wyniki
• ⊂⊃⍵⌽: Obróć listę, aby umieścić ⍵ty element na pierwszym miejscu, weź pierwszy element i zamknij go
• ⎕SM←1 1,⍨: umieść ciąg w lewym górnym rogu ⎕SMokna.
• ⎕DL÷4: poczekaj 1/4 sekundy
• 4|⍵+⌈: zaokrąglij w górę uzyskaną wartość (sekundy spędzone na oczekiwaniu, więc zawsze jest to 1), dodaj ją do ⍵ (zwiększając ją) i weź mod-4 (aby zapobiec jego ostatecznemu przepełnieniu).
• ∇: uruchom funkcję ponownie z nowym ⍵.

C #, 187 bajtów

Gra w golfa:

void L(){Console.Write("Loading...");Action<string>l=(a)=>{Console.SetCursorPosition(11,0);System.Threading.Thread.Sleep(250);Console.Write(a);};while(true){l("|");l("/");l("-");l("\\");}

Nie golfowany:

public void L()
{
  Console.Write("Loading...");
  Action<string> l = (a) =>
  {
    Console.SetCursorPosition(11, 0);
    System.Threading.Thread.Sleep(250);
    Console.Write(a);
  };
  while (true)
  {
    l("|");
    l("/");
    l("-");
    l("\\");
  }
}

Wciąż czekam na załadowanie ...

Snap !, 8 bloków

To był jeden z pierwszych algorytmów, które kiedykolwiek zastanawiałem się na Apple] [np

siatkowy, niekonkurencyjny, 40 bajtów

:i=@C"Loading... "o"|/-\\".iHo14%w.i1+4,

Zapomniałem popełnić wiele rzeczy, w tym w. No cóż.

Wyjaśnienie

:i=@C"Loading... "o"|/-\\".iHo14%w.i1+4,
:i=                                       set `i` to the TOS
   @C                                     clear the screen
     "Loading... "o                       output that string
                   "|/-\\"                push that string
                          .i              get `i`
                            H             get the `i`th character of that string
                             o            and output it
                              14%         push 0.25 (1/4)
                                 w        wait that long
                                  .i      get `i`
                                    1+    increment
                                      4,  mod 4
                                          this wraps around the beginning of the program,
                                          setting i to the said value

Bash, 98 69 bajtów

while s='\|/-';do
printf "\rLoading... ${s:i=++i%4:1}"
sleep .25
done

Dziękujemy wielu ludziom za wiele bajtów!

Perl 6 , 72 61 bajtów

Supply.interval(1/4).tap: {print "\rLoading... ",<| / - \ >[$/++];$/%=4}

loop {print "\rLoading... ",<| / - \ >[$/++];$/%=4;sleep 1/4}

> <> , 55 + 4 = 59 bajtów

"...gnidaoL"v
l?!voc1. ^:<>
<v<>'\|/-'>^v
^<^<<<8{<<^o<

Musi biec -t .01 jako dodatkowy argument do interpretera, to jest +4 w liczbie bajtów.

Powoduje to umieszczenie czterech znaków do wydrukowania na stosie, wydrukowanie górnego bez wyjmowania go i przesunięcie stosu o jedną pozycję. Następnie drukuje\b (backspace, znak x08) i restartuje pętlę.

Czas jest osiągany przez argument przekazywany do interpretera, który zmusza do odczekania 0,01 sekundy przed wykonaniem każdej instrukcji. Pomiędzy wyjściem a następnym jest 23 instrukcji (większość z nich po prostu przenosi wskaźnik instrukcji do następnej komórki), więc będzie to czekało 0,23 sekundy plus czas potrzebny na wykonanie instrukcji, co bez problemu mieści się w wymaganych 0,25 s z 10% błędem.

Mógłbyś spróbować online , ale ten interpreter nie rozpoznaje znaku backspace, więc wynik będzie nieco dziwny.

Plik MS-DOS .COM, 56 bajtów

Tutaj zawartość pliku w systemie szesnastkowym:

b4 09 ba 2c 01 cd 21 b2 2f e8 11 00 b2 2d e8 0c
00 b2 5c e8 07 00 b2 7c e8 02 00 eb ea b4 02 cd
21 b2 08 cd 21 b9 05 00 f4 e2 fd c3 4c 6f 61 64
69 6e 67 2e 2e 2e 20 24

Pasujący kod asemblera wygląda następująco:

    mov ah, 9      ; Print "Loading... "
    mov dx, text
    int 21h
theloop:
    mov dl, '/'    ; Call "chrout" for "/", "-", "\" and "|"
    call chrout
    mov dl, '-'
    call chrout
    mov dl, '\'
    call chrout
    mov dl, '|'
    call chrout
    jmp theloop    ; Endless loop

chrout:            ; Sub-Function "chrout"
    mov ah, 2      ; Output the character
    int 21h
    mov dl, 8      ; Output backspace
    int 21h
    mov cx,5       ; Call "HLT" 5 times
timeloop:
    hlt            ; Normally HLT will wait ~55 milliseconds
                   ; (Assuming no keyboard key is pressed)
    loop timeloop
    ret            ; End of the function

text:
    ASCII "Loading... ",'$'

NASM x86_64 - 349 283 bajtów

Powinien to być 64-bitowy system Linux

zbudowany przy użyciu:

nasm loading_golfed.asm -felf64 && ld loading_golfed.o

%use altreg
global _start
section .data
o:db"Loading...  "
s:db"|/-\\"
b:db`\bx`
q:dq 0,250000000
_start:mov r0,1
mov r7,1
mov r6,o
mov r2,12
syscall
mov r2,2
l:mov r7,1
mov al,[s+r8]
mov [b+1],al
mov r0,1
mov r6,b
syscall
mov r0,35
lea r7,[q]
mov r6,0
syscall
inc r8
and r8,3
jmp l

animacja:

zapisano 65 bajtów - dzięki użytkownik254948

R, 85 89 bajtów

repeat{if(T>4)T=1;cat("\fLoading...",c("|","/","-","\\")[T],sep="");T=T+1;Sys.sleep(.25)}

Edycja: Naprawiono odpowiedź, która Tnie przepełnia się, resetując licznik, jeśli jest większy niż4 .

Jedynym interesującym aspektem o tej odpowiedzi jest wykorzystanie R za TRUTHYwbudowanego polecenia T. Jest to właściwie predefiniowany zestaw zmiennych, 1/TRUEco oznacza, że ​​nie musimy inicjować licznika, ale możemy zacząć zwiększać T.

Haskell (GHC), 103 91 bajtów

import GHC.Conc
mapM((>>threadDelay 250000).putStr)$("\rLoading... "++).pure<$>cycle"|/-\\"

Dzięki @nimi za uratowanie 12 bajtów!

C (w systemach typu UNIX) 88 bajtów

main(_){for(;;){_%=4;printf("\rLoading... %c","\\-/|"[_++]);fflush(0);usleep(250000);}}

Zaczyna się od niewłaściwej postaci, ale myślę, że wygląda ładniej. Możesz łatwo zmienić kolejność znaków, modyfikując „\ - / |” strunowy.

Perl, 71 63 61 bajtów

s//\rLoading... |/;select$\,$\,$\,y'-|\/'\/|-'/4while$|=print

Poprzednia wersja:

$_="\rLoading... |";{$|=print;y#|/\-\\#/\-\\|#;select$\,$\,$\,.25;redo}

Dzięki za @primo za 10 bajtów.