नकली लोडर को इस तरह बनाएं:

पैरामीटर:

प्रदर्शन loading(स्थान) इनमें से एक चक्रीय रूप से -\|/(अंतरिक्ष) (0-100 से प्रतिशत काउंटर) तो ए %।
हर बार डिस्प्ले बदलने पर प्रतिशत काउंटर को 1 से बढ़ाना चाहिए।
अगली पुनरावृत्ति पर जाने के लिए काउंटर द्वारा लिया गया समय यादृच्छिक है। किसी भी प्रकार का यादृच्छिक कार्य तब तक किया जाएगा जब तक कि फ़ंक्शन / विधि सभी यादृच्छिक पूर्णांकों को उत्पन्न करने में सक्षम हो, जिसमें संभवता> 0 रेंज में हो1<= ms <=750 यहां msमिलीसेकंड में हो।
प्रारंभ में loading - 0 %।
समाप्त होता है loading - 100 %।
कोई INPUT आवश्यक है।
एक पूर्ण कार्यक्रम या समारोह या जो भी समान प्रस्तुत करें।

कोड है कि मैं इस्तेमाल किया:

सी ++

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

विजेता

कम से कम बाइट्स वाला कोड जीत जाता है।

code-golf ascii-art kolmogorov-complexity

— मुकुल कुमार
स्रोत

11

MATL , 45 बाइट्स

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

ऑफ़लाइन कंपाइलर में उदाहरण चलाना:

या इसे MATL ऑनलाइन पर आज़माएं!

व्याख्या

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)

— लुइस मेंडो
स्रोत

16

पॉवरशेल, 71 68 65 बाइट्स

के समान Https://codegolf.stackexchange.com/a/101357/59735 के

एक बेवकूफ नहीं होने से 3 बाइट्स बचाए (लोड होने पर ... छोड़ दिया)

-3 VisualMelon के लिए धन्यवाद

बदला हुआ 750 -> 751 सुनिश्चित करने के लिए 750 शामिल है।

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

स्पष्टीकरण:

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 अपडेट किया गया

— colsw
स्रोत

आपका आउटपुट बिल्कुल वैसा नहीं है, कृपया मेरे gif को देखें और आपका सही करें

— मुकुल कुमार

मुझे लगता है कि आप बाद में जगह छोड़ सकते हैं -m, और चारों ओर कोष्ठक खो सकते हैं $_%4(कम से कम मेरे बॉक्स पर काम करने लगता है)।

— VisualMelon

@VisualMelon धन्यवाद, ()अन्य चुनौती से बचे हुए थे जिन्हें मैंने सीधे अपने कोड से कॉपी किया था।

— Colsw

8

पायथन 2, 119 113 112 बाइट्स

मैं मूल रूप से यादृच्छिक राशि के साथ चला गया था random()/.75, हालांकि समापन बिंदु शामिल नहीं किया जाएगा। यादृच्छिकता और तथ्य यह है कि यह वास्तव में समाप्त होता है को छोड़कर अनंत लोड समय के लिए अन्य प्रश्न के लिए इससे बहुत अंतर नहीं है।

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

^{6 बाइट बचाने के लिए जोनाथन एलन का धन्यवाद, और बाइट बचाने के लिए DJMcMayhem!}

— Kade
स्रोत

1

के साथ 6 बाइट्स सहेजें import time,random as rऔर r.randint।

— जोनाथन एलन

@JonathanAllan एहसास नहीं था कि आप इस तरह आयात कर सकते हैं, धन्यवाद!

— काडे

लूप के लिए थोड़ा कम है:for i in range(101):print'\rLoading','-\|/'[i%4],i,'%',;time.sleep(r.randint(1,750)/1e3)

— डीजेमेकमेम

@DJMcMayhem वूप्स, मैं range(1,101)किसी कारण से इसका परीक्षण कर रहा था ..

— Kade

Acttually, मैं कुछ पाया और 3 कम बाइट्स:i=0;for c in'-\|/'*25:print'\rLoading',c,i,'%',;time.sleep(r.randint(1,750)/1e3);i+=1

— DJMcMayhem

6

बैच, 185 बाइट्स

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

दुर्भाग्य से समय काफी खराब है, लेकिन बैच का उपयोग करने के लिए कुछ भी बेहतर नहीं है ping।

— नील
स्रोत

यह केवल विंडोज पर काम करता है। FreeCom DOS बैच देता है Loading % Invalid switch. - /aw (अगर मैं अभी भी अपनी कॉपी पा सकता हूं तो मैं एमएस डॉस में इसे आज़माना पसंद करूंगा)।

— ब्रायन मिंटन

@BrianMinton: MS DOS (कोई पिंग कमांड) पर इसे चलाने का सौभाग्य

— जोशुआ

@ ब्रायनमिंटन को उन्नत चर प्रतिस्थापन के कारण CMD.EXE की आवश्यकता होती है।

— नील

@ जोशुआ खैर, कम से कम नहीं बनाया गया; विंडोज 2000 तक ऐसा नहीं हुआ।

— नील

6

* <<> (स्टारफ़िश), 86 82 बाइट्स

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

यहाँ यह कोशिश करो!

यह अधिक गोल्फ होने में सक्षम हो सकता है, लेकिन मुझे कुछ भी स्पष्ट नहीं दिखता है। यह 100ms, 400ms, या 700ms सोता है, अगर यह पर्याप्त यादृच्छिक नहीं है, तो मुझे बताएं!

मुझे 4 बाइट बचाने और इसे और अधिक यादृच्छिक बनाने के लिए @TealPelican का धन्यवाद!

सबसे बड़ी चुनौतियां जो मुझे मिलीं (जबकि अभी भी इसे छोटा रखने की कोशिश कर रहे थे) बेतरतीब थीं, और वास्तव में मेरी निकटतम सुविधा पर बाहर निकलने के बजाय, अंत में "लोडिंग - 100%" का उत्पादन कर रही थी: पी।

— redstarcoder
स्रोत

1

अरे, मुझे यह पसंद है कि इसे> <> भाषा पर ले लो, यह बहुत अधिक चुनौतियां खोलता है: डी - मैंने आपके कोड पर थोड़ा ट्वीक किया है और मैंने इसे बहुत कम नहीं किया है लेकिन यादृच्छिक संख्याओं को बदल दिया है। लिंक> <> कोड इस व्यवहार्य बनाने के लिए एकमात्र परिवर्तन *> <> कोड लिंक से S को समय का उपयोग करने के लिए ~ बदल रहा है। यह 749 तक सभी तरह से यादृच्छिक संख्या उत्पन्न करता है और कुछ अतिरिक्त स्टैक संचालन को काटता है। PS मुझे अच्छा लगेगा अगर आप *> <> ऑनलाइन दुभाषिया: D

— Teal pelican

1

@ Tealpelican, धन्यवाद! मुझे आपके परिवर्तन पसंद हैं, विशेष रूप से यादृच्छिक संख्या जनरेटर! मुझे भी एक ऑनलाइन *> <> दुभाषिया: पी पसंद आएगा। मैं अक्सर जेएस के साथ नहीं खेलता हूं, लेकिन मैं दोनों जेएस के साथ खेलता हूं, या शायद गोफरजेएस के माध्यम से गो दुभाषिया चला रहा हूं। :)

— redstarcoder

1

धन्यवाद, वास्तव में काम करने वाले संस्करण के साथ आने में थोड़ा समय लगा, लेकिन ऐसा लगता है कि मैं सबसे ज्यादा गोल्फ खेल सकता हूं। मैं इसके लिए अपनी आँख बाहर रखूँगा और अगर एक अजगर बनाने में नाकाम नहीं हो सकता। मुझे अभी भी लगता है कि पहली पंक्ति को थोड़ा और गोल किया जा सकता है, लेकिन मैं इसे स्वयं करने में सक्षम नहीं हूं।

— पेलिकन

1

@ Tealpelican उम्मीद है कि यह ऑनलाइन दुभाषिया खुजली को भरता है, या कम से कम गेंद को लुढ़क जाता है। मैं बाद में कोड साझा करने का एक तरीका देखने जा रहा हूं। starfish.000webhostapp.com

— redstarcoder

1

यह त्वरित था, बस अब इसमें कार्यक्रम चला रहा है और ठीक काम करने के लिए लगता है: डी मैं कोशिश कर रहा हूं कि इस सप्ताह कुछ चुनौतियों के लिए इसका उपयोग करने पर एक नज़र डालें।

— टीले पेलिकन

5

पर्ल 6 , 67 बाइट्स

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

विस्तारित:

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

}

— ब्रैड गिल्बर्ट b2gills
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 128 118 116 115 112 110 109 बाइट्स

यह पूरी तरह से ठीक काम करने लगता है, यहां तक कि "यादृच्छिक" संख्याओं के इस स्केचरी स्रोत के साथ।

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

स्निपेट का विस्तार करें

वैकल्पिक 1 , जावास्क्रिप्ट + HTML, 16 + 84 बाइट्स

यह शेष सामग्री को प्रदर्शित करने के लिए पहले से मौजूद तत्व का उपयोग करता है:

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

Loading <a id=a>

स्निपेट का विस्तार करें

वैकल्पिक 2 , 95 बाइट्स

अगर मैं मान सकता हूं कि एक टैब खोला गया है और आप इसे कंसोल में चिपका रहे हैं:

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

HTML दिखाने के बजाय, दस्तावेज़ का शीर्षक बदल जाएगा।

2 बाइट बचाने के लिए @ user2428118 को धन्यवाद !

— इस्माइल मिगुएल
स्रोत

आप दो बाइट्स सहेजने के ()बाद छोड़ सकते हैं Date।

— user2428118

@ user2428118 मुझे नहीं पता था कि यह काम करता है! टिप के लिए धन्यवाद।

— इस्माइल मिगुएल

4

एफ #, 118 बाइट्स

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

इस स्निपेट को चलाने के लिए, इसे पास करें Async.Startया Async.RunSynchronously।

— pmbanka
स्रोत

#

— स्नोफायर डे

4

PHP, 90 83 80 78 77 बाइट्स

77:

समापन ;की जरूरत नहीं है।

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

78:

जबकि मैं इसके साथ आया था चर को शुरू किए बिना 0 प्राप्त करने के लिए एक और समाधान की तलाश में है:

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

कुछ बाइट्स जीतने के लिए प्रतिध्वनित करने के लिए वापस बदला क्योंकि मैंने केवल प्रिन्ट-फोर्स का उपयोग इंट-फॉर्म के रूप में किया था। 0 के साथ बढ़े हुए $ i को बढ़ाकर मुझे एक वैध पूर्णांक मिलता है। स्ट्रिंग डिमाइटर के रूप में सिंगल कोट्स का उपयोग करके बैकस्लैश को भागने की जरूरत नहीं है, जिसके परिणामस्वरूप एक और बाइट मुक्त हो जाती है

80:

पिछले फॉर-सेक्शन से प्रिंस तक $ i की वृद्धि को आगे बढ़ाते हुए मुझे एक और 3 दिया गया। (नीचे टिप्पणी देखें)

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

83:

लोडरस्टेट्स के साथ एक वैरिएबल का इनिट हटा दिया गया।

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

90:

मैंने कुछ बाइट्स हासिल करने के लिए $ i की init निकालने की कोशिश की, क्योंकि मुझे लोडर एनीमेशन को सक्षम करने के लिए काफी कुछ जोड़ना था। प्रिंटो गूंज के विपरीत 2 जोड़ता है, लेकिन NULL को पूर्णांक के रूप में स्वरूपित करने पर परिणाम 0 हो जाता है।

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

— thisisboris
स्रोत

एक गलती है: प्रश्न में 1 और 750 के बीच की देरी की आवश्यकता है, समावेशी। आपके पास 0 और 750 के बीच है। इसके अलावा, आप वेतन वृद्धि को आगे बढ़ा सकते हैं printf, जिससे आप एक सिंगल बाइट बचा सकते हैं: for(;$i<101;usleep(rand(1,750)*1e3))printf("\rloading %s %d%%",'-\|/'[$i%4],$i++);(82 बाइट्स)

— इस्माइल मिगुएल

1

@IsmaelMiguel रैंड () * 1e3 द्वारा गुणा के कारण समावेशी है , या है? मैं उस मुफ्त बाइट में चुपके जा रहा हूँ।

— दिसबोरिस

प्रश्न के लिए 1ms और 750ms (सम्मिलित) के बीच एक यादृच्छिक अंतराल की आवश्यकता होती है। rand(0,750)*1e30 (अमान्य) और 750 के rand(1,75e4)बीच का मान लौटाता है, जिसे 1000 से गुणा किया जाता है। 1 (अमान्य) और 750000 के बीच का मान लौटाता है। विलंब तब होना चाहिए rand(1,750)*1e3, जब से आप उपयोग करते हैं usleep()। यह माइक्रोसेकंड के साथ काम करता है , जो एक मिलीसेकंड से 1000 गुना छोटा है।

— इस्माईल मिगुएल

यह आपको उपयोगकर्ता के उत्तर के करीब असुविधाजनक रूप से ले जा सकता है59178 but जवाब है, लेकिन echo3 बाइट्स से कम है printf। आप सबसे हाल के संस्करण को शीर्ष पर रखना चाहते हैं और #titleइसके बजाय उपयोग कर सकते हैं **title**। और संख्या और के बीच एक स्थान गायब है %।

— टाइटस

@ टिट्स मैं यहां इको का उपयोग नहीं कर सकता क्योंकि मैंने अपना $ i, null to string का मूल्यांकन नहीं किया है '', प्रिंटफ के माध्यम से मैं पूर्णांक को बल देता हूं (% d) जिसके परिणामस्वरूप null = 0. #justphpingsings

— itisborisis

3

ग्रूवी, 113 87 बाइट्स

-36 बाइट्स लीलैंड के लिए धन्यवाद

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

— Magic Octopus Urn
स्रोत

2

84 bytes, and should run from Groovy console: p=-1;101.times{println"Loading ${"-\\|/"[p++%4]} $p%";sleep Math.random()*750as int}

— lealand

1

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.

— manatwork

3

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]`
}

— Hydraxan14
स्रोत

1

पहले अच्छा प्रयास करें। सुधार के सुझावों के लिए बैश में गोल्फ के लिए युक्तियाँ देखें । व्यक्तिगत रूप से s='-\|/';for x in {0..100};{ printf "\rloading ${s:x%4:1} $x %%";sleep `printf .%03d $[RANDOM%750+1]`; }BTW के साथ जाना होगा , हमारे साथी साइट यूनिक्स और लिनक्स में यह भी सवाल है कि कैसे बेज़ या अन्य भाषाओं / फ्रेमवर्क में पूर्णांक और फ्लोट गणना करना है? ।

— मैनटवर्क

@manatwork अच्छे लिंक! मुझे इसके बारे में पता नहीं था $[math], { }इसके बजाय का उपयोग कर रहा था do done, या इसके बजाय वापस टिक्स का उपयोग कर रहा था $()। हाँ, लोडर ग्राफिक सरणी तक पहुँचने के लिए $ x का पुन: उपयोग करना समझ में आता है। इसके अलावा, .नींद के लिए दशमलव प्राप्त करने के लिए संख्या के सामने थप्पड़ मारना बहुत प्यारा है!

— हाइड्रैक्सन 14

3

सी #, ~~170~~ ~~149~~ 135 बाइट्स

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

मैं इस बात की गारंटी नहीं दूंगा कि इसमें हर पात्र सही है, अगर संकलन गलतियाँ हैं तो कृपया मुझे सही करें। मुझे अपने फोन पर पूरी बात टाइप करनी थी, इसलिए मैंने गलती से कुछ त्रुटियां शामिल कर ली होंगी ... whole_ (ツ) _ / / मुझे आशा है कि आप लोग मुझे क्षमा करेंगे

मेरे पीसी पर इसका परीक्षण किया गया, एक आकर्षण की तरह काम करता है और मैंने पम्बंका के लिए पूरे 20 बाइट्स भी सहेजे हैं :)

— Snowfire
स्रोत

1

आप \rइसके बजाय (गाड़ी वापसी) का उपयोग कर सकते हैं Console.Clear()। आप कुछ बाइट्स को बचाने के लिए वेरिएबल को इनलाइन भी कर सकते हैं।

— pmbanka

1

तुम भी बदल कर एक अतिरिक्त बाइट बचा सकता है i<=100के लिएi<101

— auhmaan

for (int i = 0; i <= 100; i++)के रूप में for (int i = 0; i++ <= 100;)फिर से लिखा जा सकता है। आप थ्रेड सो सकते हैं। उस जगह के भीतर जहां मैं ++ था और दोनों घुंघराले कोष्ठक बचा सकता हूं। कुल 3 बाइट्स काटना

— CSharpie

इसके अलावा ओपी फ्लॉप एक डेबूटस्ट्रैप के लिए पूछना तो आप जगह ले सकता है static void l()के साथ()=>

— CSharpie

2

C 112 103 बाइट्स

@ बाइट की बदौलत 9 बाइट्स बचाए। Sliepen। बहुत रोमांचक नहीं है, बस मूल रूप से आपके C ++ उत्तर का एक गोल्फ। इसके अलावा एक बहुत ही रोमांचक यादृच्छिक समारोह नहीं है। मैंने सोचा था Sleep(c[i%4]), या Sleep(i)वे यादृच्छिक नहीं हैं!

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

— nmjcman101
स्रोत

3

मुझे डर है, लेकिन rand ()%750आपको 4-749 से नंबर जेनरेट करने होंगे, आपको जोड़ने की जरूरत होगी 1.

— मुकुल कुमार

बदलने rand()%750के लिए rand()%751परिणाम आप चाहते हैं नहीं देंगे। यह 0 और 750 के बीच एक यादृच्छिक मूल्य उत्पन्न करेगा । प्रश्न में, देरी 1 और 750 (समावेशी) के बीच होनी चाहिए । Tutorialspoint.com/c_standard_library/c_function_rand.htm के अनुसार , फ़ंक्शन 0 और (कम से कम) 32767 के बीच संख्या उत्पन्न करता है। यदि आप करते हैं , तो आप 0 से प्राप्त करते हैं । rand()0 % 7500 / <anything> == 0

— इस्माईल मिगुएल

हटाने char*c="-\\|/";और चर के बजाय सीधे शाब्दिक स्ट्रिंग का उपयोग करके 9 बाइट्स दाढ़ी c:printf(...,"-\\|/"[i%4],...)

— जी। Sliepen

2

गणितज्ञ, १३३ बाइट्स

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

यह एक बार चलेगा, यह मानते हुए कि एक्स अपरिभाषित है। Clear@xइसे पुनः आरंभ करेगा।

क्रिया में बंधे 55 वर्ण: /

— केली लोवेर
स्रोत

क्या यह एक निश्चित अंतराल है या इसे बार-बार अनियमित किया जाएगा?

— टाइटस

यह यादृच्छिक है। UpdateInterval:> 75 तय किया गया होगा

— केली लोडर

1

@ टिट्स: मेरा मानना है कि UpdateInterval:>RandomReal@.75बार-बार कॉल करता है RandomReal, लेकिन UpdateInterval->RandomReal@.75इसे केवल एक बार ही कॉल करेगा।

— उमर

2

आर - 94 बाइट्स

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

वास्तव में अच्छा है sample(750,1) == sample(1:750,1)।

— उछलने वाली गेंद
स्रोत

2

HTML + JS (ES6), 16 + 87 = 103 बाइट्स

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

loading <a id=a>

स्निपेट का विस्तार करें

— darrylyeo
स्रोत

2

PHP, 66 79 बाइट्स

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

दुर्भाग्य से मुझे '0' प्रिंट करने के लिए $ i को असाइन करना पड़ा।
जैसे उपयोग करें:

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

संपादन: टाइटस के लिए धन्यवाद कि मुकुल कुमार के साथ वास्तव में क्या अनुमति है इसकी पुष्टि करने के लिए हम 3 बाइट्स को कम प्रतिबंधित सीमा के साथ बचा सकते हैं, लेकिन सभी 9 बाइट्स एक अप्रतिबंधित सीमा के साथ नहीं। यह इंगित करने के लिए भी धन्यवाद कि मैं साइकिल चरित्र को भूल गया और इसे करने के लिए एक सरल समाधान प्रदान किया।

— user59178
स्रोत

1

यादृच्छिक आवश्यकताएं यह है कि आप एक संभावना> 0 के साथ सभी 1ms से 750ms उत्पन्न करते हैं। मैं यह नहीं देख सकता कि अन्य मूल्य निषिद्ध हैं। rand(1,75e4)3 बाइट्स बचाता है; 1e6एक और बचा सकता है; और 9 बाइट्स को पूरी तरह से बचाने के लिए कोई पैरामीटर नहीं; और मुझे लगता है कि किसी भी नियम का उल्लंघन नहीं है। लेकिन आप इसके ","-\\|/"[$i%4],"बजाय : +16 वर्ण को भूल गए -।

— टाइटस

@ विटस usleep(rand(1,75e4))1 माइक्रोसेकंड और 750 मिलीसेकंड के बीच एक यादृच्छिक अंतराल उत्पन्न नहीं करेगा ? इसके अलावा, सवाल के अनुसार, अंतराल 1 और 750 के बीच होना चाहिए, समावेशी।

— इस्माईल मिगुएल

प्रश्न पर नवीनतम टिप्पणियाँ देखें: 1 to 75e4स्वीकार्य है।

— टाइटस

@ टिटस मैं उन बदलावों पर विचार करूंगा, लेकिन सवाल (निहितार्थ मिलीसेकंड देरी) से निहित के साथ जाने का फैसला किया। पूछने के लिए धन्यवाद कि क्या अनुमति थी!

— user59178

2

नूडल , नॉनकमेटिंग 40 बाइट्स

बस पुरानी चुनौतियों (जैसा कि नूडेल से पहले बनाई गई चुनौतियों में ) के माध्यम से वापस जा रहा है और नूडेल के साथ प्रतिस्पर्धा करने के लिए कि यह कहां कमजोर है।

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

यदि अंतिम आउटपुट से कोई फर्क नहीं पड़ता है, तो 2 बाइट बचा सकते हैं।

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

नूडेल कार्यक्रम के अंत में स्टैक के शीर्ष को स्क्रीन पर जोड़ता है ताकि जोड़कर€Ḃ इसे यह होने से रोकता है।

कोशिश करो:)

यह काम किस प्रकार करता है

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>

स्निपेट का विस्तार करें

— tkellehe
स्रोत

क्यों इतने सारे हैं ¤?

— क्रिकटी लिथोस

@KritiiLithos नूडल रिक्त स्थान को प्रिंट करने के लिए NOP के रूप में रिक्त स्थान का उपयोग करता है इसलिए ¤:)

— tkellehe

1

Btw, यह अच्छा है कि इसके लिए एक स्टैक स्निपेट है :)

— क्रिति लिथोस

स्निपेट कैसे काम करता है? क्या आयातित स्क्रिप्ट में आईडी के साथ तत्व पाया गया है noodle, फिर codeजावास्क्रिप्ट का अनुवाद करें ?

— कैरिजनेट

@ करसीनेट, हाँ। "पार्सर" जावास्क्रिप्ट फ़ंक्शन है noodelजो codeठीक से संभालता है। यह जावास्क्रिप्ट ऑब्जेक्ट्स का अनुवाद करता codeहै जो जावास्क्रिप्ट ऑब्जेक्ट्स होते हैं जो एक साथ जंजीर हो जाते हैं फिर निष्पादित होते हैं। ppcg.min.jsउचित बनाता एचटीएमएल वस्तुओं और क्या में पार्स किया गया है के उत्पादन में तब्दील हो एचटीएमएल प्रदर्शन बनाने के लिए वस्तुओं। हर टोकन को एक स्टेप ईवेंट ट्रिगर करके उनके माध्यम से निष्पादित किया जाता है जो स्क्रीन को अपडेट करने के लिए पंजीकृत है :) क्या वह मदद करता है?

— tkellehe

2

C 126 121 बाइट्स

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

Ungolfed संस्करण:

 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 @ मुकुल कुमार ने वहां की पंक्तियों के बीच नहीं पढ़ा, धन्यवाद! :)

— हाबिल टॉम
स्रोत

1

c [] यादृच्छिक नहीं है ... लेकिन साइकिल चला रहा है ....

— मुकुल कुमार

या, दूसरे शब्दों में, आप "\ / / -" से एक यादृच्छिक वर्ण लेने वाले नहीं हैं, तो आपको एक चक्र में / -, फिर -, फिर \ _, प्रदर्शित करना चाहिए।

— कैरिजिनेट

@MukulKumar @ Carcigenicate कोड को अपडेट किया है ताकि यह करे कि साइकिल के पात्रों के बारे में कल्पना क्या कहती है!

— हाबिल टॉम

1

MATLAB, 108 बाइट्स

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

— MattWH
स्रोत

1

ऑक्टेव, 122 120 119 108 बाइट्स

मैंने चुनौती को गलत बताया और 100 के पार होते ही 0 पर पुनः आरंभ होने वाले एक अनंत लोडर का निर्माण किया। इसे एक बार लोड करने के बाद ही बनाया गया:

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

परिसंचारी a, a=a([2:4,1])flawr का विचार था यहां । इसके अलावा, randमैटवे के लिए धन्यवाद के बाद कोष्ठक को छोड़ कर 2 बाइट्स को बचाया।

— स्टीवी ग्रिफिन
स्रोत

क्या यह होना चाहिए .749*rand()+.001? यह 751ms तक इंतजार कर सकता है। इसके अलावा आप ()ऑफ रैंड को छोड़ सकते हैं और 2 बाइट्स बचा सकते हैं।

— 16

1

फोर्सलैंग, 250 बाइट्स

नॉन-कंपेटिंग, भाषा सुविधाओं की आवश्यकता होती है जो प्रश्न को स्थगित करती हैं

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

मुझे जल्द ही स्ट्रिंग शाब्दिक पार्सिंग से संबंधित कुछ कीड़े को ठीक करना चाहिए।

— SuperJedi224
स्रोत

1

रैकेट 110 बाइट्स

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

परिक्षण:

(f)

आउटपुट:

(यह gif फ़ाइल वास्तविक की तुलना में धीमी प्रदर्शित कर रही है)

— rnso
स्रोत

जिफ़ में अंत में सामान के साथ क्या है?

— कैरिजनेट

यह स्क्रीन कैप्चर प्रोग्राम से एक कलाकृतियों के रूप में प्रतीत होता है।

— रंसो

1

१०y ५ रूबी

-32 मैनटवर्क के लिए धन्यवाद

साधारण

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}

— टॉम लज़ार
स्रोत

यह बताने के लिए कि आपके पास आउटपुट की एक ही पंक्ति है अधिलेखित करने के लिए, system'clear'यहाँ ओवरकिल है। इसके अलावा अलग चर i का उपयोग। ओह, और जहां संभव हो, वहां पूर्व-निर्धारित करें: 0.750-0.01→ 0.749(यह भी ध्यान दें कि आपके पास 0.01 में एक दशमलव स्थान की कमी है - 0.001 होना चाहिए)। जिसके परिणामस्वरूप 101.times{|c|$><<"\rloading #{'-\|/'[c%4]} #{c} %";sleep rand*0.749+0.001}बहुत के समान हो जाता है कोनोर ओ ब्रायन की रूबी जवाब में लोड हो रहा है ... हमेशा के लिए लेकिन अभी चुनौती है।

— १६

1

पायथन 3, 149 बाइट्स

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

लोड हो रहा है के समान ... हमेशा के लिए, लेकिन मुझे वहाँ से अपना उत्तर संपादित करना पड़ा।

— अजगर-B5
स्रोत

1

टीआई-बेसिक, 80 बाइट्स

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

यादृच्छिकता For(लूप से आती है (ई वैज्ञानिक ई टोकन है) और चूंकि टीआई-बेसिक की व्याख्या की जाती है, इसलिए स्वचालित रूप से कुछ ओवरहेड भी होता है। याद रखें कि TI-Basic में, लोअरकेस अक्षर और कुछ कम सामान्य ASCII प्रतीक दो बाइट्स हैं (इसलिए विशेष रूप से इस कार्यक्रम के लिए, l o a d i n g sub( \ | %दो-बाइट टोकन हैं

— Timtech
स्रोत

1

क्लोजर, 109 बाइट्स

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

0 से 100 तक की संख्या की एक सूची पर लूप्स, "\|/-"हमेशा के लिए दोहराने की एक अनंत सूची के साथ ज़िपित ।

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

— Carcigenicate
स्रोत

1

tcl, ११६

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

Http://www.tutorialspoint.com/execute_tcl_online.php?PID=0Bw_CjBb95KQMOXoybnVSOVJEU00 में खेलने योग्य

— sergiol
स्रोत

आपका आउटपुट बहुत कम है ...

— मुकुल कुमार

हम्म ,,, मेरा कोड गायब हो गया! ...

— सर्गिओल

मेरा मतलब है कि आपका आउटपुट इस प्रारूप में है "लोडिंग ... xx%" इसके बजाय यह "लोडिंग - xx%" जैसा होना चाहिए, जहां '-' प्रश्न में समझाया गया है।

— मुकुल कुमार

@ मुकुलकुमार: निश्चित।

— सर्गिओल

1

जावा 8, 130 बाइट्स

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

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

0

विजुअल बेसिक, 371 बाइट्स

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

विस्तारित:

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

— polyglotrealIknow
स्रोत

मुझे फर्जी लोडर बना दो

पैरामीटर:

सी ++

विजेता

MATL , 45 बाइट्स

व्याख्या

पॉवरशेल, 71 68 65 बाइट्स

पायथन 2, 119 113 112 बाइट्स

बैच, 185 बाइट्स

* <<> (स्टारफ़िश), 86 82 बाइट्स

पर्ल 6 , 67 बाइट्स

विस्तारित:

जावास्क्रिप्ट (ईएस 6), 128 118 116 115 112 110 109 बाइट्स

एफ #, 118 बाइट्स

PHP, 90 83 80 78 77 बाइट्स

ग्रूवी, 113 87 बाइट्स

Bash, 162 104 bytes

Ungolfed / Explained

C 112 103 बाइट्स

गणितज्ञ, १३३ बाइट्स

आर - 94 बाइट्स

HTML + JS (ES6), 16 + 87 = 103 बाइट्स

PHP, 66 79 बाइट्स

नूडल , नॉनकमेटिंग 40 बाइट्स

यह काम किस प्रकार करता है

C 126 121 बाइट्स

MATLAB, 108 बाइट्स

ऑक्टेव, 122 120 119 108 बाइट्स

फोर्सलैंग, 250 बाइट्स

रैकेट 110 बाइट्स

१०y ५ रूबी

पायथन 3, 149 बाइट्स

टीआई-बेसिक, 80 बाइट्स

क्लोजर, 109 बाइट्स

tcl, ११६

जावा 8, 130 बाइट्स

विजुअल बेसिक, 371 बाइट्स

विस्तारित: