29
\$\begingroup\$

Make a fake loader just like this :

Parameters :

  • Display loading (space) one of these cyclically-\|/ (space) (percentage counter from 0-100) then a %.
  • The percentage counter is supposed to increment by 1 every time the display changes.
  • The time taken by counter to jump to next iteration is random. Any kind of random will do as long as the function/method is capable of generating all random integers having probability > 0 in range 1<= ms <=750 here ms being time in milliseconds.
  • Start at loading - 0 %.
  • End at loading - 100 %.
  • NO INPUT is required.
  • submit a full program or function or whatever similar.

The code that I used :

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

Winner

  • the code with least bytes wins.
\$\endgroup\$
  • 11
    \$\begingroup\$ Related \$\endgroup\$ – DJMcMayhem Dec 8 '16 at 17:32
  • 1
    \$\begingroup\$ I didn't think this was a duplicate. This question cannot be implemented in ><>, but can be in *><> for example. I quite liked it. \$\endgroup\$ – redstarcoder Dec 8 '16 at 21:25
  • 1
    \$\begingroup\$ @Mego The question isn't a duplicate. The output is a little different, the runtime is completelly different and the output requires a random time instead of a fixed 250ms delay. Answers on one question can't be used on the other without heavy modification. Please, read the questions. \$\endgroup\$ – Ismael Miguel Dec 8 '16 at 21:32
  • 8
    \$\begingroup\$ As the author of the other challenge I'll step in with the dupe debate. Although the cycling chars (\|/-) are the same, the answer seems to be different in that it is not infinite and involves generation of random numbers, rather than a static output. Therefore I'll say, although I initially felt copied, this doesn't look like a dupe to me. \$\endgroup\$ – FlipTack Dec 8 '16 at 22:12
  • \$\begingroup\$ @flp.tkc this idea came from many places combined like I saw -\|/ in some games.And I was inspired from console installation programs. \$\endgroup\$ – Mukul Kumar Dec 9 '16 at 2:50

30 Answers 30

6
\$\begingroup\$

MATL, 45 bytes

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

Example run in the offline compiler:

enter image description here

Or try it at MATL Online!

Explanation

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)
\$\endgroup\$
16
\$\begingroup\$

Powershell, 71 68 65 Bytes

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

Saved 3 bytes by not being an idiot (left the ... on loading)

-3 thanks to VisualMelon

changed 750 -> 751 to make sure 750 is included.

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

Explanation:

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
}

Updated gif

enter image description here

\$\endgroup\$
  • \$\begingroup\$ your output is not exactly same please see my gif and correct yours \$\endgroup\$ – Mukul Kumar Dec 8 '16 at 19:22
  • \$\begingroup\$ I think you can drop the space after -m, and lose the parentheses around $_%4 (seems to work on my box at least). \$\endgroup\$ – VisualMelon Dec 8 '16 at 20:44
  • \$\begingroup\$ @VisualMelon thanks, the () were leftover from the other challenge I straight copied my code from. \$\endgroup\$ – colsw Dec 9 '16 at 8:45
8
\$\begingroup\$

Python 2, 119 113 112 Bytes

I had originally gone with the random amount being random()/.75, however the endpoint wouldn't be included. There isn't much difference from this to the other question for the infinite load time except for the randomness and the fact that it actually ends.

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

thanks to Jonathan Allan for saving 6 bytes, and DJMcMayhem for saving a byte!

\$\endgroup\$
  • 1
    \$\begingroup\$ Save 6 bytes with import time,random as r and r.randint. \$\endgroup\$ – Jonathan Allan Dec 8 '16 at 18:14
  • \$\begingroup\$ @JonathanAllan Didn't realize you could import like that, thanks! \$\endgroup\$ – Kade Dec 8 '16 at 18:22
  • \$\begingroup\$ A for loop is slightly shorter: for i in range(101):print'\rLoading','-\|/'[i%4],i,'%',;time.sleep(r.randint(1,750)/1e3) \$\endgroup\$ – DJMcMayhem Dec 8 '16 at 18:31
  • \$\begingroup\$ @DJMcMayhem Whoops, I had been testing it with range(1,101) for some reason.. \$\endgroup\$ – Kade Dec 8 '16 at 18:33
  • \$\begingroup\$ Acttually, I found something another 3 bytes shorter: i=0;for c in'-\|/'*25:print'\rLoading',c,i,'%',;time.sleep(r.randint(1,750)/1e3);i+=1 \$\endgroup\$ – DJMcMayhem Dec 8 '16 at 18:35
6
\$\begingroup\$

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%

The timing is fairly poor unfortunately, but Batch doesn't have anything better to use than ping.

\$\endgroup\$
  • \$\begingroup\$ This only works on Windows. FreeCom DOS batch gives Loading % Invalid switch. - /aw (I would love to try it in MS DOS if I can still find my copy). \$\endgroup\$ – Brian Minton Dec 9 '16 at 21:56
  • \$\begingroup\$ @BrianMinton: Good luck running it on MS DOS (no ping command) \$\endgroup\$ – Joshua Dec 9 '16 at 22:53
  • \$\begingroup\$ @BrianMinton It requires CMD.EXE because of the advanced variable substitutions. \$\endgroup\$ – Neil Dec 9 '16 at 23:50
  • \$\begingroup\$ @Joshua Well, not built in at least; that didn't happen until Windows 2000. \$\endgroup\$ – Neil Dec 9 '16 at 23:52
6
\$\begingroup\$

*><> (Starfish), 86 82 bytes

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

Try it here!

This may be able to be golfed more, but I don't see anything super obvious. It sleeps 100ms, 400ms, or 700ms, if this isn't random enough, let me know!

Thanks to @TealPelican for saving me 4 bytes and making it much more random!

The biggest challenges I found (while still trying to keep it small) were randomness, and actually outputting "loading - 100 %" at the end, instead of just exiting at my nearest convenience :p.

\$\endgroup\$
  • 1
    \$\begingroup\$ Hey, I love this take on the ><> language, it opens up a lot more challenges :D - I've had a bit of a tweak on your code and I've not reduced it by much but changed the random numbers. Link to ><> code The only change to make this viable in *><> would be changing the ~ from the code link to S to use the time. This does generate random numbers all the way up to 749 and cuts out some excess stack operations. P.S I'd love it if you could make *><> online interpreter :D \$\endgroup\$ – Teal pelican Dec 12 '16 at 11:29
  • 1
    \$\begingroup\$ @Tealpelican, thanks! I love your changes, especially the random number generator! I'd also love an online *><> interpreter :p. I don't play around with JS too often, but I'll both look into playing with JS, or maybe running the Go interpreter through GopherJS first for a head-start. :) \$\endgroup\$ – redstarcoder Dec 12 '16 at 15:03
  • 1
    \$\begingroup\$ Thanks, it took a while to actually come up with a working version but this seems the mosted golfed I could generate. I'll keep my eye out for it and if not may dabble into making a python one. I still think the first line could be golfed a bit more but I haven't been able to do it myself. \$\endgroup\$ – Teal pelican Dec 12 '16 at 15:26
  • 1
    \$\begingroup\$ @Tealpelican hopefully this fills the online interpreter itch, or at least gets the ball rolling. I'm going to look into a way to share code later. starfish.000webhostapp.com \$\endgroup\$ – redstarcoder Dec 12 '16 at 18:54
  • 1
    \$\begingroup\$ That was quick, just running the program in it now and seems to work fine :D I'm going to try have a look at using this for some challenges this week. \$\endgroup\$ – Teal pelican Dec 12 '16 at 20:37
5
\$\begingroup\$

Perl 6, 67 bytes

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

Expanded:

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

}
\$\endgroup\$
4
\$\begingroup\$

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

This seems to work perfectly fine, even with this sketchy source of "random" numbers.

(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

This one uses an already-existing element to display the remaining content:

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

Alternative 2, 95 bytes

If I can assume a tab is opened and that you're pasting this into the console:

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

Instead of showing the HTML, the title of the document will change.


Thank you to @user2428118 for saving 2 bytes!

\$\endgroup\$
  • \$\begingroup\$ You can drop the () after Date to save two bytes. \$\endgroup\$ – user2428118 Dec 9 '16 at 9:39
  • \$\begingroup\$ @user2428118 I didn't knew that that works! Thank you for the tip. \$\endgroup\$ – Ismael Miguel Dec 9 '16 at 11:24
4
\$\begingroup\$

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

In order to run this snippet, pass it into Async.Start or Async.RunSynchronously.

\$\endgroup\$
  • \$\begingroup\$ Instant upvote because of F# \$\endgroup\$ – Snowfire Dec 9 '16 at 14:12
4
\$\begingroup\$

PHP, 90 83 80 78 77 Bytes

77:

The closing ; is not needed.

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

78:

While looking for another workaround to get a 0 initially without initializing the variable I came up with this:

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

Changed back to echo to win a few bytes as I only used printf to force-format as int. By incrementing the incremented $i with 0 I get a valid integer. By using single quotes as string delimiter the backslash does not need to be escaped, resulting in another byte freed

80:

Moving the increment of $i from the last for-section to the prinf gave me another 3 off. (See comments below)

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

83:

Removed init of a variable with the loaderstates.

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

90:

I tried removing the init of $i to gain some bytes, as I had to add quite a few to enable the loader animation. printf adds 2 as opposed to echo, but formatting NULL as an integer results in 0.

for($l='-\|/';$i<101;usleep(rand(0,750)*1e3),$i++)printf("\rloading %s %d%%",$l[$i%4],$i);
\$\endgroup\$
  • \$\begingroup\$ There's one mistake: The question requires the delay to be between 1 and 750, inclusive. You have between 0 and 750. Also, you could move the increment to the printf, saving you a single byte: for(;$i<101;usleep(rand(1,750)*1e3))printf("\rloading %s %d%%",'-\|/'[$i%4],$i++); (82 bytes) \$\endgroup\$ – Ismael Miguel Dec 9 '16 at 16:26
  • 1
    \$\begingroup\$ @IsmaelMiguel rand() is inclusive, or is this because of the multiplication by *1e3? I'm going to sneak in that free byte. \$\endgroup\$ – thisisboris Dec 9 '16 at 16:31
  • \$\begingroup\$ The question requires a random interval between 1ms and 750ms (inclusive). rand(0,750)*1e3 returns a value between 0 (invalid) and 750, which is multiplied by 1000. rand(1,75e4) returns a value between 1 (invalid) and 750000. The delay must be rand(1,750)*1e3, since you use usleep(). It works with microseconds, which is 1000x smaller than a millisecond. \$\endgroup\$ – Ismael Miguel Dec 9 '16 at 17:13
  • \$\begingroup\$ This may take you inconveniently close to user59178´s answer, but echo is 3 bytes shorter than printf. You may want to put the most recent version to the top and use #title instead of **title**. And there is a space missing between the number and the %. \$\endgroup\$ – Titus Dec 9 '16 at 20:01
  • \$\begingroup\$ @Titus I can't use echo here because I didn't initialize my $i, null to string evaluates to '', via printf I force integer (%d) resulting in null = 0. #justphpthings \$\endgroup\$ – thisisboris Dec 13 '16 at 15:04
3
\$\begingroup\$

Groovy, 113 87 bytes

-36 bytes thanks to lealand

{p=-1;101.times{print"\rLoading ${"-\\|/"[p++%4]} $p%";sleep Math.random()*750as int}}​
\$\endgroup\$
  • 2
    \$\begingroup\$ 84 bytes, and should run from Groovy console: p=-1;101.times{println"Loading ${"-\\|/"[p++%4]} $p%";sleep Math.random()*750as int} \$\endgroup\$ – lealand Dec 8 '16 at 23:57
  • 1
    \$\begingroup\$ Although the question owner not explicitly requested, he probably wants the consecutive loading messages to overwrite each other. There is no size difference, so better change println"Loading…print"\rLoading…. And remove that variable p, use the implicit it instead. \$\endgroup\$ – manatwork Dec 9 '16 at 11:48
3
\$\begingroup\$

Bash, 162 104 bytes

Modification of Zachary's answer on a related question, with massive improvements by manatwork:

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

I had to look up how to do random numbers in 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]`
}
\$\endgroup\$
  • 1
    \$\begingroup\$ Nice first try. See Tips for golfing in Bash for improvement tips. Personally would go with s='-\|/';for x in {0..100};{ printf "\rloading ${s:x%4:1} $x %%";sleep `printf .%03d $[RANDOM%750+1]`; } BTW, our fellow site Unix & Linux also has a question about How to do integer & float calculations, in bash or other languages/frameworks?. \$\endgroup\$ – manatwork Dec 12 '16 at 9:56
  • \$\begingroup\$ @manatwork Good links! I didn't know about $[math], using { } instead of do done, or using back ticks instead of $(). Yeah, reusing $x for accessing the loader graphic array makes sense. Also, slapping a . in front of the number to get the decimal for sleep is pretty sweet! \$\endgroup\$ – Hydraxan14 Dec 12 '16 at 15:38
3
\$\begingroup\$

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

I won't guarantee that every character in this is right, please correct me if there are compilation errors. I had to type the whole thing on my phone so I might have accidentally included some errors... ¯_(ツ)_/¯ I hope you guys forgive me that

Tested it on my PC, works like a charm and I even saved a whole 20 bytes thanks to pmbanka :)

\$\endgroup\$
  • 1
    \$\begingroup\$ You can use \r (carriage return) instead of Console.Clear(). You can also inline s variable to save some bytes. \$\endgroup\$ – pmbanka Dec 9 '16 at 14:11
  • 1
    \$\begingroup\$ You can also save an extra byte by replacing the i<=100 for i<101 \$\endgroup\$ – auhmaan Dec 9 '16 at 16:33
  • \$\begingroup\$ for (int i = 0; i <= 100; i++) can be rewritten as for (int i = 0; i++ <= 100;) Then you can put the Thread.Sleep within the place where i++ was and save both curly brackets. Cutting 3 bytes in total \$\endgroup\$ – CSharpie Jan 19 '17 at 18:32
  • \$\begingroup\$ Also OP didnt ask for a Programm so you can replace static void l() with ()=> \$\endgroup\$ – CSharpie Jan 19 '17 at 18:36
2
\$\begingroup\$

C 112 103 bytes

Saved 9 bytes thanks to @G. Sliepen. Not very exciting, just a golf of your C++ answer basically. Also not a very exciting random function. I thought about Sleep(c[i%4]), or Sleep(i) but they're not random at all!

#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);
  }
}
\$\endgroup\$
  • 3
    \$\begingroup\$ I am afraid but rand ()%750 generates numbers from 0-749 you will need to add 1. \$\endgroup\$ – Mukul Kumar Dec 8 '16 at 20:35
  • \$\begingroup\$ Changing rand()%750 to rand()%751 won't give the result you want. It will generate a random value between 0 and 750. In the question, the delay must be between 1 and 750 (inclusive). According to tutorialspoint.com/c_standard_library/c_function_rand.htm, the rand() function generates numbers between 0 and (at least) 32767. If you do 0 % 750, you get 0 since 0 / <anything> == 0. \$\endgroup\$ – Ismael Miguel Dec 8 '16 at 21:08
  • \$\begingroup\$ Shave off 9 bytes by removing char*c="-\\|/"; and using the literal string directly instead of the variable c: printf(...,"-\\|/"[i%4],...) \$\endgroup\$ – G. Sliepen Dec 9 '16 at 12:45
2
\$\begingroup\$

Mathematica, 133 Bytes

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

This will run once, assuming x is undefined. Clear@x will restart it.

55 characters tied up in verbosity :/

\$\endgroup\$
  • \$\begingroup\$ Is that a fixed interval or will it be repeatedly randomized? \$\endgroup\$ – Titus Dec 9 '16 at 18:37
  • \$\begingroup\$ It's randomized. UpdateInterval:>.75 would have been fixed \$\endgroup\$ – Kelly Lowder Dec 9 '16 at 19:15
  • 1
    \$\begingroup\$ @Titus: I believe UpdateInterval:>RandomReal@.75 repeatedly calls RandomReal, but UpdateInterval->RandomReal@.75 would call it only once. \$\endgroup\$ – Omar Dec 14 '16 at 2:12
2
\$\begingroup\$

R - 94 bytes

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

Really nice that sample(750,1) == sample(1:750,1).

\$\endgroup\$
2
\$\begingroup\$

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>

\$\endgroup\$
2
\$\begingroup\$

PHP, 66 79 bytes

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

Unfortunately I had to assign $i in order to get it to print '0'.
Use like:

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

Edits: thanks to Titus confirming exactly what's allowed with Mukul Kumar we can save 3 bytes with a less restricted range, but not all 9 bytes with an unrestricted range. Thanks also for pointing out that I forgot the cycling character and providing a simple solution to do it.

\$\endgroup\$
  • 1
    \$\begingroup\$ The random requirements are that you generate all 1ms to 750ms with a possibility>0. I can´t see that other values are prohibited. rand(1,75e4) saves 3 bytes; 1e6 can save another one; and no parameters at all save 9 bytes altogether; and I don´t see that violate any rule. But you forgot to cycle the character: +16 for ","-\\|/"[$i%4]," instead of -. \$\endgroup\$ – Titus Dec 9 '16 at 16:11
  • \$\begingroup\$ @Titus Won't usleep(rand(1,75e4)) generate a random interval between 1 microsecond and 750 milliseconds? Also, according to the question, the interval must be between 1 and 750, inclusive. \$\endgroup\$ – Ismael Miguel Dec 9 '16 at 17:46
  • \$\begingroup\$ See the latest comments on the question: 1 to 75e4 is acceptable. \$\endgroup\$ – Titus Dec 9 '16 at 18:34
  • \$\begingroup\$ @Titus I'd considered changes like those but decided to go with what seemed implied by the question (integer millisecond delays). Thanks for asking exactly what was allowed! \$\endgroup\$ – user59178 Dec 12 '16 at 9:49
2
\$\begingroup\$

Noodel, noncompeting 40 bytes

Just going back through old challenges (as in challenges that were made before Noodel) and competing with Noodel to find where it is weak.

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

If final output does not matter, then can save 2 bytes.

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

Noodel pushes the top of the stack to the screen at the end of the program so by adding the €Ḃ it prevents that from happening.

Try it:)

How It Works

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>

\$\endgroup\$
  • \$\begingroup\$ Why are there so many ¤s? \$\endgroup\$ – Kritixi Lithos Jan 11 '17 at 18:54
  • \$\begingroup\$ @KritixiLithos Noodel uses spaces as a NOP so for printing a space the ¤ is used:) \$\endgroup\$ – tkellehe Jan 11 '17 at 18:56
  • 1
    \$\begingroup\$ Btw, it's nice that there is a stack snippet for this :) \$\endgroup\$ – Kritixi Lithos Jan 11 '17 at 18:57
  • \$\begingroup\$ How does the snippet work? Does the imported script find the element with the id of noodle, then translate the code to Javascript? \$\endgroup\$ – Carcigenicate Jan 20 '17 at 1:03
  • \$\begingroup\$ @Carcigenicate, Yes. The "parser" is the JavaScript function noodel which handles the code properly. It translates the code into tokens that are JavaScript objects that get chained together then executed. The ppcg.min.js creates the proper HTML objects and translates the output of what is parsed into the HTML objects to create the display. Every token is executed by stepping through them triggering a step event which is registered to update the screen:) Does that help? \$\endgroup\$ – tkellehe Jan 20 '17 at 2:00
2
\$\begingroup\$

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 Did not read between the lines there, Thanks! :)

\$\endgroup\$
  • 1
    \$\begingroup\$ c[] is not random... But is cycling.... \$\endgroup\$ – Mukul Kumar Jan 19 '17 at 19:05
  • \$\begingroup\$ Or, in other words, you're not supposed to pick a random character from "\|/-", you're supposed to display /, then -, then \, then |, in a cycle. \$\endgroup\$ – Carcigenicate Jan 20 '17 at 0:58
  • \$\begingroup\$ @MukulKumar @ Carcigenicate Updated the code so that it does what the spec says regarding cycling characters! \$\endgroup\$ – Abel Tom Jan 20 '17 at 4:39
1
\$\begingroup\$

MATLAB, 108 bytes

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

Octave, 122 120 119 108 bytes

I misread the challenge and created an infinite loader that restarted at 0 once it passed 100. Making it into a one time only loader:

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

Circulating a, a=a([2:4,1]) was flawr's idea here. Also, saved 2 bytes by skipping the parentheses after rand thanks to MattWH.

\$\endgroup\$
  • \$\begingroup\$ Should it be .749*rand()+.001? This can wait for 751ms. Also you can leave the () off rand and save 2 bytes. \$\endgroup\$ – MattWH Dec 9 '16 at 16:05
1
\$\begingroup\$

ForceLang, 250 bytes

Noncompeting, requires language features which postdate the 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

I should probably fix some bugs related to string literal parsing soon.

\$\endgroup\$
1
\$\begingroup\$

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

Testing:

(f)

Output: enter image description here

(This gif file is showing slower display than actual)

\$\endgroup\$
  • \$\begingroup\$ What's with the stuff at the end in the gif? \$\endgroup\$ – Carcigenicate Jan 20 '17 at 1:03
  • \$\begingroup\$ This seem to be an artefact from screen capture program. \$\endgroup\$ – rnso Jan 20 '17 at 3:09
1
\$\begingroup\$

107 75 Ruby

-32 thanks to 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}
\$\endgroup\$
  • \$\begingroup\$ Given you have a single line of output to overwrite, the system'clear' is overkill here. Also the use of the separate variable i. Oh, and precalculate where possible: 0.750-0.010.749 (also note that you lack one decimal place in 0.01 – should be 0.001). The resulting 101.times{|c|$><<"\rloading #{'-\|/'[c%4]} #{c} %";sleep rand*0.749+0.001} becomes very similar to Conor O'Brien's Ruby answer in Loading… Forever but so is the challenge. \$\endgroup\$ – manatwork Dec 13 '16 at 16:36
1
\$\begingroup\$

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 to Loading... Forever, but I did have to edit my answer from there a lot.

\$\endgroup\$
1
\$\begingroup\$

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

The randomness comes from the For( loop (E is scientific E token) and since TI-Basic is interpreted there is also automatically some overhead. Remember that in TI-Basic, lowercase letters and some less common ASCII symbols are two bytes each (so specifically for this program, l o a d i n g sub( \ | % are the two-byte tokens

\$\endgroup\$
1
\$\begingroup\$

Clojure, 109 bytes

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

Loops over a list of the range of numbers from 0 to 100, zipped with an infinite list of "\|/-" repeating forever.

; (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)))
\$\endgroup\$
1
\$\begingroup\$

tcl, 116

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

Playable in http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMOXoybnVSOVJEU00

\$\endgroup\$
  • \$\begingroup\$ Your output seems little off... \$\endgroup\$ – Mukul Kumar Jan 17 '17 at 14:31
  • \$\begingroup\$ hmm,,, my code disappeared! ... \$\endgroup\$ – sergiol Jan 17 '17 at 17:02
  • \$\begingroup\$ I mean that your output is in this format "loading... xx%" instead it should be like this "loading - xx%" where '-' varies as explained in the question. \$\endgroup\$ – Mukul Kumar Jan 19 '17 at 3:46
  • \$\begingroup\$ @MukulKumar: Fixed. \$\endgroup\$ – sergiol Jan 19 '17 at 15:03
1
\$\begingroup\$

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

Explanation:

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

Output gif:

enter image description here

\$\endgroup\$
0
\$\begingroup\$

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

Expanded:

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
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.