Seu desafio é criar uma tela de carregamento infinita, com a seguinte aparência:

Ou, para ser mais específico:

• Não aceite nenhuma entrada.
• Saída Loading..., com um espaço à direita, mas sem nova linha à direita.
• Ciclo infinitamente através dos caracteres |, /, -e \: a cada 0,25 segundos, substituir o último com o seguinte na sequência. Você pode substituir apenas o último caractere ou excluir e reescrever a linha inteira, desde que Loading...permaneça inalterada.

Regras

• O texto de saída deve parecer exatamente como especificado. Novas linhas / espaços à direita são aceitáveis.
• Você não deve esperar 0,25 segundos antes de mostrar inicialmente a saída - o primeiro quadro deve ser impresso assim que o programa for executado.
• Seu programa deve ser capaz de executar indefinidamente. Por exemplo, se você usar um contador para quadros, o contador nunca deverá causar um erro excedendo o máximo no seu idioma.
• Embora o período de espera entre cada "quadro" deva ser de 0,25 segundos, obviamente isso nunca será exato - uma margem de erro de 10% ou mais é permitida.
• Você pode enviar uma função, mas ela deve ser impressa em stdout.
• Você pode enviar uma resposta em um ambiente que não seja do console (mas ainda com base em texto), desde que seja capaz de produzir a animação de carregamento.
• Isso é código-golfe , então a solução mais curta (em bytes) vence. Aplicam-se lacunas de código-golfe padrão.
• Se possível, forneça um gif da sua tela de carregamento em ação.

Exemplo

Aqui está o código C ++ que eu usei para criar o exemplo (não-destruído):

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

Que ganhe o melhor jogador de golfe!

HTML / CSS, 183 180 163 161 160 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>

Editar: salvou 3 bytes graças a @betseg. Economizou 17 bytes graças a @manatwork. Guardou 1 byte graças a @Daniel. Guardou 13 bytes graças a @Ismael Miguel. Guardado 4 bytes graças a @Fez Vrasta.

Vim, 43 , 41 bytes

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

Dois bytes salvos graças ao @Udioica!

Aqui está uma animação (um pouco desatualizada) acontecendo em tempo real!

E aqui está uma explicação:

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 bytes

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

Loading... <a id=a>-

-1 byte (Zachary T)

Confira minha resposta HTML / CSS de 132 bytes também.

Lote do Windows, 121 114 84 80 79 78 bytes

Apenas jogando isso fora por diversão.

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

Como não consegui atribuir pipe ( |) à matriz, tive que adicioná-lo manualmente com outra atribuição.O atraso está concluído PING, o que pode não ser preciso .

Resultado:

Editar:

• Obrigado a Roman Gräf por economizar 7 bytes!
• Agradecimentos a Neil por salvar 30 bytes! Também modifiquei um pouco mais para salvar bytes nas novas linhas.
• Obrigado ao phyrfox por salvar 4 bytes!
• Obrigado a YourDeathIsComing por salvar 2 bytes!

Nó, 72 70 bytes

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

Substitua \x1Bpelo caractere de escape literal para obter a contagem correta de bytes. Ligue f()para iniciar a animação. Veja como fica no emulador de terminal ConEmu no meu computador:

Kotlin, 67 66 bytes

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

Bastante auto-explicativo, usando \rpara limpar a linha e aproveitando a incrível interpolação de cordas de Kotlin.

EDIT: Salvo 1 byte graças a @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu, alterando while(true)parawhile(1>0)

Vim, 35 bytes

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

A versão chata. Aqui está uma solução não conforme que é melhor:

Vim (1 segundo de suspensão), 27 bytes

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

Usar gsnão apenas é muito mais curto, mas você não precisa pressionar Enter. Isso significa que a macro se encaixa na linha e eu posso salvar bytes alternando para @.. (Como nada depois da chamada recursiva pode ser executado, eu posso digitar o que quiser.)

Pitão, 31 bytes

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

Intérprete aqui .

Explicação

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

De volta ao Bytecount eu comecei com!

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

A CLI no PowerShell falha levemente em alguns computadores, por isso não parece perfeita, mas é a melhor possível.

Moveu $ a ++ para o loop for para salvar um byte, (não ;)

Em seguida, mova-o para o indexador de matriz, para outro salvamento de 2 bytes, graças a Roman por apontar isso.

Também salvou mais 1 byte ( ;) movendo a parte Limpar tela ( cls) para o loop for.

Edição e corrigir apontado por TimmyD para o aspecto infinito da questão, apenas cinco Bytes necessário, mudou $a++%4para ($a=++$a%4)que ele nunca vai acima de 3.

Salve outro byte deixando o loop for totalmente em branco, graças a 'qualquer coisa' por indicar que isso é realmente possível no Powershell versão 4!

Novo gif atualizado para a versão (final?) Desta resposta.

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}

Pitão - 36 35 bytes

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

Não funciona online, obviamente.

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

Melhorado com a resposta de 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 Bytes

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

Gritante 7 bytes de desconto graças a @dahnoak

C #, 170 133 Bytes

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

Muito obrigado a Roman Gräf e raznagul, que me salvaram 37 bytes. (Especialmente raznagul, que apontou, que minha solução original era inválida de qualquer maneira. Eu meio que perdi alguma coisa lá, mas ela está corrigida agora e deve atender aos requisitos :)

bastante semelhante à resposta C # existente de Pete Arden, mas com algumas melhorias

por exemplo "for (;;)" em vez de "while (true)", char em vez de string

Eu teria comentado minhas sugestões sobre a resposta dele, mas na verdade não tenho reputação suficiente para fazer isso.

Ungolfed:

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

Adiante, 72, 73 bytes

EDIT :

• Adicionada a versão Gforth-only, 69 bytes (Obrigado @ninjalj!)
• Adicionado espaço em branco ausente após "Carregando ..." (Thx @Roman Gräf!), +1 byte
• Atualizado para corresponder às regras com mais precisão (na mesma contagem de bytes)

Golfe

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

Versão Gforth

A versão GNU Forth-only pode ser reduzida para 69 bytes assim:

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

Screencast

Experimente online!

Python 2, 81 79 78 77 bytes

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

Uma solução bastante simples que dorme usando time.

Uso \r(Um retorno de carro) para voltar ao início da linha e, em seguida, imprimo a mensagem substituindo a linha.

Começo com i=1para evitar o duplo escape do \(é em '\|/-'vez de '|/-\\').

No passado, eu costumava -~iquerer i + 1evitar parênteses. (Obrigado a @ Flp.Tkc por esses -2 bytes!) (Foi i=(i+1)%4contra i=-~i%4)

Agora, estou deixando o contador subir para sempre, já que tecnicamente o Python intnão pode transbordar. Obrigado a @Zachary T por apontar isso e salvar um byte!
Ele só para em uma máquina porque ela fica sem memória, mas isso leva 9,7 gerações, com 4 GB de memória para aquela int.

Graças ao @Kade, pelo -1 byte em que as print a,bimpressões ae o bespaço são separados, para que eu não precise do meu próprio espaço.

Aqui está um gif dele trabalhando no Windows:

Também testei em uma VM Linux. Não pude testá-lo em um Mac.

MATL , 36 bytes

1 byte removido usando a idéia de @ flawr de mudar circularmente a string

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

Aqui está uma gravação gif do compilador offline:

Ou tente no MATL Online! Se não for executado inicialmente, atualize a página e pressione "Executar" novamente.

Como funciona

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

Isso funciona apenas na versão do Windows; caso contrário, a ⎕SMjanela não será exibida, a menos que ⎕SRseja chamado.

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

Explicação:

• {... }1: execute a função começando com⍵=1
• Loading... '∘,¨'|/-\': gerar as quatro saídas possíveis
• ⊂⊃⍵⌽: Gire a lista para colocar o décimo elemento primeiro, pegue o primeiro elemento e coloque-o
• ⎕SM←1 1,⍨: coloque a corda no canto superior esquerdo da ⎕SMjanela.
• ⎕DL÷4: aguarde 1/4 de segundo
• 4|⍵+⌈: arredonde o valor resultante (segundos gastos em espera, portanto, esse é sempre 1), adicione-o ⍵(aumente-o) e use o mod-4 (para evitar que ele transborde).
• ∇: execute a função novamente com o novo ⍵.

C #, 187 bytes

Golfe:

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

Ainda esperando o carregamento ...

Snap !, 8 blocos

Este foi um dos primeiros algoritmos que eu já descobri em uma Apple] [e

reticular, não-competitivo, 40 bytes

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

Eu esqueci de cometer um monte de coisas, inclusive w. Ah bem.

Explicação

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

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

Obrigado a muitas pessoas pelos muitos bytes jogados fora!

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<

Deve ser executado passando -t .01como argumento adicional para o intérprete, que é o +4 na contagem de bytes.

O que isso faz é colocar os quatro caracteres a serem impressos na pilha, imprimir o de cima sem removê-lo e mudar a pilha por uma posição. Em seguida, ele imprime \b(backspace, caractere x08) e reinicia o loop.

O tempo é alcançado pelo argumento passado ao intérprete, o que força a aguardar 0,01 segundo antes de executar cada instrução. Existem 23 instruções entre uma saída e a próxima (a maioria simplesmente move o ponteiro da instrução para a próxima célula); portanto, isso irá esperar 0,23 segundos mais o tempo necessário para executar as instruções, o que se encaixa sem problemas nos 0,25s solicitados. com 10% de erro.

Você pode tentar online , mas esse intérprete não reconhece o caractere de backspace, portanto a saída será um pouco estranha lá.

Arquivo .com do MS-DOS, 56 bytes

Aqui o conteúdo do arquivo em hexadecimal:

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

O código do assembler correspondente é assim:

    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 bytes

Isso deve ser executado em sistemas Linux de 64 bits

construído 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

animação:

salvou 65 bytes - obrigado user254948

R, 85 89 bytes

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

Editar: Corrigida a resposta de forma que Tnão transbordasse, redefinindo o contador se maior que 4.

O único aspecto interessante sobre essa resposta é o uso do R TRUTHYembutido T. É efetivamente um conjunto de variáveis ​​predefinido, o 1/TRUEque significa que não precisamos inicializar o contador, mas podemos começar a incrementar T.

Haskell (GHC), 103 91 bytes

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

Obrigado @nimi por salvar 12 bytes!

C (em sistemas UNIX) 88 bytes

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

Começa com o personagem errado, mas acho que parece melhor. Você pode alterar facilmente a ordem dos caracteres modificando o "\ - / |" corda.

Perl, 71 63 61 bytes

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

Versão anterior:

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

Thanx para @primo por 10 bytes.