Haga un cargador falso así:

Parámetros:

• Muestre loading(espacio) uno de estos cíclicamente -\|/(espacio) (contador de porcentaje de 0-100) y luego a %.
• Se supone que el contador porcentual se incrementa en 1 cada vez que cambia la pantalla.
• El tiempo que tarda el contador en saltar a la siguiente iteración es aleatorio. Cualquier tipo de aleatoriedad funcionará siempre que la función / método sea capaz de generar todos los enteros aleatorios que tengan una probabilidad> 0 en el rango 1<= ms <=750, mses decir, el tiempo en milisegundos.
• Comience a loading - 0 %.
• Poner fin al loading - 100 %.
• NO se requiere ENTRADA.
• enviar un programa completo o función o lo que sea similar.

El código que usé:

C ++

#include<stdio.h>
#include<time.h>
#include<windows.h>

int main()
{
    srand(time(NULL));
    char a[15],b[]="-\\|/";
    int i=0,j=0,ms;
    while(j<101)
    {
        (i<3)?i++:i=0;
        wsprintf(a,"loading %c %d ",b[i],j++);
        printf(a);puts("%");
            //This part is to make the output look cool
        switch(rand()%9)
        {
            case 0:ms=1;break;
            case 1:ms=2;break;
            case 2:ms=5;break;
            case 3:ms=10;break;
            case 4:ms=15;break;
            case 5:ms=20;break;
            case 6:ms=25;break;
            case 7:ms=50;break;
            case 8:ms=500;
        }
        Sleep(ms);  //Otherwise this is supposed to be random
        if(j<101)   //like this Sleep(rand()%750+1);
        system("cls");
    }
}

Ganador

• el código con menos bytes gana.

MATL , 45 bytes

101:"'loading'O'-\|/'@)O@qVO37&hD750Yr100/&Xx

Ejemplo ejecutado en el compilador fuera de línea:

¡O pruébalo en MATL Online!

Explicación

101:          % Push array [1 2 ... 101]
"             % For each
  'loading'   %   Push this string
  O           %   Push 0. When converted to char it will be displayed as a space
  '-\|/'      %   Push this sring
  @)          %   Modular index into this string with iteration index
  O           %   Push 0
  @q          %   Iteration index minus 1
  V           %   Convert to string
  O           %   Push 0
  37          %   Push 37, which is ASCII for '%'
  &h          %   Concatenate horizontally into a string, Numbers are converted to char
  D           %   Display
  750Yr       %   Random integer with uniform distribution on [1 2 ... 750]
  100/        %   Divide by 100
  &Xx         %   Pause that many tenths of a second and clear screen
              % End (implicit)

Powershell, 71 68 65 Bytes

Similar a https://codegolf.stackexchange.com/a/101357/59735

Ahorró 3 bytes al no ser un idiota (dejó el ... al cargar)

-3 gracias a VisualMelon

cambió 750 -> 751 para asegurarse de que se incluye 750.

0..100|%{cls;"loading $("|/-\"[$_%4]) $_ %";sleep -m(random 751)}

Explicación:

0..100|%{                                  #For range 0-100...
    cls                                    #Clear Display
    "loading $("|/-\"[$_%4]) $_ %"    #Display the current string
    sleep -m(random 750)                  #Sleep random ms up to 750
}

GIF actualizado

Python 2, 119 113 112 Bytes

Originalmente había ido con la cantidad aleatoria random()/.75, sin embargo, el punto final no se incluiría. No hay mucha diferencia entre esta y la otra pregunta para el tiempo de carga infinito, excepto por la aleatoriedad y el hecho de que realmente termina.

import time,random as r
for i in range(101):print'\rLoading','-\|/'[i%4],i,'%',;time.sleep(r.randint(1,750)/1e3)

^{¡Gracias a Jonathan Allan por guardar 6 bytes y a DJMcMayhem por guardar un byte!}

Lote, 185 bytes

@set s=-\!/
@for /l %%i in (0,1,100)do @call:l %%i
@exit/b
:l
@cls
@set c=%s:~0,1%
@set s=%s:~1%%c%
@echo Loading %c:!=^|% %1 %%
@set/aw=%random%%%751
@ping>nul 1.1 -n 1 -w %w%

Desafortunadamente, el tiempo es bastante pobre, pero Batch no tiene nada mejor que usar ping.

*> <> (Estrella de mar), 86 82 bytes

| v1*aoooooooo"loading K"&0"-\|/"
!0x1! +
%$<.0+af{od;?)*aa&:&Soono$&+1:&"  %"{o:}

Pruébalo aquí!

Es posible que se pueda jugar más al golf, pero no veo nada súper obvio. Tiene una capacidad de 100 ms, 400 ms o 700 ms, si esto no es lo suficientemente aleatorio, ¡hágamelo saber!

¡Gracias a @TealPelican por guardarme 4 bytes y hacerlo mucho más aleatorio!

Los mayores desafíos que encontré (mientras intentaba mantenerlo pequeño) fueron la aleatoriedad, y en realidad arrojar "carga - 100%" al final, en lugar de simplemente salir a mi conveniencia más cercana: p.

Perl 6 , 67 bytes

for |<- \ | />xx* Z 0..100 {print "\rloading $_ %";sleep .750.rand}

Expandido:

for

  # produce a list of all the pairs of values

  |<- \ | /> xx *   # a flat infinite list of "clock faces"
  Z                 # zipped with
  0 .. 100          # all the numbers from 0 to 100 inclusive

  # &zip / &infix:<Z> stop on the shortest list

{

  # ｢$_｣ will look something like ｢("/", 39)｣
  # when it is coerced to a Str, all of its elements
  # will be coerced to Str, and joined with spaces

  print "\rloading $_ %";

  sleep .750.rand

}

Javascript (ES6), 128 118 116 115 112 110 109 bytes

Esto parece funcionar perfectamente bien, incluso con esta fuente incompleta de números "aleatorios".

(X=_=>setTimeout(i>99||X,1+new Date%750,document.body.innerHTML=`<pre>Loading ${'-\\|/'[i%4]} ${i++}%`))(i=0)

Alternativa 1 , Javascript + HTML, 16 + 84 bytes

Este utiliza un elemento ya existente para mostrar el contenido restante:

(X=_=>setTimeout(i>99||X,1+new Date%750,a.innerHTML=`${'-\\|/'[i%4]} ${i++}%`))(i=0)

Loading <a id=a>

Alternativa 2 , 95 bytes

Si puedo suponer que se abre una pestaña y que estás pegando esto en la consola:

(X=_=>setTimeout(i>99||X,1+new Date%750,document.title=`Loading ${'-\\|/'[i%4]} ${i++}%`))(i=0)

En lugar de mostrar el HTML, el título del documento cambiará.

¡Gracias a @ user2428118 por guardar 2 bytes!

F #, 118 bytes

async{let r=System.Random()
for i in 0..100 do printf"\rLoading %O %d %%""|/-\\".[i%4]i;do!Async.Sleep(r.Next(1,750))}

Para ejecutar este fragmento, páselo a Async.Starto Async.RunSynchronously.

PHP, 90 83 80 78 77 Bytes

77:

El cierre ;no es necesario.

for(;$i<101;usleep(rand(1,75e4)))echo"\rloading ",'-\|/'[$i%4],' ',$i+++0,'%'

78:

Mientras buscaba otra solución para obtener un 0 inicialmente sin inicializar la variable, se me ocurrió esto:

for(;$i<101;usleep(rand(1,75e4)))echo"\rloading ",'-\|/'[$i%4],' ',$i+++0,'%';

Cambié de nuevo a echo para ganar unos pocos bytes, ya que solo usé printf para forzar el formato como int. Al incrementar el $ i incrementado con 0 obtengo un entero válido. Al usar comillas simples como delimitador de cadena, no es necesario escapar de la barra diagonal inversa, lo que da como resultado otro byte liberado

80:

Mover el incremento de $ i de la última sección for al prinf me dio otros 3 de descuento. (Ver comentarios a continuación)

for(;$i<101;usleep(rand(1,75e4)))printf("\rloading %s %d%%","-\\|/"[$i%4],$i++);

83:

Se eliminó el inicio de una variable con los estados de carga.

for(;$i<101;usleep(rand(1,75e4)),$i++)printf("\rloading %s %d%%","-\\|/"[$i%4],$i);

90:

Intenté eliminar el init de $ i para ganar algunos bytes, ya que tuve que agregar bastantes para habilitar la animación del cargador. printf agrega 2 en lugar de echo, pero formatear NULL como un entero da como resultado 0.

for($l='-\|/';$i<101;usleep(rand(0,750)*1e3),$i++)printf("\rloading %s %d%%",$l[$i%4],$i);

Groovy, 113 87 bytes

-36 bytes gracias a lealand

{p=-1;101.times{print"\rLoading ${"-\\|/"[p++%4]} $p%";sleep Math.random()*750as int}}​

Bash, 162104 bytes

Modificación de la respuesta de Zachary en una pregunta relacionada, con mejoras masivas por manatwork:

s='-\|/'
for x in {0..100};{
printf "\rloading ${s:x%4:1} $x %%"
sleep `printf .%03d $[RANDOM%750+1]`
}

Tuve que buscar cómo hacer números aleatorios en bash.

Sin golf / Explicado

s='-\|/'
for x in {0..100}
{
    # \r returns the carriage to the beginning of the current line.
    # ${s:x%4:1} grabs a substring from s, at index x%4, with a length of 1.
    printf "\rloading ${s:x%4:1} $x %%"

    # "$RANDOM is an internal bash function that returns
    #   a pseudorandom integer in the range 0 - 32767."
    # .%03d is a dot followed by a base-ten number formatted to 3 places,
    #   padded with zeros if needed.
    # sleep accepts a floating point number to represent milliseconds.
    sleep `printf .%03d $[RANDOM%750+1]`
}

C #, 170 149 135 Bytes

()=>{for(int i=0;i++<=100;System.Threading.Thread.Sleep(new Random().Next(1,750)))Console.Write($"\rloading {@"-\|/"[i % 4]} {i} %");};

Sin golf:

static void l()
{
    for (int i = 0; i <= 100; System.Threading.Thread.Sleep(new Random().Next(1, 750)))
        Console.Write($"\rloading {@"-\|/"[i % 4]} {i} %");   
}

No garantizaré que todos los caracteres de esta sean correctos, corrígeme si hay errores de compilación. Tuve que escribir todo en mi teléfono, así que podría haber incluido accidentalmente algunos errores ... ¯_ (ツ) _ / ¯ Espero que me perdonen.

Lo probé en mi PC, funciona de maravilla e incluso guardé 20 bytes enteros gracias a pmbanka :)

C 112 103 bytes

Guardado 9 bytes gracias a @G. Sliepen No es muy emocionante, solo un golf de su respuesta C ++ básicamente. Tampoco es una función aleatoria muy emocionante. Pensé en eso Sleep(c[i%4]), ¡ Sleep(i)pero no son al azar en absoluto!

#import<windows.h>
i;f(){for(;i<101;printf("\rloading %c %d %%","-\\|/"[i%4],i++),Sleep(rand()%750+1));}

Sin golf:

#include <windows.h>
int i;
void f() {
  for(;i<101;) {
    printf("\rloading %c %d %%", "-\\|/"[i%4], i++);
    Sleep(rand()%750+1);
  }
}

Mathematica, 133 Bytes

Dynamic[If[x<100,x++,,x=0];Row@{"Loading ",StringPart["-\|/",1+x~Mod~4]," ",x,"%"},
    UpdateInterval:>RandomReal@.75,TrackedSymbols:>{}]

Esto se ejecutará una vez, suponiendo que x esté indefinido. Clear@xlo reiniciará

55 caracteres atados en verbosidad: /

R - 94 bytes

for(i in 0:100){cat('\rLoading',c('-','\\','|','/')[i%%4+1],i,'%');Sys.sleep(sample(750,1)/1e3)}

Muy bueno eso sample(750,1) == sample(1:750,1).

HTML + JS (ES6), 16 + 87 = 103 bytes

(f=_=>a.innerHTML='\\|/-'[i++%4]+` ${i<100&&setTimeout(f,Math.random()*750),i} %`)(i=0)

loading <a id=a>

PHP, 66 79 bytes

for($i=-1;++$i<101;usleep(rand(1,75e4)))echo"\rloading ","-\\|/"[$i%4]," $i %";

Desafortunadamente, tuve que asignar $ i para que imprimiera '0'.
Usar como:

php -r 'for($i=-1;++$i<101;usleep(rand(1,75e4)))echo"\rloading ","-\\|/"[$i%4]," $i %";'

Ediciones: gracias a Titus que confirma exactamente lo que está permitido con Mukul Kumar, podemos guardar 3 bytes con un rango menos restringido, pero no todos los 9 bytes con un rango sin restricciones. Gracias también por señalar que olvidé el personaje de ciclismo y por proporcionar una solución simple para hacerlo.

Noodel , 40 bytes no competitivos

Simplemente volviendo a los viejos desafíos (como en los desafíos que se hicieron antes de Noodel ) y compitiendo con Noodel para encontrar dónde es débil.

Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ€Ḃ

Si la salida final no importa, puede guardar 2 bytes.

Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ

Noodel empuja la parte superior de la pila a la pantalla al final del programa, así que al agregar el€Ḃ esto evita que eso suceda.

Intentalo:)

Cómo funciona

Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ€Ḃ # Main Noodel script.

Loading¤”ḋḟƇḣ⁺s¤ṡ⁺                       # Creates the array ["Loading¤-¤", "Loading¤\¤", "Loading¤|¤", "Loading¤/¤"]
Loading¤                                 # Pushes the string "Loading¤"
        ”Ƈḟḋḣ                            # Pushes the array ["-", "\", "|", "/"]
             ⁺s                          # Concats "Loading¤" to each element in the array by prepending.
               ¤                         # Pushes a "¤" onto the stack.
                ṡ                        # Pushes
                 ⁺

                  Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ   # Main loop that creates the animation.
                  Ḷ101                   # Loop the following code 101 times.
                      ạ                  # Pushes on a copy of the next animation element from the array.
                       ¤%                # Pushes the string "¤%"
                         ɱ               # Pushes on the current count of the number of times that have looped (zero based).
                          Ṡ              # Swaps the two items at the bottom of the stack.
                           Ė             # Pushes the item at the bottom of the stack to the top (which will be the string selected from the array).
                            ²⁺           # Concat twice appending the loop count then the string "¤%" to the string selected from the array.
                              Ç          # Pops the string off of the stack, clears the screen, then prints the string.
                               ṛ749      # Randomly generate an integer from 0 to 749.
                                   ⁺1    # Increment the random number producing a random number from 1 - 750.
                                     ḍ   # Pop off the stack and delay for that number of milliseconds.

                                      €Ḃ # Ends the loop and prevents anything else being displayed.
                                      €  # Ends the loop (new line could be used as well)
                                       Ḃ # Destroys the current stack therein, nothing gets pushed to the screen at the end of the program.

<div id="noodel" code="Loading¤”ḋḟƇḣ⁺s¤ṡ⁺Ḷ101ạ¤%ɱṠĖ²⁺Çṛ749⁺1ḍ€Ḃ" input="" cols="14" rows="2"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

C 126 121 bytes

f(){i=0;char c[]="/-\\|";for(;i<101;i++){printf("\rloading %c %d %% ",c[i%4],i);fflush(stdout);usleep(1000*(rand()%75));}

Versión sin golf:

 void f()
 {
  int i=0;
  char c[]="/-\\|";
  for(;i<101;i++)
  {
    printf("\rloading %c %d %% ",c[i%4], i);
    fflush(stdout);
    usleep(1000*(rand()%75));  
  }
 } 

@Carcigenicate @ Mukul Kumar No leí entre líneas allí, ¡Gracias! :)

MATLAB, 108 bytes

function k;for i=0:100;a='-\|/';pause(rand*.749+.001);clc;['loading ' a(mod(i,3)+1) ' ' num2str(i) ' %']
end

Octava, 122 120 119 108 bytes

Leí mal el desafío y creé un cargador infinito que se reinició en 0 una vez que pasó de 100. Lo convertí en un cargador único:

a='\|/-';for i=0:100;clc;disp(['Loading ',a(1),' ',num2str(i),' %']);a=a([2:4,1]);pause(0.749*rand+.001);end

Circulando a, a=a([2:4,1])fue idea de flawr aquí . Además, ahorré 2 bytes omitiendo los paréntesis después de randgracias a MattWH.

ForceLang, 250 bytes

Sin competencia, requiere características de idioma que sean posteriores a la pregunta

def D def
D w io.write
D l e+"loading"+s
D z string.char 8
D s string.char 32
D d datetime.wait 750.mult random.rand()
D e z.repeat 24
D n set i 1+i
D k s+n+s+"%"
set i -1
label 1
w l+"-"+k
if i=100
exit()
d
w l+"\"+k
d
w l+"|"+k
d
w l+"/"+k
d
goto 1

Probablemente debería corregir algunos errores relacionados con el análisis literal de cadenas pronto.

Raqueta 110 bytes

(for((i 101))(printf"Loading ~a ~a % ~n"(list-ref'("-" "\\" "|" "/")(modulo i 4))i)(sleep(/(random 750)1000)))

Sin golf:

(define(f)
  (for ((i 101))
    (printf "Loading ~a ~a % ~n" (list-ref '("-" "\\" "|" "/") (modulo i 4)) i)
    (sleep (/(random 750)1000))))

Pruebas:

(f)

Salida:

(Este archivo gif muestra una visualización más lenta que la real)

107 75 Ruby

-32 gracias a manatwork

Normal

i=0
(0..100).each{|c|
system'clear'
puts"loading #{'\|/-'[i=-~i%4]} #{c} %"
sleep rand*(0.750-0.01)+0.01
}

Golfed

101.times{|c|$><<"\rloading #{'-\|/'[c%4]} #{c} %";sleep rand*0.749+0.001}

Python 3, 149 bytes

import time,random;f=0;n=0
while n<=100:
 print("Loading...","|/-\\"[f],n,"%",end="\r");f+=1
 if f>=3:f=0
 n+=1
 time.sleep(random.uniform(.25,.75))

Similar a Cargando ... para siempre, pero tuve que editar mi respuesta desde allí mucho.

TI-Basic, 80 bytes

For(I,0,100
For(A,0,randE2
End
Text(0,0,"loading "+sub("-\|/",1+fPart(I/4),1)+" ",I," %
End

La aleatoriedad proviene del For(bucle (E es el token E científico) y, dado que se interpreta TI-Basic, también hay automáticamente algo de sobrecarga. Recuerde que en TI-Basic, las letras minúsculas y algunos símbolos ASCII menos comunes son dos bytes cada uno (por lo que específicamente para este programa, l o a d i n g sub( \ | %son los tokens de dos bytes

Clojure, 109 bytes

(doseq[[c i](map vector(cycle"\\|/-")(range 101))](print"\rloading"c i\%)(flush)(Thread/sleep(rand-int 751)))

Recorre una lista del rango de números del 0 al 100, comprimida con una lista infinita de "\|/-"repeticiones para siempre.

; (map vector...) is how you zip in Clojure
;  All arguments after the first to map are lists. The function is expected to
;  take as many arguments as there are lists. vector is var-arg.
(doseq [[c i] (map vector (cycle "\\|/-") (range 101))]
  ; \r to erase the old line
  (println "\rloading" c i \%)
  (Thread/sleep (rand-int 751)))

tcl, 116

set i 0;time {lmap c {- \\ | /} {puts -nonewline stderr "\rloading $c $i%";after [expr int(187*rand())]};incr i} 100

Se puede reproducir en http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMOXoybnVSOVJEU00

Java 8, 130 bytes

()->{for(int n=0;n<101;Thread.sleep((long)(1+Math.random()*750)))System.out.print("\rloading "+"-\\|/".charAt(n%4)+" "+n+++" %");}

Explicación:

()->{                           // Method without parameter nor return-type
  for(int n=0;n<101;            //  Loop from 0 to 100
      Thread.sleep((long)(1+Math.random()*750)))
                                //   And sleep randomly 1-750 ms 
    System.out.print(           //   Print:
      "\r                       //    Reset to the start of the line
      loading "                 //    Literal "loading "
      +"-\\|/".charAt(n%4)+" "  //    + the spinner char & a space
      +n++                      //    + the number (and increase it by 1)
      +" %");                   //    + a space & '%'
                                //  End of loop (implicit / single-line body)
}                               // End of method

Salida gif:

Visual Basic, 371 bytes

module m
sub main()
Dim s as Object
for i as Integer=0 to 100
Select Case new System.Random().next(0,9)
Case 0
s=1
Case 1
s=2
Case 2
s=5
Case 3
s=10
Case 4
s=15
Case 5
s=20
Case 6
s=25
Case 7
s=50
Case 8
s=500
End Select
Console.SetCursorPosition(0,0)
console.write("loading "+"-\|/"(i mod 4)+" "+i.tostring+" %")
system.threading.thread.sleep(s)
next
end sub
end module

Expandido:

module m
    sub main()
        Dim s as Object
        for i as Integer=0 to 100
            Select Case new System.Random().next(0,9)
                Case 0
                s=1
                Case 1
                s=2
                Case 2
                s=5
                Case 3
                s=10
                Case 4
                s=15
                Case 5
                s=20
                Case 6
                s=25
                Case 7
                s=50
                Case 8
                s=500
            End Select
            Console.SetCursorPosition(0,0)
            console.write("loading " + "-\|/"(i mod 4) + " " + i.tostring + " %")
            system.threading.thread.sleep(s)
        next
    end sub
end module