Mache einen Fake Loader wie folgt:

Parameter:

• Zeigen Sie loadingeines dieser Symbole zyklisch an -\|/(Leerzeichen) (Prozentzähler von 0-100) und dann a %.
• Der Prozentzähler soll sich bei jeder Änderung der Anzeige um 1 erhöhen.
• Die Zeit, die der Zähler benötigt, um zur nächsten Iteration zu springen, ist zufällig. Jede Art von Zufall ist möglich, solange die Funktion / Methode in der Lage ist, alle zufälligen Ganzzahlen mit einer Wahrscheinlichkeit> 0 im Bereich zu generieren. 1<= ms <=750Hierbei handelt mses sich um die Zeit in Millisekunden.
• Beginnen Sie bei loading - 0 %.
• Ende um loading - 100 %.
• KEIN EINGANG ist erforderlich.
• Reichen Sie ein vollständiges Programm oder eine Funktion oder etwas Ähnliches ein.

Der Code, den ich verwendet habe:

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

Gewinner

• der Code mit den wenigsten Bytes gewinnt.

MATL , 45 Bytes

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

Beispiellauf im Offline-Compiler:

Oder probieren Sie es bei MATL Online!

Erläuterung

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

Ähnlich wie https://codegolf.stackexchange.com/a/101357/59735

3 Bytes gespart, indem du kein Idiot bist (... beim Laden verlassen)

-3 dank VisualMelon

750 -> 751 geändert, um sicherzustellen, dass 750 enthalten ist.

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

Erläuterung:

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
}

Aktualisiertes GIF

Python 2, 119 113 112 Bytes

Ich war ursprünglich mit dem Zufallsbetrag gegangen random()/.75, aber der Endpunkt würde nicht enthalten sein. Es gibt keinen großen Unterschied zwischen dieser und der anderen Frage für die unendliche Ladezeit, abgesehen von der Zufälligkeit und der Tatsache, dass sie tatsächlich endet.

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

^{Danke an Jonathan Allan für das Speichern von 6 Bytes und DJMcMayhem für das Speichern eines Bytes!}

Batch, 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%

Das Timing ist leider ziemlich schlecht, aber Batch hat nichts Besseres zu gebrauchen als ping.

*> <> (Seestern), 86 82 Bytes

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

Probieren Sie es hier aus!

Das kann man vielleicht mehr Golf spielen, aber ich sehe nichts sehr offensichtliches. Es schläft 100 ms, 400 ms oder 700 ms, wenn dies nicht zufällig genug ist, lassen Sie es mich wissen!

Vielen Dank an @TealPelican, dass du mir 4 Bytes gespart und es viel zufälliger gemacht hast!

Die größten Herausforderungen, die ich gefunden habe (während ich immer noch versucht habe, es klein zu halten), waren Zufälligkeiten und die Ausgabe von "Laden - 100%" am Ende, anstatt nur zu beenden, wenn es mir am besten gefällt: p.

Perl 6 , 67 Bytes

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

Erweitert:

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

Dies scheint auch mit dieser skizzenhaften Quelle von "Zufallszahlen" einwandfrei zu funktionieren.

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

Dieser verwendet ein bereits vorhandenes Element, um den verbleibenden Inhalt anzuzeigen:

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

Loading <a id=a>

Alternative 2 , 95 Bytes

Wenn ich davon ausgehen kann, dass eine Registerkarte geöffnet ist und Sie diese in die Konsole einfügen:

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

Anstatt den HTML-Code anzuzeigen, ändert sich der Titel des Dokuments.

Vielen Dank an @ user2428118 für das Speichern von 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))}

Um dieses Snippet auszuführen, übergeben Sie es an Async.Startoder Async.RunSynchronously.

PHP, 90 83 80 78 77 Bytes

77

Das Schließen ;ist nicht erforderlich.

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

78

Während ich nach einer anderen Problemumgehung suchte, um zunächst eine 0 zu erhalten, ohne die Variable zu initialisieren, kam ich zu folgendem Ergebnis:

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

Zurück zu Echo geändert, um ein paar Bytes zu gewinnen, da ich nur printf verwendet habe, um das Formatieren als int zu erzwingen. Durch Inkrementieren des inkrementierten $ i mit 0 erhalte ich eine gültige Ganzzahl. Durch die Verwendung von einfachen Anführungszeichen als Zeichenfolgentrennzeichen muss der Backslash nicht maskiert werden, wodurch ein weiteres Byte freigegeben wird

80

Das Verschieben des Inkrements von $ i vom letzten For-Abschnitt zum Prinf brachte mir weitere 3 Punkte. (Siehe Kommentare unten)

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

83

Init einer Variablen mit den Ladezuständen entfernt.

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

90

Ich habe versucht, das Init von $ i zu entfernen, um einige Bytes zu erhalten, da ich einige hinzufügen musste, um die Loader-Animation zu aktivieren. printf addiert 2 im Gegensatz zu echo, aber das Formatieren von NULL als Ganzzahl ergibt 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 dank lealand

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

Bash, 162 104 Bytes

Änderung von Zacharys Antwort auf eine verwandte Frage mit massiven Verbesserungen durch Handarbeit:

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

Ich musste nachsehen, wie man Zufallszahlen in Bash macht.

Ungolfed / Erklärt

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

Ich kann nicht garantieren, dass alle Zeichen in diesem Artikel richtig sind. Bitte korrigieren Sie mich, falls Kompilierungsfehler auftreten. Ich musste das Ganze auf meinem Handy tippen, damit ich möglicherweise versehentlich einige Fehler eingefügt habe ... ¯_ (ツ) _ / ¯ Ich hoffe, ihr verzeiht mir das

Getestet auf meinem PC, funktioniert wie ein Zauber und ich habe dank pmbanka sogar ganze 20 Bytes gespart :)

C 112 103 Bytes

9 Bytes dank @G gespart. Sliepen. Nicht sehr aufregend, nur ein Golf Ihrer C ++ Antwort im Grunde. Auch keine sehr aufregende Zufallsfunktion. Ich habe darüber nachgedacht Sleep(c[i%4]), Sleep(i)aber sie sind überhaupt nicht zufällig!

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

Dies wird einmal ausgeführt, vorausgesetzt, x ist undefiniert. Clear@xwird es neu starten.

55 Zeichen in Ausführlichkeit gebunden: /

R - 94 Bytes

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

Wirklich schön das sample(750,1) == sample(1:750,1).

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

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

Leider musste ich $ i zuweisen, damit es '0' druckt.
Verwenden Sie wie:

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

Änderungen: Dank Titus, der genau bestätigt, was mit Mukul Kumar erlaubt ist, können wir 3 Bytes mit einem weniger eingeschränkten Bereich speichern, aber nicht alle 9 Bytes mit einem uneingeschränkten Bereich. Vielen Dank auch für den Hinweis, dass ich den Radsportcharakter vergessen und eine einfache Lösung dafür gefunden habe.

Noodel , nicht konkurrierende 40 Bytes

Ich gehe einfach durch alte Herausforderungen (wie bei Herausforderungen, die vor Noodel erstellt wurden ) und konkurriere mit Noodel, um herauszufinden, wo es schwach ist.

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

Wenn die endgültige Ausgabe keine Rolle spielt, können 2 Bytes gespart werden.

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

Noodel schiebt die Oberseite des Stapels am Ende des Programms auf den Bildschirm, damit dies durch Hinzufügen €Ḃvon verhindert wird.

Versuch es:)

Wie es funktioniert

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

Ungolfed-Version:

 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 Hab da nicht zwischen den Zeilen gelesen, Danke! :)

MATLAB, 108 Bytes

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

Oktave, 122 120 119 108 Bytes

Ich habe die Herausforderung falsch verstanden und einen unendlichen Loader erstellt, der bei 0 neu gestartet wurde, sobald er 100 überschritten hat.

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

Im Umlauf a, a=a([2:4,1])war Flawrs Idee hier . Außerdem konnten randdank MattWH 2 Bytes eingespart werden, indem die Klammern übersprungen wurden.

ForceLang, 250 Byte

Nicht konkurrierend, erfordert Sprachfunktionen, die die Frage nachdatieren

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

Ich sollte wahrscheinlich bald einige Fehler im Zusammenhang mit dem Parsing von String-Literalen beheben.

Schläger 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))))

Testen:

(f)

Ausgabe:

(Diese GIF-Datei zeigt eine langsamere Anzeige als die tatsächliche)

107 75 Ruby

-32 dank manatwork

Normal

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

Golf gespielt

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

Ähnlich wie beim Laden ... Für immer, aber ich musste meine Antwort von dort aus sehr viel bearbeiten.

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

Die Zufälligkeit kommt von der For(Schleife (E ist wissenschaftliches E-Token) und da TI-Basic interpretiert wird, entsteht automatisch ein gewisser Overhead. Denken Sie daran, dass in TI-Basic Kleinbuchstaben und einige weniger gebräuchliche ASCII-Symbole jeweils zwei Bytes umfassen (speziell für dieses Programm l o a d i n g sub( \ | %sind dies die Zwei-Byte-Token)

Clojure, 109 Bytes

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

Durchläuft eine Liste mit Zahlenbereichen von 0 bis 100 und enthält eine unendliche Liste von "\|/-"Wiederholungen für immer.

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

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

Erläuterung:

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

Ausgangsgif:

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

Erweitert:

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