Stwórz fałszywy moduł ładujący w następujący sposób:

Parametry:

• Wyświetl loading(spację) jeden z nich cyklicznie -\|/(spacja) (licznik procentowy od 0-100), a następnie a %.
• Licznik procentowy powinien zwiększać się o 1 przy każdej zmianie wyświetlacza.
• Czas potrzebny licznikowi na przejście do następnej iteracji jest losowy. Każdy rodzaj losu będzie działał, o ile funkcja / metoda jest w stanie wygenerować wszystkie losowe liczby całkowite o prawdopodobieństwie> 0 w zakresie 1<= ms <=750, msczyli czas w milisekundach.
• Zacznij od loading - 0 %.
• Koniec o loading - 100 %.
• NIE jest wymagane WEJŚCIE.
• prześlij pełny program lub funkcję lub coś podobnego.

Kod, którego użyłem:

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

Zwycięzca

• kod z najmniej bajtami wygrywa.

MATL , 45 bajtów

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

Przykład uruchomiony w kompilatorze offline:

Lub spróbuj w MATL Online!

Wyjaśnienie

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 bajtów

Podobne do https://codegolf.stackexchange.com/a/101357/59735

Zapisano 3 bajty, nie będąc idiotą (opuściłem ... podczas ładowania)

-3 dzięki VisualMelon

zmieniono 750 -> 751, aby upewnić się, że 750 jest uwzględnione.

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

Wyjaśnienie:

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
}

Zaktualizowano gif

Python 2, 119 113 112 bajtów

Pierwotnie wybrałem losową kwotę random()/.75, jednak punkt końcowy nie zostałby uwzględniony. Nie ma dużej różnicy od tego do drugiego pytania dotyczącego nieskończonego czasu ładowania, z wyjątkiem losowości i faktu, że faktycznie się kończy.

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

^{podziękowania dla Jonathana Allana za uratowanie 6 bajtów i DJMcMayhem za uratowanie bajtu!}

Partia, 185 bajtów

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

Czas jest niestety dość słaby, ale Batch nie ma nic lepszego do użycia niż ping.

*> <> (Rozgwiazda), 86 82 bajtów

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

Wypróbuj tutaj!

To może być więcej golfa, ale nie widzę nic super oczywistego. Śpi 100 ms, 400 ms lub 700 ms, jeśli nie jest to wystarczająco losowe, daj mi znać!

Dzięki @TealPelican za uratowanie mnie 4 bajtów i uczynienie go bardziej losowym!

Największymi wyzwaniami, które znalazłem (wciąż starając się, aby były małe) były losowość i faktycznie generowanie „ładowania - 100%” na końcu, zamiast tylko wyjścia z mojej najbliższej wygody: str.

Perl 6 , 67 bajtów

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

Rozszerzony:

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 bajtów

Wydaje się, że działa to doskonale, nawet w przypadku tego szkicowego źródła „losowych” liczb.

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

Alternatywnie 1 , JavaScript + HTML, 16 + 84 bajtów

Ten wykorzystuje już istniejący element do wyświetlenia pozostałej zawartości:

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

Loading <a id=a>

Alternatywnie 2 , 95 bajtów

Jeśli mogę założyć, że karta jest otwarta i wklejasz ją do konsoli:

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

Zamiast pokazywania HTML zmieni się tytuł dokumentu.

Dziękuję @ user2428118 za zapisanie 2 bajtów!

F #, 118 bajtów

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

Aby uruchomić ten fragment kodu, przekaż go do Async.Startlub Async.RunSynchronously.

PHP, 90 83 80 78 77 bajtów

77:

Zamknięcie ;nie jest potrzebne.

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

78:

Szukając innego obejścia, aby uzyskać początkowo 0 bez inicjowania zmiennej, wpadłem na to:

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

Wróciłem do echa, aby wygrać kilka bajtów, ponieważ użyłem tylko printf do wymuszenia formatowania jako int. Zwiększając wartość przyrostu $ i o 0, otrzymuję poprawną liczbę całkowitą. Używając pojedynczych cudzysłowów jako ogranicznika łańcucha, odwrotny ukośnik nie musi być poprzedzany, co powoduje zwolnienie kolejnego bajtu

80:

Przeniesienie przyrostu $ i z ostatniej sekcji do księcia dało mi kolejne 3. (Patrz komentarze poniżej)

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

83:

Usunięto init zmiennej ze stanami loader.

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

90:

Próbowałem usunąć init $ i, aby zyskać trochę bajtów, ponieważ musiałem dodać sporo, aby włączyć animację modułu ładującego. printf dodaje 2 w przeciwieństwie do echa, ale sformatowanie NULL jako liczby całkowitej powoduje 0.

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

Groovy, 113 87 bajtów

-36 bajtów dzięki lealand

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

Bash, 162 104 bajty

Modyfikacja odpowiedzi Zachary'ego na powiązane pytanie, z ogromnymi ulepszeniami przez manatwork:

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

Musiałem sprawdzić, jak wykonywać losowe liczby w 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 bajtów

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

Nie golfowany:

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

Nie gwarantuję, że każda postać w tym pliku jest poprawna, proszę popraw mnie, jeśli wystąpią błędy kompilacji. Musiałem napisać całą rzecz na telefonie, więc mogłem przypadkowo dołączyć jakieś błędy ... ¯_ (ツ) _ / ¯ Mam nadzieję, że mi wybaczyliście

Przetestowałem to na moim komputerze, działa jak urok, a nawet zaoszczędziłem całe 20 bajtów dzięki pmbanka :)

C 112 103 bajty

Zaoszczędź 9 bajtów dzięki @G. Sliepen. Niezbyt ekscytujące, po prostu gra w golfa w Twojej odpowiedzi w C ++. Również niezbyt ekscytująca losowa funkcja. Myślałem o tym Sleep(c[i%4]), Sleep(i)ale wcale nie są przypadkowe!

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

Nie golfowany:

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

Mathematica, 133 bajtów

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

Uruchomi się to raz, zakładając, że x jest niezdefiniowany. Clear@xuruchomi go ponownie.

55 znaków związanych gadatliwie: /

R - 94 bajty

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

Naprawdę miło to sample(750,1) == sample(1:750,1).

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

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

loading <a id=a>

PHP, 66 79 bajtów

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

Niestety musiałem przypisać $ i, aby wydrukować „0”.
Użyj jak:

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

Edycje: dzięki Titusowi potwierdzającemu dokładnie, co jest dozwolone w Mukul Kumar, możemy zapisać 3 bajty z mniej ograniczonym zakresem, ale nie wszystkie 9 bajtów z nieograniczonym zakresem. Dziękuję również za zwrócenie uwagi na to, że zapomniałem o kolarskim charakterze i zapewnienie prostego rozwiązania.

Noodel , niekonkurencyjne 40 bajtów

Po prostu wracając do starych wyzwań (jak w przypadku wyzwań postawionych przed Noodelem ) i konkurując z Noodelem, aby znaleźć słabe punkty .

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

Jeśli wynik końcowy nie ma znaczenia, można zapisać 2 bajty.

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

Noodel przesuwa górną część stosu na ekran na końcu programu, więc dodanie €Ḃgo zapobiega temu.

Spróbuj:)

Jak to działa

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 bajtów

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

Wersja bez golfa:

 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 Nie czytałem między wierszami, dzięki! :)

MATLAB, 108 bajtów

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

Oktawa, 122 120 119 108 bajtów

Źle odczytałem wyzwanie i stworzyłem nieskończony moduł ładujący, który ponownie uruchomił się po 0, gdy przekroczył 100. Zmieniając go w jednorazowy moduł ładujący:

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

Obiegowa a, a=a([2:4,1])był pomysł flawr jest tutaj . Zapisano również 2 bajty, pomijając nawiasy po randpodziękowaniu dla MattWH.

ForceLang, 250 bajtów

Niekonkurencyjny, wymaga funkcji językowych, które dodają datę do pytania

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

Prawdopodobnie powinienem wkrótce naprawić kilka błędów związanych z analizą literałów łańcuchowych.

Rakieta 110 bajtów

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

Nie golfowany:

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

Testowanie:

(f)

Wydajność:

(Ten plik gif wyświetla wolniej niż w rzeczywistości)

107 75 Rubinowy

-32 dzięki manatwork

Normalna

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

Grał w golfa

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

Python 3, 149 bajtów

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

Podobne do Ładowanie ... Na zawsze, ale musiałem stamtąd edytować swoją odpowiedź.

TI-Basic, 80 bajtów

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

Losowość pochodzi z For(pętli (E to naukowy token E), a ponieważ interpretowany jest TI-Basic, automatycznie pojawia się również pewien narzut. Pamiętaj, że w TI-Basic małe litery i niektóre mniej popularne symbole ASCII mają po dwa bajty (tak więc specjalnie dla tego programu l o a d i n g sub( \ | %to dwubajtowe tokeny

Clojure, 109 bajtów

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

Pętle nad listą zakresu liczb od 0 do 100, spakowane nieskończoną listą "\|/-" powtarzających się na zawsze.

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

Odtwarzane w http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMOXoybnVSOVJEU00

Java 8, 130 bajtów

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

Wyjaśnienie:

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

Dane wyjściowe gif:

Visual Basic, 371 bajtów

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

Rozszerzony:

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