Faça um carregador falso assim:

Parâmetros:

• Exiba loading(espaço) um destes ciclicamente -\|/(espaço) (contador de porcentagem de 0 a 100) e depois a %.
• O contador de porcentagem deve aumentar em 1 sempre que a exibição for alterada.
• O tempo gasto pelo contador para pular para a próxima iteração é aleatório. Qualquer tipo aleatório funcionará desde que a função / método seja capaz de gerar todos os números inteiros aleatórios com probabilidade> 0 no intervalo 1<= ms <=750aquims sendo tempo em milissegundos.
• Comece às loading - 0 %.
• Terminar às loading - 100 %.
• Nenhuma entrada é necessária.
• envie um programa ou função completo ou algo semelhante.

O código que eu usei:

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

Vencedora

• o código com menos bytes vence.

MATL , 45 bytes

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

Exemplo de execução no compilador offline:

Ou tente no MATL Online!

Explicação

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

Semelhante ao https://codegolf.stackexchange.com/a/101357/59735

Economizou 3 bytes por não ser um idiota (deixou o ... ao carregar)

-3 graças a VisualMelon

alterado 750 -> 751 para garantir que 750 seja incluído.

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

Explicação:

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 atualizado

Python 2, 119 113 112 Bytes

Originalmente, eu tinha escolhido o valor aleatório random()/.75, mas o ponto final não seria incluído. Não há muita diferença disso para a outra questão para o tempo de carregamento infinito, exceto pela aleatoriedade e pelo fato de que ele realmente termina.

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

^{obrigado a Jonathan Allan, por salvar 6 bytes, e ao DJMcMayhem, por salvar um 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%

Infelizmente, o tempo é bastante ruim, mas o Lote não tem nada melhor para usar do que ping.

*> <> (Estrela do mar), 86 82 bytes

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

Experimente aqui!

Pode ser que você possa jogar mais, mas não vejo nada super óbvio. Ele dorme 100ms, 400ms ou 700ms, se isso não for aleatório o suficiente, avise-me!

Obrigado a @TealPelican por me salvar 4 bytes e torná-lo muito mais aleatório!

Os maiores desafios que encontrei (enquanto ainda tentava mantê-lo pequeno) foram a aleatoriedade e, na verdade, exibindo "loading - 100%" no final, em vez de simplesmente sair da forma mais conveniente: 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

Isso parece funcionar perfeitamente bem, mesmo com essa fonte superficial de números "aleatórios".

(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 usa um elemento já existente para exibir o conteúdo 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

Se eu posso assumir que uma guia está aberta e que você está colando isso no console:

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

Em vez de mostrar o HTML, o título do documento será alterado.

Obrigado a @ user2428118 por salvar 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 executar esse snippet, passe-o para Async.Startou Async.RunSynchronously.

PHP, 90 83 80 78 77 bytes

77:

O fechamento ;não é necessário.

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

78:

Enquanto procurava outra solução alternativa para obter um 0 inicialmente sem inicializar a variável, vim com isso:

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

Alterei de volta ao eco para ganhar alguns bytes, pois apenas usei printf para forçar o formato como int. Ao incrementar o $ i incrementado com 0, recebo um número inteiro válido. Ao usar aspas simples como delimitador de string, a barra invertida não precisa ser escapada, resultando em outro byte liberado

80:

Mover o incremento de $ i da última seção para o prinf me deu mais 3 pontos. (Veja os comentários abaixo)

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

83:

Removida init de uma variável com os loaderstates.

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

90:

Tentei remover o init de $ i para obter alguns bytes, pois precisei adicionar alguns para ativar a animação do carregador. printf adiciona 2 ao invés de eco, mas a formatação de NULL como um número inteiro resulta em 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 thanks to lealand

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

Bash, 162 104 bytes

Modificação da resposta de Zachary em uma pergunta relacionada, com melhorias maciças por manatwork:

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

Eu tive que procurar como fazer números aleatórios no bash.

Ungolfed / Explained

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

Ungolfed:

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

Não garanto que todos os personagens estejam corretos. Corrija-me se houver erros de compilação. Eu tive que digitar tudo no meu telefone, para poder incluir acidentalmente alguns erros ... ¯_ (ツ) _ / ¯ Espero que vocês me perdoem

Testei no meu PC, funciona como um encanto e até salvei 20 bytes graças ao pmbanka :)

C 112 103 bytes

Economizou 9 bytes graças a @G. Sliepen. Não é muito emocionante, apenas um pouco da sua resposta em C ++ basicamente. Também não é uma função aleatória muito emocionante. Eu pensei Sleep(c[i%4]), ou Sleep(i)mas eles não são aleatórios!

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

Ungolfed:

#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:>{}]

Isso será executado uma vez, assumindo que x é indefinido. Clear@xirá reiniciá-lo.

55 caracteres amarrados na verbosidade: /

R - 94 bytes

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

Muito bom isso 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 %";

Infelizmente, tive que atribuir $ i para imprimir '0'.
Use como:

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

Edições: graças a Titus confirmando exatamente o que é permitido com Mukul Kumar, podemos salvar 3 bytes com um intervalo menos restrito, mas nem todos os 9 bytes com um intervalo irrestrito. Obrigado também por apontar que esqueci o personagem de ciclismo e fornecendo uma solução simples para isso.

Noodel , 40 bytes não- concorrentes

Voltando aos velhos desafios (como nos anteriores ao Noodel ) e competindo com o Noodel para descobrir onde ele é fraco.

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

Se a saída final não importa, você pode salvar 2 bytes.

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

Noodel empurra a parte superior da pilha para a tela no final do programa, adicionando a opção €Ḃpara impedir que isso aconteça.

Tente:)

Como 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));}

Versão não destruída:

 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 Não leu nas entrelinhas, obrigado! :)

MATLAB, 108 bytes

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

Oitava, 122 120 119 108 bytes

Eu interpretei mal o desafio e criei um carregador infinito que reiniciou em 0 quando passou de 100. Transformando-o em um carregador único:

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

Circulante a, a=a([2:4,1])foi idéia de flawr aqui . Além disso, economizou 2 bytes ignorando os parênteses depois de randagradecer a MattWH.

ForceLang, 250 bytes

Não-competitivo, requer recursos de idioma que pós-datam a pergunta

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

Provavelmente eu deveria corrigir alguns erros relacionados à análise literal de strings em breve.

Raquete 110 bytes

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

Ungolfed:

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

Teste:

(f)

Saída:

(Este arquivo gif está mostrando uma exibição mais lenta que a real)

107 75 Rubi

-32 graças 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
}

Golfe

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))

Semelhante a Carregando ... Para sempre, mas tive que editar muito a minha resposta a partir daí.

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

A aleatoriedade vem do For(loop (E é um token E científico) e, como a TI-Basic é interpretada, também há automaticamente alguma sobrecarga. Lembre-se de que, no TI-Basic, letras minúsculas e alguns símbolos ASCII menos comuns têm dois bytes cada (portanto, especificamente para este programa, l o a d i n g sub( \ | %são os tokens de dois bytes

Clojure, 109 bytes

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

Loops em uma lista do intervalo de números de 0 a 100, compactados com uma lista infinita de "\|/-"repetições para sempre.

; (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

Pode ser reproduzido em 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+++" %");}

Explicação:

()->{                           // 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

Gif de saída:

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