La tua sfida è quella di creare una schermata di caricamento infinita, che assomigli a questa:

O, per essere più specifici:

• Non dare input.
• Output Loading..., con uno spazio finale, ma nessuna riga finale finale.
• Ciclo all'infinito attraverso i caratteri |, /, -e \: ogni 0,25 secondi, sovrascrivere l'ultimo con il successivo nella sequenza. È possibile sovrascrivere solo l'ultimo carattere oppure eliminare e riscrivere l'intera riga, a condizione che Loading...rimanga invariato.

Regole

• Il testo di output deve apparire esattamente come specificato. Newline / spazi finali sono accettabili.
• Si dovrebbe Non attendere 0.25 secondi prima di mostrare inizialmente in uscita - il primo fotogramma deve essere stampato non appena il programma viene eseguito.
• Il tuo programma dovrebbe essere in grado di funzionare all'infinito. Ad esempio, se si utilizza un contatore per i frame, il contatore non dovrebbe mai causare un errore superando il massimo nella propria lingua.
• Sebbene il periodo di attesa tra ciascun "frame" dovrebbe essere di 0,25 secondi, ovviamente questo non sarà mai esatto - è consentito un margine di errore del 10% circa.
• È possibile inviare una funzione, ma deve stampare su stdout.
• È possibile inviare una risposta in un ambiente non console (ma ancora basato su testo), purché sia ​​in grado di produrre l'animazione di caricamento.
• Questo è code-golf , quindi vince la soluzione più breve (in byte). Si applicano scappatoie standard per il golf da codice.
• Se possibile, fornisci una gif della schermata di caricamento in azione.

Esempio

Ecco il codice C ++ che ho usato per creare l'esempio (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;
    }
}

Che vinca il migliore golfista!

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

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>

Modifica: 3 byte salvati grazie a @betseg. Risparmiato 17 byte grazie a @manatwork. Salvato 1 byte grazie a @Daniel. Salvato 13 byte grazie a @Ismael Miguel. Salvato 4 byte grazie a @Fez Vrasta.

Vim, 43 , 41 byte

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

Due byte salvati grazie a @Udioica!

Ecco un'animazione (leggermente obsoleta) che accade in tempo reale!

Ed ecco una spiegazione:

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)

Scopri anche la mia risposta HTML / CSS a 132 byte .

Windows Batch, 121 114 84 80 79 78 byte

Basta buttarlo fuori per divertimento.

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

Non sono stato in grado di assegnare pipe ( |) nell'array, quindi ho dovuto aggiungerlo manualmente con un altro compito.Il ritardo è terminato PING, il che potrebbe non essere preciso .

Produzione:

Modificare:

• Grazie a Roman Gräf per aver salvato 7 byte!
• Grazie a Neil per aver salvato 30 byte! L'ho anche modificato un po 'di più per salvare byte sulle newline.
• Grazie a phyrfox per aver salvato 4 byte!
• Grazie a YourDeathIsComing per aver salvato 2 byte!

Nodo, 72 70 byte

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

Sostituisci \x1Bcon il carattere di escape letterale per ottenere il conteggio di byte corretto. Chiama f()per avviare l'animazione. Ecco come appare nell'emulatore di terminale ConEmu sul mio computer:

Kotlin, 67 66 byte

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

Abbastanza autoesplicativo, usando \rper cancellare la linea e approfittare della straordinaria interpolazione di stringhe di Kotlin.

EDIT: salvato 1 byte grazie a @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu cambiando while(true)inwhile(1>0)

Vim, 35 byte

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

La versione noiosa. Ecco una soluzione non conforme che è meglio:

Vim (1 secondo di sospensione), 27 byte

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

L'uso gsnon solo è molto più breve, ma non è necessario premere Invio. Ciò significa che la macro si adatta in linea e posso salvare byte passando a @.. (Dal momento che nulla dopo la chiamata ricorsiva può mai essere eseguito, posso digitare quello che voglio.)

Pyth, 31 byte

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

Interprete qui .

Spiegazione

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 byte

Torna al Bytecount con cui ho iniziato!

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

L'interfaccia della riga di comando in PowerShell si spegnerà leggermente su alcuni computer, quindi non sembra perfetta, ma è buona quanto posso ottenere.

Spostato $ a ++ nel ciclo for per salvare un byte, (no ;)

Quindi lo ha spostato nell'indicizzatore di array, per un altro salvataggio di 2 byte, grazie a Roman per averlo sottolineato.

Inoltre ho salvato un altro byte ( ;) spostando la parte Clear screen ( cls) nel ciclo for ..

Problema e correzione segnalati da TimmyD per l'aspetto infinito della domanda, richiesti solo +5 byte, modificati $a++%4in ($a=++$a%4)modo che non superino mai i 3.

Hai salvato un altro byte lasciando vuoto il ciclo for, grazie a "qualunque" per aver sottolineato che ciò è effettivamente possibile nella versione 4 di Powershell!

Nuova gif aggiornata per la versione (finale?) Di questa risposta.

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 byte

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

Non funziona online, ovviamente.

Matlab, 78 75 byte

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

HTML / CSS, 23 + 109 = 132 byte

Migliorato sulla risposta di Neil .

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 byte

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

Un enorme 7 byte grazie a @dahnoak

C #, 170 133 byte

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

Grazie mille a Roman Gräf e raznagul, che mi hanno salvato 37 byte. (Soprattutto raznagul, che ha sottolineato, che la mia soluzione originale non era valida comunque. Mi sono perso qualcosa, ma ora è stato risolto e dovrebbe soddisfare i requisiti :)

abbastanza simile alla risposta C # esistente di Pete Arden ma con alcuni miglioramenti

ad es. "for (;;)" invece di "while (true)", char anziché string

Avrei commentato i miei suggerimenti sulla sua risposta, ma in realtà non ho abbastanza reputazione per farlo.

Ungolfed:

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

Via, 72, 73 byte

MODIFICA :

• Aggiunta la versione solo Gforth, 69 byte (Grazie @ninjalj!)
• Aggiunto spazio vuoto mancante dopo "Caricamento in corso ..." (Thx @Roman Gräf!), +1 byte
• Aggiornato per abbinare le regole in modo più preciso (nello stesso conteggio byte)

golfed

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

Versione Gforth

La versione solo per GNU Forth può essere ridotta a 69 byte in questo modo:

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

screencast

Provalo online!

Python 2, 81 79 78 77 byte

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

Piuttosto una soluzione semplice che dorme usando time .

Io uso \r (Ritorno a capo) per tornare all'inizio della riga e quindi stampare il messaggio sovrascrivendo la riga.

Comincio con i=1per evitare il doppio escape del \(è '\|/-'invece di '|/-\\').

In passato, avevo usato -~iper significare i + 1per evitare parentesi. (Grazie a @ Flp.Tkc per questi -2 byte!) (Era i=(i+1)%4vs. i=-~i%4)

Ora, sto solo lasciando che il contatore salga per sempre, dal momento che tecnicamente Python intnon può traboccare. Grazie a @Zachary T per averlo sottolineato e salvato un byte!
Si ferma solo su una macchina perché la macchina ha esaurito la memoria, ma ciò richiede 9,7 generazioni con 4 GB di memoria per quella int.

Grazie a @Kade per il -1 byte in cui print a,bstampe ae bspazio sono separati, quindi non ho bisogno del mio spazio.

Ecco una gif che funziona su Windows:

L'ho provato anche su una VM Linux. Non ho potuto provarlo su un Mac.

MATL , 36 byte

1 byte rimosso usando l'idea di @ flawr di spostare circolarmente la stringa

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

Ecco una registrazione gif dal compilatore offline:

Oppure provalo su MATL Online! Se inizialmente non viene eseguito, aggiornare la pagina e premere nuovamente "Esegui".

Come funziona

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

Funziona solo nella versione Windows, altrimenti la ⎕SMfinestra non mostrerà se non ⎕SRviene chiamata.

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

Spiegazione:

• {... }1: avvia la funzione che inizia con⍵=1
• Loading... '∘,¨'|/-\': genera le quattro possibili uscite
• ⊂⊃⍵⌽: Ruota l'elenco per inserire prima il primo elemento, prendi il primo elemento e racchiudilo
• ⎕SM←1 1,⍨: posiziona la stringa nell'angolo in alto a sinistra della ⎕SMfinestra.
• ⎕DL÷4: attendere 1/4 di secondo
• 4|⍵+⌈: arrotondare per eccesso il valore risultante (secondi trascorsi in attesa, quindi è sempre 1), aggiungerlo a ⍵(incrementandolo) e prendere il mod-4 (per evitare che alla fine trabocchi).
• ∇: esegue nuovamente la funzione con il nuovo ⍵.

C #, 187 byte

golfed:

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

Aspetto ancora che si carichi ...

Snap !, 8 blocchi

Questo è stato uno dei primissimi algoritmi che abbia mai lasciato perplesso su una Apple] [e

reticolare, non competitivo, 40 byte

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

Ho dimenticato di commettere un sacco di cose, incluso w. Oh bene.

Spiegazione

: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 byte

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

Grazie a molte persone per i tanti byte giocati a golf!

Perl 6 , 72 61 byte

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

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

> <> , 55 + 4 = 59 byte

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

Deve essere eseguito passando -t .01 come argomento aggiuntivo all'interprete, ovvero il +4 nel conteggio dei byte.

Ciò che fa è mettere i quattro personaggi da stampare in pila, stampando quello in alto senza rimuoverlo e spostando la pila di una posizione. Quindi stampa\b (backspace, carattere x08) e riavvia il ciclo.

Il tempismo è raggiunto dall'argomento passato all'interprete, che forza ad attendere 0,01 secondi prima di eseguire ciascuna istruzione. Esistono 23 istruzioni tra un'uscita e la successiva (la maggior parte di esse sposta semplicemente il puntatore delle istruzioni sulla cella successiva), quindi questo attenderà 0,23 secondi più il tempo necessario per eseguire le istruzioni, che si adatta senza problemi agli 0,25 richiesti con errore del 10%.

Potresti provarlo online , ma quell'interprete non riconosce il carattere backspace, quindi l'output sarà un po 'strano lì.

File .COM MS-DOS, 56 byte

Qui il contenuto del file in esadecimale:

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

Il codice dell'assemblatore corrispondente è simile al seguente:

    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

Dovrebbero essere eseguiti sistemi Linux a 64 bit

costruito usando:

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

animazione:

salvato 65 byte - grazie user254948

R, 85 89 byte

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

Modifica: risolto il problema in modo tale che Tnon traboccasse ripristinando il contatore se maggiore di 4.

L'unico aspetto interessante di questa risposta è l'uso di R TRUTHYintegrato T. È effettivamente un set di variabili predefinito, il 1/TRUEche significa che non è necessario inizializzare il contatore, ma è possibile iniziare l'incremento T.

Haskell (GHC), 103 91 byte

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

Grazie @nimi per aver salvato 12 byte!

C (su sistemi tipo UNIX) 88 byte

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

Inizia con il personaggio sbagliato, ma penso che sia più bello. Puoi facilmente cambiare l'ordine dei caratteri modificando "\ - / |" corda.

Perl, 71 63 61 byte

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

Versione precedente:

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

Grazie a @primo per 10 byte.