Faites un faux chargeur comme ceci:

Paramètres :

• Affichez loading(espace) l'un de ces éléments cycliquement -\|/(espace) (compteur de pourcentage de 0 à 100) puis a %.
• Le compteur de pourcentage est censé augmenter de 1 chaque fois que l'affichage change.
• Le temps mis par le compteur pour passer à l'itération suivante est aléatoire. N'importe quel type d'aléatoire fera l'affaire tant que la fonction / méthode est capable de générer tous les entiers aléatoires ayant une probabilité> 0 dans la plage 1<= ms <=750ici msétant le temps en millisecondes.
• Commencez à loading - 0 %.
• Fin à loading - 100 %.
• AUCUNE ENTRÉE n'est requise.
• soumettre un programme ou une fonction complète ou quelque chose de similaire.

Le code que j'ai utilisé:

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

Gagnant

• le code avec le moins d'octets gagne.

MATL , 45 octets

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

Exemple exécuté dans le compilateur hors ligne:

Ou essayez-le sur MATL Online!

Explication

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 octets

Similaire à /codegolf//a/101357/59735

Sauvegardé 3 octets en n'étant pas idiot (laissé le ... au chargement)

-3 grâce à VisualMelon

changé 750 -> 751 pour vous assurer que 750 est inclus.

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

Explication:

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 mis à jour

Python 2, 119 113 112 Octets

J'étais à l'origine allé avec le montant aléatoire étant random()/.75, cependant le point final ne serait pas inclus. Il n'y a pas beaucoup de différence entre cette question et l'autre question pour le temps de chargement infini, sauf pour le caractère aléatoire et le fait qu'il se termine réellement.

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

^{merci à Jonathan Allan pour avoir sauvé 6 octets, et DJMcMayhem pour avoir sauvé un octet!}

Lot, 185 octets

@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%

Le timing est malheureusement assez médiocre, mais Batch n'a rien de mieux à utiliser que ping.

*> <> (Étoile de mer), 86 82 octets

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

Essayez-le ici!

Cela peut peut-être être plus joué au golf, mais je ne vois rien de super évident. Il dort 100 ms, 400 ms ou 700 ms, si ce n'est pas assez aléatoire, faites le moi savoir!

Merci à @TealPelican de m'avoir sauvé 4 octets et de le rendre beaucoup plus aléatoire!

Les plus grands défis que j'ai rencontrés (tout en essayant de le garder petit) étaient le caractère aléatoire et la sortie de "chargement - 100%" à la fin, au lieu de simplement sortir à ma convenance la plus proche: p.

Perl 6 , 67 octets

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

Étendu:

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 octets

Cela semble fonctionner parfaitement bien, même avec cette source sommaire de nombres "aléatoires".

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

Alternative 1 , Javascript + HTML, 16 + 84 octets

Celui-ci utilise un élément déjà existant pour afficher le contenu restant:

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

Loading <a id=a>

Alternative 2 , 95 octets

Si je peux supposer qu'un onglet est ouvert et que vous le collez dans la console:

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

Au lieu d'afficher le HTML, le titre du document va changer.

Merci à @ user2428118 pour avoir économisé 2 octets!

F #, 118 octets

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

Pour exécuter cet extrait, passez-le dans Async.Startou Async.RunSynchronously.

PHP, 90 83 80 78 77 octets

77:

La fermeture ;n'est pas nécessaire.

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

78:

En cherchant une autre solution pour obtenir un 0 au départ sans initialiser la variable, j'ai trouvé ceci:

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

Changé en écho pour gagner quelques octets car je n'ai utilisé printf que pour forcer le formatage en int. En incrémentant le $ i incrémenté avec 0, j'obtiens un entier valide. En utilisant des guillemets simples comme délimiteur de chaîne, la barre oblique inverse n'a pas besoin d'être échappée, ce qui entraîne la libération d'un autre octet

80:

Déplacer l'incrément de $ i de la dernière section for vers l'imprimeur m'a donné encore 3 de plus. (Voir les commentaires ci-dessous)

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

83:

Suppression de l'initialisation d'une variable avec les états de charge.

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

90:

J'ai essayé de supprimer l'init de $ i pour gagner quelques octets, car j'ai dû en ajouter quelques-uns pour activer l'animation du chargeur. printf ajoute 2 par opposition à echo, mais le formatage NULL comme un entier donne 0.

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

Groovy, 113 87 octets

-36 octets grâce à lealand

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

Bash, 162 104 octets

Modification de la réponse Zachary sur une question connexe, avec des améliorations massives par manatwork:

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

Je devais chercher comment faire des nombres aléatoires en bash.

Non golfé / expliqué

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 octets

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

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

Je ne garantis pas que chaque personnage dans ce document est correct, veuillez me corriger s'il y a des erreurs de compilation. J'ai dû taper le tout sur mon téléphone, donc j'ai peut-être accidentellement inclus des erreurs ... ¯_ (ツ) _ / ¯ J'espère que vous me pardonnerez

Testé sur mon PC, fonctionne comme un charme et j'ai même économisé 20 octets grâce à pmbanka :)

C 112 103 octets

9 octets enregistrés grâce à @G. Sliepen. Pas très excitant, juste un golf de votre réponse C ++ en gros. Ce n'est pas non plus une fonction aléatoire très excitante. J'y ai pensé Sleep(c[i%4]), ou Sleep(i)mais ils ne sont pas du tout aléatoires!

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

Non golfé:

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

Mathematica, 133 octets

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

Cela s'exécutera une fois, en supposant que x n'est pas défini. Clear@xva le redémarrer.

55 caractères attachés dans la verbosité: /

R - 94 octets

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

Vraiment sympa sample(750,1) == sample(1:750,1).

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

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

loading <a id=a>

PHP, 66 79 octets

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

Malheureusement, j'ai dû assigner $ i pour qu'il puisse imprimer '0'.
Utilisez comme:

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

Modifications: grâce à Titus confirmant exactement ce qui est autorisé avec Mukul Kumar, nous pouvons économiser 3 octets avec une plage moins restreinte, mais pas les 9 octets avec une plage non restreinte. Merci également d'avoir souligné que j'avais oublié le caractère cycliste et d'avoir fourni une solution simple pour le faire.

Noodel , non compressible 40 octets

Il suffit de revenir à travers d'anciens défis (comme dans les défis qui ont été faits avant Noodel ) et de rivaliser avec Noodel pour trouver où il est faible.

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

Si la sortie finale n'a pas d'importance, vous pouvez économiser 2 octets.

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

Noodel pousse le haut de la pile à l'écran à la fin du programme donc en ajoutant le€Ḃ cela empêche que cela se produise.

Essayez-le :)

Comment ça marche

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 octets

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

Version non golfée:

 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'a pas lu entre les lignes là-bas, merci! :)

MATLAB, 108 octets

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

Octave, 122 120 119 108 octets

J'ai mal lu le défi et créé un chargeur infini qui a redémarré à 0 une fois qu'il a passé 100. Ce qui en fait un chargeur unique:

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

Circulation a, a=a([2:4,1])était l'idée de flawr ici . En outre, enregistré 2 octets en sautant les parenthèses après randmerci à MattWH.

ForceLang, 250 octets

Non compétitif, nécessite des fonctionnalités linguistiques postérieures à la question

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

Je devrais probablement corriger bientôt quelques bugs liés à l'analyse littérale des chaînes.

Raquette 110 octets

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

Non golfé:

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

Essai:

(f)

Sortie:

(Ce fichier gif affiche un affichage plus lent que réel)

107 75 rubis

-32 grâce au manatwork

Ordinaire

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

Golfé

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

Python 3, 149 octets

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

Similaire à Loading ... Forever, mais j'ai dû beaucoup modifier ma réponse à partir de là.

TI-Basic, 80 octets

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

Le caractère aléatoire provient de la For(boucle (E est un jeton scientifique E) et puisque TI-Basic est interprété, il y a aussi automatiquement des frais généraux. Rappelez-vous que dans TI-Basic, les lettres minuscules et certains symboles ASCII moins courants sont deux octets chacun (donc spécifiquement pour ce programme, l o a d i n g sub( \ | %sont les jetons à deux octets

Clojure, 109 octets

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

Boucles sur une liste de la plage de nombres de 0 à 100, zippée avec une liste infinie de "\|/-"répétition pour toujours.

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

Jouable sur http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMOXoybnVSOVJEU00

Java 8, 130 octets

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

Explication:

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

Visual Basic, 371 octets

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

Étendu:

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