Su desafío es hacer una pantalla de carga infinita, que se vea así:

O, para ser más específicos:

• No tomes ninguna entrada.
• Salida Loading..., con un espacio final, pero sin nueva línea final.
• Ciclo infinitamente a través de los caracteres |, /, -y \: cada 0,25 segundos, sobrescribir el último con la siguiente en la secuencia. Puede sobrescribir solo el último carácter, o eliminar y reescribir toda la línea, siempre que Loading...permanezca sin cambios.

Reglas

• El texto de salida debe verse exactamente como se especifica. Las líneas / espacios finales son aceptables.
• Usted debe no espere 0,25 segundos antes de mostrar inicialmente de salida - el primer cuadro se debe imprimir en cuanto el programa se ejecuta.
• Su programa debería poder ejecutarse indefinidamente. Por ejemplo, si usa un contador para marcos, el contador nunca debe causar un error al exceder el máximo en su idioma.
• Aunque el período de espera entre cada "cuadro" debe ser de 0.25 segundos, obviamente esto nunca será exacto: se permite un margen de error del 10% más o menos.
• Puede enviar una función, pero debe imprimirla stdout.
• Puede enviar una respuesta en un entorno que no sea de consola (pero basado en texto), siempre que sea capaz de producir la animación de carga.
• Este es el código de golf , por lo que gana la solución más corta (en bytes). Se aplican las lagunas de código estándar de golf.
• Si es posible, proporcione un gif de su pantalla de carga en acción.

Ejemplo

Aquí está el código C ++ que utilicé para crear el ejemplo (sin 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;
    }
}

¡Que gane el mejor golfista!

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>

Editar: Guardado 3 bytes gracias a @betseg. Guardado 17 bytes gracias a @manatwork. Guardado 1 byte gracias a @Daniel. Guardado 13 bytes gracias a @Ismael Miguel. Guardado 4 bytes gracias a @Fez Vrasta.

Vim, 43 , 41 bytes

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

¡Dos bytes guardados gracias a @Udioica!

¡Aquí hay una animación (ligeramente desactualizada) de que sucede en tiempo real!

Y aquí hay una explicación:

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)

Echa un vistazo a mi respuesta de 132 bytes HTML / CSS también.

Windows Batch 121 114 84 80 79 78 bytes

Solo tirar esto por diversión.

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

No pude asignar pipe ( |) a la matriz, así que tuve que agregarlo manualmente con otra asignación.El retraso se realiza con PING, lo que podría no ser exacto .

Salida:

Editar:

• ¡Gracias a Roman Gräf por guardar 7 bytes!
• ¡Gracias a Neil por guardar 30 bytes! También lo he destrozado un poco más para guardar bytes en las nuevas líneas.
• ¡Gracias a phyrfox por guardar 4 bytes!
• ¡Gracias a YourDeathIsComing por guardar 2 bytes!

Nodo, 72 70 bytes

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

Reemplace \x1Bcon el carácter de escape literal para obtener el recuento de bytes correcto. Llame f()para comenzar la animación. Así es como se ve en el emulador de terminal ConEmu en mi computadora:

Kotlin, 67 66 bytes

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

Bastante autoexplicativo, usando \rpara despejar la línea y aprovechando la impresionante interpolación de cuerdas de Kotlin.

EDITAR: guardado 1 byte gracias a @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu al cambiar while(true)awhile(1>0)

Vim, 35 bytes

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

La versión aburrida. Aquí hay una solución que no cumple que es mejor:

Vim (suspensión de 1 segundo), 27 bytes

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

Usar gsno solo es mucho más corto, sino que no tiene que presionar Enter. Eso significa que la macro encaja en línea, y puedo guardar bytes cambiando a @.. (Dado que nada después de la llamada recursiva puede ejecutarse, puedo escribir lo que quiera).

Pyth, 31 bytes

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

Intérprete aquí .

Explicación

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 vuelta en el Bytecount con el que empecé!

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

El CLI en PowerShell fallará ligeramente en algunas computadoras, por lo que no se ve perfecto, pero es tan bueno como puedo conseguir.

Se movió $ a ++ al bucle for para guardar un byte (no ;)

Luego lo movió al indexador de matriz, para guardar otros 2 bytes, gracias a Roman por señalarlo.

También guardé 1 byte más ( ;) moviendo la parte Borrar pantalla ( cls) al bucle for.

El problema y la solución señalados por TimmyD para el aspecto infinito de la pregunta, solo se requieren +5 bytes, cambiados $a++%4a($a=++$a%4) lo que nunca pasará por encima de 3.

¡Ahorré otro byte dejando el bucle for totalmente en blanco, gracias a 'lo que sea' por señalar que esto es realmente posible en Powershell Versión 4!

Nuevo gif actualizado para la versión (¿final?) De esta respuesta.

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

No funciona en línea, 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

Mejorado con la respuesta 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]

La increíble cantidad de 7 bytes gracias 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);}}}

Muchas gracias a Roman Gräf y raznagul, que me ahorraron 37 bytes. (Especialmente raznagul, quien señaló, que mi solución original era inválida de todos modos. Me perdí algo, pero ahora está solucionado y debería cumplir con los requisitos :)

bastante similar a la respuesta C # existente de Pete Arden pero con algunas mejoras

por ejemplo, "for (;;)" en lugar de "while (true)", char en lugar de string

Hubiera comentado mis sugerencias sobre su respuesta, pero en realidad no tengo suficiente reputación para hacerlo.

Sin golf:

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

Adelante, 7273 bytes

EDITAR :

• Se agregó la versión exclusiva de Gforth, 69 bytes (¡Gracias @ninjalj!)
• Se agregaron espacios en blanco faltantes después de "Cargando ..." (¡Thx @Roman Gräf!), +1 byte
• Actualizado para que coincida con las reglas con mayor precisión (en el mismo recuento de bytes)

Golfed

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

Versión Gforth

La versión exclusiva de GNU Forth se puede reducir a 69 bytes de esta manera:

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

Screencast

Pruébalo en línea!

Python 2, 81 79 78 77 bytes

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

Una solución bastante simple que duerme usando time.

Uso \r(Un retorno de carro) para volver al inicio de la línea y luego imprimo el mensaje sobrescribiendo la línea.

Comienzo i=1para evitar el doble escape de \(Es en '\|/-'lugar de '|/-\\').

En el pasado, solía -~isignificar i + 1evitar los paréntesis. (¡Gracias a @ Flp.Tkc por estos -2 bytes!) (Fue i=(i+1)%4vs.i=-~i%4 )

Ahora, solo estoy dejando que el contador suba para siempre, ya que técnicamente Python intno puede desbordarse. ¡Gracias a @Zachary T por señalarlo y guardar un byte!
Solo se detiene en una máquina porque la máquina se queda sin memoria, pero esto requiere 9.7 generaciones con 4GB de memoria para esa int.

Gracias a @Kade por el byte -1 donde las print a,bimpresiones ay el bespacio se separaron, por lo que no necesito mi propio espacio.

Aquí hay un gif que funciona en Windows:

También lo probé en una máquina virtual Linux. No pude probarlo en una Mac.

MATL , 36 bytes

1 byte eliminado usando la idea de @ flawr de cambiar circularmente la cadena

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

Aquí hay una grabación gif del compilador fuera de línea:

¡O pruébalo en MATL Online!Si no se ejecuta inicialmente, actualice la página y presione "Ejecutar" nuevamente.

Cómo 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

Esto solo funciona en la versión de Windows, ya que de lo contrario la ⎕SMventana no se mostrará a menos que ⎕SRse llame.

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

Explicación:

• {... }1: ejecuta la función comenzando con⍵=1
• Loading... '∘,¨'|/-\': genera las cuatro salidas posibles
• ⊂⊃⍵⌽: Gire la lista para poner el elemento first primero, tome el primer elemento y enciérrelo
• ⎕SM←1 1,⍨: coloca la cadena en la esquina superior izquierda de la ⎕SMventana.
• ⎕DL÷4: espera 1/4 de segundo
• 4|⍵+⌈: redondea el valor resultante (segundos de espera, por lo que siempre es 1), agrégalo a ⍵(incrementándolo) y toma el mod-4 (para evitar que se desborde).
• ∇: vuelva a ejecutar la función con el nuevo ⍵.

C #, 187 bytes

Golfizado:

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

Sin golf:

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

Todavía estoy esperando que se cargue ...

Snap !, 8 bloques

Este fue uno de los primeros algoritmos que descubrí en una Apple] [e

reticular, no competitivo, 40 bytes

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

Olvidé cometer un montón de cosas, incluso w. Oh bien.

Explicación

: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

¡Gracias a muchas personas por los muchos bytes que jugaron!

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<

Debe ejecutarse pasando -t .01 como argumento adicional al intérprete, ese es el +4 en el recuento de bytes.

Lo que esto hace es poner los cuatro caracteres que se imprimirán en la pila, imprimir el superior sin quitarlo y cambiar la pila en una posición. Luego imprime \b(retroceso, carácter x08) y reinicia el bucle.

La sincronización se logra mediante el argumento pasado al intérprete, que obliga a esperar 0.01 segundos antes de ejecutar cada instrucción. Hay 23 instrucciones entre una salida y la siguiente (la mayoría de ellas simplemente mueve el puntero de instrucciones a la siguiente celda), por lo que esto esperará 0.23 segundos más el tiempo necesario para ejecutar las instrucciones, que se ajusta sin problemas en los 0.25s solicitados con 10% de error.

Puede probarlo en línea , pero ese intérprete no reconoce el carácter de retroceso, por lo que la salida será un poco extraña allí.

Archivo .COM de MS-DOS, 56 bytes

Aquí el contenido del archivo en 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

El código del ensamblador correspondiente se ve así:

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

Esto debería ejecutarse en sistemas Linux de 64 bits

construido 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

animación:

ahorró 65 bytes - gracias user254948

R, 85 89 bytes

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

Editar: se corrigió la respuesta de modo que Tno se desborde restableciendo el contador si es mayor que 4.

El único aspecto interesante de esta respuesta es el uso de R's TRUTHYincorporado T. Es efectivamente un conjunto de variables predefinido, lo 1/TRUEque significa que no tenemos que inicializar el contador, pero podemos comenzar a incrementarlo T.

Haskell (GHC), 103 91 bytes

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

¡Gracias @nimi por guardar 12 bytes!

C (en sistemas tipo UNIX) 88 bytes

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

Comienza con el personaje equivocado, pero creo que se ve mejor. Puede cambiar fácilmente el orden de los caracteres modificando "\ - / |" cuerda.

Perl, 71 63 61 bytes

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

Versión previa:

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

Gracias a @primo por 10 bytes.