Ihre Herausforderung besteht darin, einen unendlichen Ladebildschirm zu erstellen, der so aussieht:

Oder um genauer zu sein:

• Nehmen Sie keine Eingabe.
• Ausgabe Loading...mit nachgestelltem Leerzeichen, jedoch ohne nachgestellte Zeile.
• Stufenlos zyklisch durch die Zeichen |, /, -und \: alle 0,25 Sekunden überschreiben die letzte mit der nächsten in der Sequenz. Sie können nur das letzte Zeichen überschreiben oder die gesamte Zeile löschen und neu schreiben, solange Loading...nichts geändert wird.

Regeln

• Der Ausgabetext muss genau wie angegeben aussehen. Nachgestellte Zeilenumbrüche / Leerzeichen sind zulässig.
• Sie sollten nicht 0,25 Sekunden warten, bevor Sie die Ausgabe zum ersten Mal anzeigen - das erste Bild sollte gedruckt werden, sobald das Programm ausgeführt wird.
• Ihr Programm sollte auf unbestimmte Zeit ausgeführt werden können. Wenn Sie beispielsweise einen Zähler für Frames verwenden, sollte der Zähler niemals einen Fehler verursachen, indem er das Maximum in Ihrer Sprache überschreitet.
• Obwohl die Wartezeit zwischen jedem "Frame" 0,25 Sekunden betragen sollte, wird dies offensichtlich niemals exakt sein - eine Fehlerspanne von etwa 10% ist zulässig.
• Sie können eine Funktion übermitteln, diese muss jedoch an gesendet werden stdout.
• Sie können eine Antwort in einer Nicht-Konsolenumgebung (aber immer noch textbasiert) senden, sofern die Ladeanimation erstellt werden kann.
• Das ist Code-Golf , also gewinnt die kürzeste Lösung (in Bytes). Es gelten Standard-Code-Golf-Regelungslücken.
• Geben Sie nach Möglichkeit ein GIF Ihres Ladebildschirms in Aktion an.

Beispiel

Hier ist der C ++ - Code, mit dem ich das Beispiel erstellt habe (ungolfed):

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

Möge der beste Golfer gewinnen!

HTML / CSS, 183 180 163 161 160 147 143 Bytes

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>

Bearbeiten: 3 Bytes dank @betseg gespeichert. 17 Bytes dank @manatwork eingespart. 1 Byte dank @Daniel gespeichert. 13 Bytes dank @Ismael Miguel gespeichert. 4 Bytes dank @Fez Vrasta gespeichert.

Vim, 43 , 41 Bytes

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

Zwei Bytes gespart dank @Udioica!

Hier ist eine (etwas veraltete) Animation davon in Echtzeit!

Und hier ist eine Erklärung:

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 Byte

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

Loading... <a id=a>-

-1 Byte (Zachary T)

Schauen Sie sich auch meine 132-Byte-HTML / CSS-Antwort an.

Windows Batch, 121 114 84 80 79 78 Bytes

Einfach aus Spaß rausschmeißen.

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

Ich konnte |dem Array kein pipe ( ) zuweisen , daher musste ich es manuell mit einer anderen Zuweisung hinzufügen.Die Verzögerung wird mit ausgeführt PING, was möglicherweise nicht genau ist .

Ausgabe:

Bearbeiten:

• Vielen Dank an Roman Gräf für das Speichern von 7 Bytes!
• Vielen Dank an Neil für das Speichern von 30 Bytes! Ich habe es auch ein bisschen mehr entstellt, um Bytes in den Zeilenumbrüchen zu sparen.
• Danke an phyrfox für das Speichern von 4 Bytes!
• Danke an YourDeathIsComing für das Sparen von 2 Bytes!

Knoten, 72-70 Bytes

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

Ersetzen Sie \x1Bdurch das Escape-Zeichen, um die richtige Byteanzahl zu erhalten. Rufen Sie f()an, um die Animation zu starten. So sieht es im ConEmu-Terminalemulator auf meinem Computer aus:

Kotlin, 67 66 Bytes

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

Ziemlich selbsterklärend, \rum die Linie zu löschen und Kotlins fantastische String-Interpolation zu nutzen.

BEARBEITEN: 1 Byte dank @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu durch Ändern while(true)von gespeichertwhile(1>0)

Vim, 35 Bytes

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

Die langweilige Version. Hier ist eine nicht konforme Lösung, die besser ist:

Vim (1 Sekunde Schlaf), 27 Bytes

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

Die Verwendung von ist gsnicht nur viel kürzer, sondern Sie müssen auch nicht die Eingabetaste drücken. Das bedeutet, dass das Makro in die Zeile passt und ich durch Umschalten auf Bytes sparen kann @.. (Da nach dem rekursiven Aufruf nichts mehr ausgeführt werden kann, kann ich eingeben, was ich will.)

Pyth, 31 Bytes

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

Dolmetscher hier .

Erläuterung

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 Bytes

Zurück beim Bytecount, mit dem ich angefangen habe!

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

Die CLI in Powershell wird auf einigen Computern leicht fehlerhaft sein, sodass sie nicht perfekt aussieht, aber so gut, wie ich es mir vorstellen kann.

$ A ++ in die for-Schleife verschoben, um ein Byte zu speichern (nein ;)

Verschob es dann in den Array-Indexer, um weitere 2 Byte zu sparen, danke an Roman, der darauf hingewiesen hat.

Sie können auch 1 weiteres Byte ( ;) speichern, indem Sie den Teil Clear screen ( cls) in die for-Schleife verschieben.

Problem und Fehlerbehebung, auf die TimmyD für den unendlichen Aspekt der Frage hingewiesen hat, nur +5 Bytes erforderlich, geändert $a++%4in, ($a=++$a%4)sodass es niemals über 3 hinausgeht .

Sie haben ein weiteres Byte gespeichert, indem Sie die for-Schleife leer gelassen haben, dank 'whatever', um darauf hinzuweisen, dass dies in Powershell Version 4 tatsächlich möglich ist!

Neues aktualisiertes GIF für die (endgültige?) Version dieser Antwort.

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 Bytes

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

Funktioniert natürlich nicht online.

Matlab, 78 75 Bytes

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

HTML / CSS, 23 + 109 = 132 Bytes

Neils Antwort wurde verbessert .

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 Bytes

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

Satte 7 Bytes weniger dank @dahnoak

C #, 170 133 Bytes

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

Ein großes Dankeschön an Roman Gräf und raznagul, die mir 37 Bytes gerettet haben. (Besonders raznagul, der darauf hinwies, dass meine ursprüngliche Lösung sowieso ungültig war. Ich habe dort etwas verpasst, aber es ist jetzt behoben und sollte die Anforderungen erfüllen :)

ziemlich ähnlich zu Pete Ardens bestehender C # -Antwort, aber mit einigen Verbesserungen

zB "for (;;)" anstelle von "while (true)", char anstelle von string

Ich hätte meine Vorschläge zu seiner Antwort kommentiert, aber ich habe nicht genug Ruf, um das zu tun.

Ungolfed:

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

Forth, 7273 Bytes

EDIT :

• Hinzugefügt die Gforth-only-Version, 69 Bytes (Danke @ninjalj!)
• Fehlendes Leerzeichen nach "Loading ..." hinzugefügt (Thx @Roman Gräf!), +1 Byte
• Aktualisiert, um den Regeln genauer zu entsprechen (in derselben Byteanzahl)

Golf gespielt

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

Gforth-Version

Die GNU Forth-only-Version kann wie folgt auf 69 Bytes reduziert werden:

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

Screencast

Probieren Sie es online!

Python 2, 81 79 78 77 Bytes

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

Eine ganz einfache Lösung, mit der man schläft time.

Ich benutze \r(Wagenrücklauf), um zum Zeilenanfang zurückzukehren und dann die Nachricht auszudrucken, die die Zeile überschreibt.

Ich beginne mit i=1Doppel zu vermeiden Flucht der \(Es ist '\|/-'statt '|/-\\').

Früher hatte ich -~igemeint i + 1, Klammern zu vermeiden. (Danke an @ Flp.Tkc für diese -2 Bytes!) (Es war i=(i+1)%4vs. i=-~i%4)

Jetzt lasse ich nur den Zähler für immer steigen, da Pythons technisch intnicht überlaufen können. Vielen Dank an @Zachary T für den Hinweis und das Speichern eines Bytes!
Es wird nur auf einem Computer angehalten, weil auf dem Computer nicht mehr genügend Arbeitsspeicher vorhanden ist. Für diesen Computer sind jedoch 9,7 Generationen mit 4 GB Arbeitsspeicher erforderlich int.

Dank an @Kade für das -1-Byte, bei dem print a,bDrucke aund bSpeicherplatz getrennt sind, sodass ich keinen eigenen Speicherplatz benötige.

Hier ist ein GIF davon, das unter Windows funktioniert:

Ich habe es auch auf einer Linux-VM getestet. Ich konnte es nicht auf einem Mac testen.

MATL , 36 Bytes

1 Byte entfernt mit der Idee von @ flawr , den String zirkulär zu verschieben

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

Hier ist eine GIF-Aufnahme vom Offline-Compiler:

Oder probieren Sie es bei MATL Online! Wenn es anfänglich nicht ausgeführt wird, aktualisieren Sie die Seite und klicken Sie erneut auf "Ausführen".

Wie es funktioniert

'\-/|'           % 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 Bytes

Dies funktioniert nur in der Windows-Version, da das ⎕SMFenster sonst nur angezeigt wird, wenn ⎕SRes aufgerufen wird.

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

Erläuterung:

• {... }1: führe die Funktion beginnend mit aus⍵=1
• Loading... '∘,¨'|/-\': Die vier möglichen Ausgaben erzeugen
• ⊂⊃⍵⌽: Drehen Sie die Liste, um das ⍵te Element an die erste Stelle zu setzen, nehmen Sie das erste Element und schließen Sie es ein
• ⎕SM←1 1,⍨: Lege den String in die obere linke Ecke des ⎕SMFensters.
• ⎕DL÷4: warte 1/4 Sekunde
• 4|⍵+⌈: Runden Sie den resultierenden Wert auf (Sekunden Wartezeit, also immer 1), addieren Sie ihn zu ⍵(inkrementieren Sie ihn) und nehmen Sie den Mod-4 (um zu verhindern, dass er irgendwann überläuft).
• ∇: Führen Sie die Funktion erneut mit dem neuen aus ⍵.

C #, 187 Bytes

Golf gespielt:

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("\\");}

Ungolfed:

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("\\");
  }
}

Ich warte immer noch darauf, dass es geladen wird ...

Fang !, 8 Blöcke

Dies war einer der allerersten Algorithmen, die ich jemals auf einem Apple ausprobiert habe] [e

netzförmig, nicht konkurrierend, 40 Bytes

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

Ich habe vergessen, eine Reihe von Dingen zu begehen, einschließlich w. Naja.

Erläuterung

: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 bis 69 Bytes

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

Vielen Dank an viele Leute für die vielen Bytes!

Perl 6 , 72 61 Bytes

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

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

> <> , 55 + 4 = 59 Bytes

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

Muss -t .01als zusätzliches Argument an den Interpreter übergeben werden, das ist die +4 in der Byteanzahl.

Dies setzt die vier zu druckenden Zeichen auf den Stapel, druckt das oberste, ohne es zu entfernen, und verschiebt den Stapel um eine Position. Dann wird gedruckt \b(Rücktaste, Zeichen x08) und die Schleife neu gestartet.

Das Timing wird durch das an den Interpreter übergebene Argument erreicht, das eine Wartezeit von 0,01 Sekunden vor der Ausführung der einzelnen Befehle erzwingt. Es gibt 23 Anweisungen zwischen einer Ausgabe und der nächsten (die meisten von ihnen bewegen einfach den Anweisungszeiger zur nächsten Zelle), so dass dies 0,23 Sekunden plus der für die Ausführung der Anweisungen erforderlichen Zeit wartet, die problemlos in die angeforderten 0,25 Sekunden passt mit 10% Fehler.

Sie könnten es online versuchen , aber dieser Interpreter erkennt das Backspace-Zeichen nicht, so dass die Ausgabe dort etwas seltsam sein wird.

MS-DOS-COM-Datei, 56 Byte

Hier der Dateiinhalt in hexadezimaler Schreibweise:

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

Der übereinstimmende Assembler-Code sieht folgendermaßen aus:

    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 Byte

Dies sollte 64-Bit-Linux-Systeme ausgeführt werden

gebaut mit:

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

Animation:

65 Bytes gespart - danke user254948

R 85 89 Bytes

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

Bearbeiten: Die Antwort wurde so Tkorrigiert, dass sie nicht überläuft, wenn der Zähler zurückgesetzt wird 4.

Der einzig interessante Aspekt bei dieser Antwort ist die Verwendung von TRUTHYRs eingebautem Code T. Es ist praktisch ein vordefinierter Variablensatz, 1/TRUEdh wir müssen den Zähler nicht initialisieren, sondern können mit dem Inkrementieren beginnen T.

Haskell (GHC), 103-91 Bytes

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

Vielen Dank an @nimi für das Speichern von 12 Bytes!

C (auf UNIX-ähnlichen Systemen) 88 Byte

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

Es beginnt mit dem falschen Charakter, aber ich denke, es sieht schöner aus. Sie können die Zeichenreihenfolge ganz einfach ändern, indem Sie "\ - / |" Zeichenfolge.

Perl, 71 63 61 Bytes

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

Vorherige Version:

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

Vielen Dank an @primo für 10 Bytes.