आपकी चुनौती एक अनंत लोडिंग स्क्रीन बनाने की है, जो इस तरह दिखती है:

या, अधिक विशिष्ट होने के लिए:

कोई इनपुट न लें।
आउटपुट Loading..., एक अनुगामी स्थान के साथ, लेकिन कोई अनुगामी न्यूलाइन नहीं।
वर्ण के माध्यम से असीम चक्र |, /, -और \: हर 0.25 सेकंड, क्रम में अगला के साथ पिछले एक के ऊपर लिख। जब तक Loading...अपरिवर्तित रहे , आप केवल अंतिम वर्ण को अधिलेखित कर सकते हैं, या पूरी पंक्ति को हटा सकते हैं और पुनः लिख सकते हैं।

नियम

आउटपुट टेक्स्ट को बिल्कुल निर्दिष्ट रूप में देखना चाहिए। अनुगामी newlines / रिक्त स्थान स्वीकार्य हैं।
शुरू में आउटपुट दिखाने से पहले आपको 0.25 सेकंड तक इंतजार नहीं करना चाहिए - प्रोग्राम के चलते ही पहला फ्रेम प्रिंट होना चाहिए।
आपका कार्यक्रम अनिश्चित काल तक चलने में सक्षम होना चाहिए।उदाहरण के लिए, यदि आप फ़्रेम के लिए काउंटर का उपयोग करते हैं, तो काउंटर को कभी भी आपकी भाषा में अधिकतम से अधिक त्रुटि का कारण नहीं होना चाहिए।
यद्यपि प्रत्येक "फ्रेम" के बीच की प्रतीक्षा अवधि 0.25 सेकंड होनी चाहिए, जाहिर है यह कभी भी सटीक नहीं होगा - 10% या तो त्रुटि मार्जिन की अनुमति है।
आप एक फ़ंक्शन सबमिट कर सकते हैं, लेकिन इसे प्रिंट करना होगा stdout।
आप एक गैर-कंसोल (लेकिन अभी भी पाठ-आधारित) वातावरण में एक उत्तर प्रस्तुत कर सकते हैं, जब तक यह लोडिंग एनीमेशन का उत्पादन करने में सक्षम है।
यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान (बाइट्स में) जीतता है। स्टैंडर्ड कोड-गोल्फ लूपहोल्स लागू होते हैं।
यदि संभव हो, तो कृपया कार्रवाई में अपनी लोडिंग स्क्रीन का gif प्रदान करें।

उदाहरण

यहाँ C ++ कोड है जिसका उपयोग मैंने उदाहरण (ungolfed) बनाने के लिए किया था:

#include <iostream>
#include <string>
#include <thread>

using namespace std;

int main() {
    string cycle = "|/-\\";
    int i = 0;

    cout << "Loading... ";

    while (true) {
        // Print current character
        cout << cycle[i];

        // Sleep for 0.25 seconds
        this_thread::sleep_for(chrono::milliseconds(250));

        // Delete last character, then increase counter.
        cout << "\b";
        i = ++i % 4;
    }
}

सर्वश्रेष्ठ गोल्फर जीत सकते हैं!

— FlipTack
स्रोत

3

प्रारंभ में आउटपुट प्रदर्शित करने से पहले सबमिशन 0.25 सेकंड प्रतीक्षा कर सकता है?

— ETHproductions

2

नहीं, लेकिन उस उल्लेख के लिए धन्यवाद, मैं इसे नियमों में जोड़ दूंगा @ETHproductions

— FlipTack

क्या एक अनुगामी न्यूलाइन (एनिमेटिंग सिंबल के बाद) स्वीकार्य है?

— ताम्र

बेशक :) @ कोपर

— फ्लिपकार्ट

1

@BitByte का अर्थ है कि, सैद्धांतिक रूप से, आपके कार्यक्रम के अंदर कुछ भी त्रुटि का कारण नहीं बनेगा - जैसे कि एक काउंटर अतिप्रवाह या अधिकतम पुनरावृत्ति गहराई तक पहुंचना।

— फ्लिपकार्ट

76

HTML / CSS, 183 180 163 161 160 147 143 बाइट्स

a{display:inline-flex;overflow:hidden;width:1ch}c{animation:c 1s steps(4)infinite}@keyframes c{to{margin:0-4ch

<pre>Loading... <a><c>|/-\</pre>

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

संपादित करें: @betseg के लिए 3 बाइट्स सहेजे गए। 17 बाइट्स @manatwork की बदौलत सहेजे गए। @Daniel को 1 बाइट धन्यवाद दिया। सहेजे गए 13 बाइट्स @Ismael Miguel की बदौलत। 4 बाइट्स @Fez Vrasta की बदौलत सहेजे गए।

— नील
स्रोत

4

मेटा के अनुसार, सीएसएस + HTML सवालों के जवाब देने के लिए ठीक है। इसके अलावा मैंने चुनौती विवरण में इसकी अनुमति दी। तो यह जवाब पूरी तरह से मान्य है :)

— 21

5

HTML + CSS TC है, इसलिए मैं यह नहीं देखता कि यह गैर-प्रतिस्पर्धा क्यों हो सकती है

— TuxCrafting

1

@ T @xCräftîñg CSS निश्चित रूप से पूर्ण नहीं हो रही है क्योंकि आप इसमें हल करने की समस्या को हल कर सकते हैं (यदि कोई अनंत एनीमेशन नहीं है, तो यह रुक जाता है)। मुझे लगता है कि HTML के लिए भी यही लागू होता है (यदि आप JS को शामिल नहीं करते हैं)।

— एरियर

4

@Artyer stackoverflow.com/a/5239256/3273184 कुछ विचार करने लायक है।

— मामा फन रोल

4

@MamaFunRoll उस पोस्ट पर एक टिप्पणी का उल्लेख है जो वास्तव में इसे साबित नहीं करता है टीसी क्योंकि यह उपयोगकर्ता के हस्तक्षेप के बिना लूप नहीं कर सकता है। हालाँकि, यह इस विशेष चुनौती को हल कर सकता है, इसलिए मुझे इस उत्तर के साथ कोई समस्या नहीं दिखती है।

— ETHproductions

57

विम, ४३ , ४१ बाइट्स

qqSLoading... |<esc>:sl250m
r/@:r-@:r\@:@qq@q

@Udioica की बदौलत दो बाइट बच गईं!

यहाँ (थोड़ा पुराना) इसका एनीमेशन वास्तविक समय में हो रहा है!

और यहाँ एक स्पष्टीकरण है:

qq                              " Start recording into register 'q'
  SLoading... |<esc>            " Replace all of the text in the buffer with 'Loading... |'
                    :sl250m     " Sleep for 250 ms
r/                              " Replace the bar with a slash
  @:                            " Re-run the last ex command (sleeping)
    r-                          " Replace the slash with a dash
      @:                        " Re-run the last ex command (sleeping)
        r\                      " Replace the dash with a backslash
          @:                    " Re-run the last ex command (sleeping)
            @q                  " Run macro 'q' (the one we're recording)
              q                 " Stop recording
               @q               " Call macro 'q', which will run forever because it's recursive

— DJMcMayhem
स्रोत

1

बस जिज्ञासा: क्या यह उल्लंघन करता है "आपका कार्यक्रम अनिश्चित काल तक चलने में सक्षम होना चाहिए"? यह अंततः एक ढेर अतिप्रवाह तक पहुँच सकता है? :)

— डैन ओक

4

@dahnoak खैर, जाहिर है कि मैं असीम रूप से इसका परीक्षण नहीं कर सकता, लेकिन यह किसी भी अतिरिक्त मेमोरी को आवंटित नहीं करता है, इसलिए मैं किसी भी कारण से इसे अनिश्चित काल तक काम नहीं कर सकता।

— DJMcMayhem

1

आप स्विच करते हैं iकरने के लिए Sऔर मैक्रो में किसी एक यह ले जाते हैं, आप को छोड़ सकते हैं r|।

— ०४:४६ पर ०१-१९

2

@dahnoak कोई कारण नहीं है कि vi इंजन पूंछ पुनरावृत्ति को नोटिस नहीं कर सकता है। और पुनरावृत्ति के कुछ कार्यान्वयन स्वाभाविक रूप से करते हैं (कल्पना करें कि क्या कमांड के वेक्टर से टू-ए-एक्जिक्यूट किया गया है, और एक वर्तमान निष्पादन स्थान है। फिर @qरजिस्टर-स्क्रिप्ट की सामग्री को वर्तमान-स्थान में सम्मिलित करेगा q। कोई स्टैक की आवश्यकता नहीं है, और नहीं। स्मृति को तब तक आबंटित किया जाता है जब तक कि उसके @q भीतर चलने की आज्ञा न हो q।)

— याकूब

लगभग हर बार जब आप एक चुनौती का जवाब देते हैं, तो मैं कुछ नया सीखता हूं (इस मामले में, @:और :sl), इसलिए धन्यवाद और उन्हें आते रहना :)

— ईसाई रोंडेउ

37

HTML + JS (ES6), 20 + 51 50 = 70 बाइट्स

setInterval(_=>a.innerHTML='|/-\\'[i=-~i%4],i=250)

Loading... <a id=a>-

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

-1 बाइट (ज़ाचरी टी)

मेरे 132 बाइट HTML / CSS उत्तर को भी देखें।

— darrylyeo
स्रोत

अतिप्रवाह हो सकता है i?

— ज़ाचरी २ '

हाँ, यह अंततः होगा। तय है कि!

— darrylyeo

1

क्या आप एक बाइट के i++,i%=4साथ बदल सकते हैं i=-~i%4?

— ज़ाचारी

2

@Xufox <pre>केवल सुनिश्चित मोनोपॉज फ़ॉन्ट का उपयोग किया गया था ताकि chइकाइयाँ काम करें। उपयोग किए गए फ़ॉन्ट परिवार के बारे में नियमों में कुछ भी उल्लेख नहीं है। ;)

— darrylyeo

1

अगर मैं गलत नहीं हूं, तो जेएस द्वारा मुद्रित पहला चरित्र स्ट्रिंग में अंतिम एक होगा; तो आप के -बजाय के साथ init चाहिए /। या के साथ init |और पाश के माध्यम से '-\\|/'। हालांकि अच्छा वेतन वृद्धि।

— टाइटस

21

विंडोज बैच, 121 114 84 80 79 78 बाइट्स

बस इसे मजे के लिए बाहर फेंक रहे हैं।

for %%b in (/ - \ ^|)do (cls
@echo Loading... %%b
ping 1.1 -n 1 -w 250>nul)
%0

मैं पाइप असाइन नहीं कर पा रहा था (| सरणी में ) , इसलिए मुझे इसे दूसरे असाइनमेंट के साथ मैन्युअल रूप से जोड़ना पड़ा।देरी के साथ किया जाता है PING, जो सटीक नहीं हो सकता है ।

आउटपुट:

संपादित करें:

7 बाइट बचाने के लिए रोमन ग्रैफ को धन्यवाद!
30 बाइट बचाने के लिए नील को धन्यवाद! मैंने इसे नए सिरे से बाइट्स को बचाने के लिए थोड़ा और बढ़ा दिया है।
4 बाइट्स बचाने के लिए फ़ाइरफ़ॉक्स के लिए धन्यवाद!
2 बाइट्स बचाने के लिए YourDeathIsComing को धन्यवाद!

— user6616962
स्रोत

3

आप हटा सकते हैं @echo offऔर @हर setया echoकमांड के सामने रख सकते हैं

— रोमन ग्रैफ

1

आपको सरणी, in (/ - \ ^|)कार्यों की आवश्यकता नहीं है । इसके अलावा,% 0 लूप से छोटा तरीका है goto।

— नील

2

आपको आईपी पते "1.1" (-4 बाइट्स) का उपयोग करने में सक्षम होना चाहिए, क्योंकि अधिकांश प्लेटफ़ॉर्म आपके लिए ऑटो-एक्सपेंशन को 1.0.0.1 कर देंगे।

— phyrfox

1

आप सामने की जगह को हटाकर 1 बाइट बचा सकते हैं >nul।

— YourDeathIsComing

1

मेरा मतलब इससे पहले था, उसके बाद नहीं।

— YourDeathIsComing

20

नोड, 72 70 बाइट्स

f=i=>console.log('\x1BcLoading... '+'|/-\\'[setTimeout(f,250,i=-~i%4),i])

\x1Bसही बाइट गिनती प्राप्त करने के लिए शाब्दिक भागने चरित्र के साथ बदलें । f()एनीमेशन शुरू करने के लिए कॉल करें। यहां बताया गया है कि यह मेरे कंप्यूटर पर ConEmu टर्मिनल एमुलेटर में कैसा दिखता है:

— ETHproductions
स्रोत

उपयोग करने का प्रयास करें \033c( \033इसके वास्तविक चार प्रतिनिधित्व के साथ बदलें )। यह उतना अच्छा नहीं लगता है, लेकिन यह आपको कुछ बाइट्स बचाता है।

— मामा फन रोल

iअतिप्रवाह नहीं होगा ?

— ज़ाचारी

12

@ZacharyT यह 71 मिलियन वर्षों के बाद होगा, लेकिन मैं यह तय कर सकता हूं कि यदि आवश्यक हो

— ETHproductions

3

"आपका कार्यक्रम अनिश्चित काल तक चलने में सक्षम होना चाहिए। उदाहरण के लिए, यदि आप फ़्रेम के लिए काउंटर का उपयोग करते हैं, तो काउंटर को कभी भी आपकी भाषा में अधिकतम से अधिक त्रुटि का कारण नहीं होना चाहिए।", हाँ, यह आवश्यक है।

— Zacharý

3

@ फ़्लोरेंट लेकिन फिर यह नोड पर नहीं चलेगा ;-)

— ETHproductions

14

कोटलिन, 67 66 बाइट्स

while(1>0)"|/-\\".map{print("\rLoading... $it");Thread.sleep(250)}

\rबहुत स्पष्ट रूप से आत्म व्याख्यात्मक, लाइन को साफ करने और कोटलिन के भयानक स्ट्रिंग प्रक्षेप का लाभ उठाने के लिए।

संपादित करें: बदलकर @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu में सहेजा गया 1 बाइट धन्यवाद while(true)करने के लिएwhile(1>0)

— टायलर मैकडोनेल
स्रोत

1

आप (-1) के while(1>0)बजाय का उपयोग करके एक बाइट बचा सकते हैं while(true)और संभवत: अपने जवाब ( fun a(){<code>}, +9) में वास्तविक फ़ंक्शन सिंटैक्स को शामिल करना चाहिए । यदि आप थोड़ा धोखा देना चाहते हैं, तो आप एक फ़ंक्शन को एक चर ( val a={<code>}, +8) के रूप में उपयोग कर सकते हैं ।

— एफ जॉर्ज

2

@ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu 'पूर्ण कार्यक्रम' मोड स्वीकार्य नहीं है? इसे .ktsक्लास या फ़ंक्शन परिभाषाओं के बिना कोटलिन स्क्रिप्ट के रूप में चलाया जा सकता है । इसके अलावा, महान कॉल के साथ while(1>0)!

— टायलर मैकडोनेल

3

लेकिन क्या होगा अगर, एक दिन, 0 1 से अधिक हो जाए ???? : P

— FlipTack

कोटलिन स्क्रिप्ट का उपयोग करने का महान विचार। : @ Flp.Tkc आपकी टिप्पणी मुझे इस की याद दिला दी codegolf.stackexchange.com/a/101131/62024 । अभी भी कंपकंपी है कि यह संभव है।

— एफ। जॉर्ज

@TylerMacDonell सच में? मुझे नहीं पता था कि आप एक स्क्रिप्ट के रूप में कोटलिन को सीधे चला सकते हैं। जानकारी के लिए धन्यवाद।

— TheNumberOne

14

विम, 35 बाइट्स

iLoading... \-/|<Esc>qqdb:sl250m<CR>p@qq@q

उबाऊ संस्करण। यहां एक गैर-अनुपालन समाधान है जो बेहतर है:

विम (1 सेकंड की नींद), 27 बाइट्स

idbgsp@@<C-U>Loading... \-/|<Esc>@.

gsन केवल उपयोग करना बहुत कम है, लेकिन आपको एंटर को हिट करने की आवश्यकता नहीं है। इसका मतलब है कि मैक्रो इन-लाइन फिट बैठता है, और मैं बाइट्स को स्विच करके बचा सकता हूं @.। (चूंकि पुनरावर्ती कॉल कभी भी नहीं चल सकता है, मैं जो चाहूं टाइप कर सकता हूं।)

— udioica
स्रोत

इस उत्तर के लिए धन्यवाद! मैंने सीखा gs, @.और @@भीतर @.अभी भी मेरे सिर पर चोट लगी है!

— क्रिश्चियन रोंडेउ

14

पायथ, 31 बाइट्स

Wm,p+"\rLoading... "d.d.25"|/-\

यहाँ दुभाषिया ।

जीआईएफ लोड हो रहा है

व्याख्या

Wm,p+"\rLoading... "d.d.25"|/-\
    +"\rLoading... "d              Concatenate the string "\rLoading... " and the variable d
   p                               Print the result without a newline
                     .d.25         Sleep for 0.25 seconds
  ,                                Form a two-element list with the results of the two statements above. This is only needed to execute both statements in a single lambda function.
 m                        "|/-\    Map the above statement over the characters in the string "|/-\", setting the variable d to the character for each iteration
W                                  While the result of the map statement is true, do nothing

— insert_name_here
स्रोत

13

पॉवर्सशेल (v4), 57 56 54 53 58 57 बाइट्स

वापस Bytecount मैं के साथ शुरू कर दिया!

for(){cls;"Loading... "+"|/-\"[($a=++$a%4)];sleep -m 250}

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

एक बाइट को बचाने के लिए लूप में $ + ++ ले गए, (नहीं ;)

फिर इसे सरणी अनुक्रमणिका में स्थानांतरित कर दिया, एक और 2 बाइट बचाने के लिए, रोमन को धन्यवाद कि बाहर इशारा करने के लिए।

लूप के लिए ;क्लियर स्क्रीन ( cls) भाग को स्थानांतरित करके 1 और बाइट ( ) को बचाया ।

समस्या के अनंत पहलू के लिए टिम्मी द्वारा इंगित और तय किया गया, केवल +5 बाइट्स की आवश्यकता है, में बदल $a++%4गया($a=++$a%4) तो यह 3 से ऊपर जाना कभी नहीं होगा।

लूप के लिए पूरी तरह से खाली छोड़ कर एक और बाइट को बचाया, यह इंगित करने के लिए 'जो कुछ भी' के लिए धन्यवाद कि यह वास्तव में पॉवर्स वर्जन 4 में संभव है!

इस उत्तर के ~~अंतिम (अंतिम?)~~ संस्करण के लिए नया अपडेट किया गया gif

~~for(;;cls){"Loading... "+"|/-\"[($a=++$a%4)];sleep -m 250}~~

~~for(;;cls){"Loading... "+"|/-\"[$a++%4];sleep -m 250}~~

~~for(;;){"Loading... "+"|/-\"[$a++%4];sleep -m 250;cls}~~

~~for(;;$a++){"Loading... "+"|/-\"[$a%4];sleep -m 250;cls}~~

~~for(;;){$a++;"Loading... "+"|/-\"[$a%4];sleep -m 250;cls}~~

— colsw
स्रोत

2

for(;;){"Loading... "+"|/-\"[$a++%4];sleep -m 250;cls}( $a++अंतिम उपयोग के लिए कदम $a)

— रोमन ग्रैफ

हमेशा कुछ भूल - उस के लिए धन्यवाद!

— कोलों

2

मैं पॉवरशेल में बहुत माहिर नहीं हूं, लेकिन जब मैंने विंडोज बैच प्रविष्टि देखी, तो मुझे लगा कि "क्या पॉवरशेल इसे हरा सकता है?"। और यहाँ यह है!

— जैकब जानकोव्स्की

1

कम से कम ps v4 पर आपको हालत के लिए पूरी तरह से खाली रखकर एक अन्य बाइट को सक्षम करना चाहिए:for(){cls;"Loading... "+"|/-\"[($a=++$a%4)];sleep -m 250}

— जो कुछ भी है

1

आपका स्वागत है। यह वास्तव में संस्करण 2 + के लिए काम करने लगता है, अभी भी पहले की जाँच करने के आलसी था;)

— जो कुछ भी

11

पायथ - 36 35 बाइट्स

#+"\033cLoading... "@"\|/-"~hZ.d.25

ऑनलाइन काम नहीं करता है, जाहिर है।

— Maltysen
स्रोत

क्या आपके पास कार्रवाई में इसका एक gif है? इसके अलावा, क्या कोई काउंटर है जो अतिप्रवाह कर सकता है?

— फ्लिपटैक

@ Flp.Tkc केवल एक काउंटर है Zजो एक अजगर पूर्णांक है, जो अतिप्रवाह नहीं करता है। मैं एक GIF बनाने की कोशिश कर रहा था, लेकिन काम करने के लिए नहीं मिला। यदि आप जानते हैं कि एक कैसे बनाया जाए, तो आप इसे pyth दुभाषिए के साथ github.com/isaacg1/pyth

— Maltysen

4

यदि पूर्णांक अतिप्रवाह नहीं करता है, तो यह संभवतः सभी मेमोरी को भरने तक बढ़ेगा, जो कि अधिकांश 32-बिट सिस्टम पर कम से कम 10 32 वर्षों के बाद विफल हो जाएगा। निश्चित रूप से, ब्रह्मांड की गर्मी मृत्यु पहले होगी, लेकिन फिर भी ...

— jjrv

11

मतलाब, 78 75 बाइट्स

a='\|/-';while 1;clc;disp(['Loading... ',a(1)]);a=a([2:4,1]);pause(1/4);end

— flawr
स्रोत

11

HTML / CSS, 23 + 109 = 132 बाइट्स

नील के जवाब में सुधार हुआ ।

pre{display:flex}a{overflow:hidden;animation:a 1s steps(4)infinite;width:1ch}@keyframes a{to{text-indent:-4ch

<pre>Loading... <a>|/-\

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

— darrylyeo
स्रोत

9

गणितज्ञ, atic४ ६ By बाइट्स

ListAnimate["Loading... "<>#&/@{"|","/","-","\\"},AnimationRate->4]

@Dahnoak की बदौलत 7 बाइट्स दूर

— एक सीमन्स
स्रोत

ListAnimate["Loading... "<>#&/@Characters@"|/-\\",AnimationRate->4]

— डैन ओक

1

@dahnoak चीयर्स! मुझे नहीं पता था कि ListAnimate एक चीज थी। यह शर्म की बात है कि <>फ्लैट लिस्टेबल नहीं है अन्यथा 4 और बाइट्स का मुंडन किया जा सकता है!

— एक सीमन्स

बस मज़े के लिए:Dynamic["Loading... "<>{"|","/","-","\\"}[[1+Round[4Now@"Second"]~Mod~4]],UpdateInterval->.25]

— shrx

9

सी #, 170 133 बाइट्स

void X(){Console.Write("Loading...  ");for(;;){foreach(var c in "|/-\\"){Console.Write("\b"+c);System.Threading.Thread.Sleep(250);}}}

रोमन ग्रेफ और रज़ानगुल का बड़ा धन्यवाद, जिन्होंने मुझे 37 बाइट्स से बचाया। (विशेष रूप से raznagul, जिन्होंने बताया कि मेरा मूल समाधान वैसे भी अमान्य था। मैं थोड़े से वहां से चूक गया, लेकिन यह अब तय हो गया है और आवश्यकताओं को पूरा करना चाहिए :)

पीट आर्डेन के मौजूदा सी # उत्तर के समान लेकिन कुछ सुधारों के साथ

जैसे "" (;)) "के बजाय" जबकि (सत्य) "", स्ट्रिंग के बजाय चार

मैंने उनके सुझाव पर अपने सुझाव दिए होंगे, लेकिन वास्तव में मेरे पास ऐसा करने के लिए पर्याप्त प्रतिष्ठा नहीं है।

Ungolfed:

static void X()
{
    Console.Write("Loading...  ");
    for (;;)
    {
        foreach (var c in "|/-\\")
        {
            Console.Write("\b" + c);
            System.Threading.Thread.Sleep(250);
        }
    }
}

— Snowfire
स्रोत

2

पहले को क्यों न हटाएं Console.Write("\b");और दूसरे को बदलें Console.Write("\b"+a);?

— रोमन ग्रैफ

एक क्रिया को परिभाषित करना अनावश्यक है और लंबे समय तक एक लूप का उपयोग करना है foreach(var a in"|/-\\")और वर्तमान में आपके पास इस कोड को जोड़ना है क्योंकि शरीर आपको 20 ~ बाइट्स बचाएगा।

— रज़नागुल

इसके अलावा, कार्य आवश्यक आउटपुट का निर्माण करना है। जो फिलहाल नहीं है।

— raznagul

अब यही होना चाहिए, मैं भूल गया '|' और "लोड हो रहा है ..." के बाद पीछे की जगह।

— स्नोफायर

आपके अनगुल्ड संस्करण में (क्योंकि यह गोल्फ संस्करण से मेल नहीं खाता है), आप पहले को हटा सकते हैं Console.Write()और Console.Write($"Loading... {c}\r")दूसरे के बजाय सिर्फ एक का उपयोग कर सकते हैं ।

— दूध

9

आगे, 72, 73 बाइट्स

संपादित करें :

Gforth-only संस्करण, 69 बाइट्स जोड़ा गया (धन्यवाद @ninjalj!)
"लोड हो रहा है ..." (Thx @Roman ग्रैफ़!), +1 बाइट के बाद गायब व्हाट्सएप
नियमों को अधिक सटीक रूप से मिलान करने के लिए अद्यतन (उसी बाइट गणना में)

golfed

: L '| '/ '- '\ begin .\" \rLoading... " 3 roll dup emit 250 ms again ; L

Gforth संस्करण

GNU फोर्थ-केवल संस्करण को 69 बाइट्स तक नीचे लाया जा सकता है:

'| '/ '- '\ [begin] .\" \rLoading... " 3 roll dup emit 250 ms [again]

स्क्रीनकास्ट

इसे ऑनलाइन आज़माएं!

— टसेपेल्लिन
स्रोत

1

चूँकि आप gforth का उपयोग कर रहे हैं, यदि आप अन्य फोर्थ के लिए पोर्टेबिलिटी की परवाह नहीं करते हैं, तो आप एक शब्द परिभाषा का उपयोग कर सकते हैं [begin]और [again]बाहर कर सकते हैं ।

— नवजाल

9

पायथन 2, 81 79 78 77 बाइट्स

import time
i=1
while 1:print'\rLoading...','\|/-'[i%4],;i+=1;time.sleep(.25)

एक सरल उपाय का उपयोग करके सोता है time।

मैं \rलाइन की शुरुआत में वापस जाने के लिए (ए कैरिज रिटर्न) का उपयोग करता हूं और फिर लाइन को ओवरराइट करते हुए संदेश को प्रिंट करता हूं ।

मैं i=1दोहरे बचने से बचने के लिए शुरुआत करता हूं \(यह '\|/-'इसके बजाय है '|/-\\')।

अतीत में, मैं कोष्ठकों से बचने -~iका मतलब था i + 1। ( इन -2 बाइट्स के लिए @ Flp.Tkc को धन्यवाद !) (यह i=(i+1)%4बनाम था i=-~i%4)

अब, मैं सिर्फ काउंटर को हमेशा के लिए बढ़ने दे रहा हूं, क्योंकि तकनीकी रूप से पायथन intओवरफ्लो नहीं कर सकता है। @Zachary टी के लिए धन्यवाद कि बाहर और एक बाइट को बचाने के लिए!
यह केवल एक मशीन पर रुकता है क्योंकि मशीन मेमोरी से बाहर निकलती है, लेकिन यह एक पीढ़ी के लिए 4GB मेमोरी के साथ 9.7 पीढ़ी लेता है int।

@ बाइट के लिए -1 बाइट के लिए धन्यवाद जहां print a,bप्रिंट aऔर bस्पेस अलग हो गए, इसलिए मुझे अपने स्पेस की जरूरत नहीं है।

यह विंडोज पर काम कर रहा है:

मैंने इसे लिनक्स वीएम पर भी परीक्षण किया। मैं इसे एक पर परीक्षण नहीं कर सकता MAC।

— Artyer
स्रोत

1

अगर मुझे सही से याद है, तो आप i=-~i%4

— पैरेंस के

2

बाइट [i],;i=-~i%4को [i%4],;i+=1बचाने के साथ प्रतिस्थापित नहीं करेगा क्योंकि यह पायथन के लिए अधिकतम से अधिक नहीं है, केवल अधिकतम मेमोरी?

— 22

9

मुझे आपको Administrator... के रूप में लॉग इन करने के लिए डाउनवोट करना चाहिए ...

— नील

5

@ नई पूरी तरह से ईमानदार होने के लिए, मैंने अभी पायथन फाइल को एडमिनिस्ट्रेटर में रखा है और इसे वहां से चलाया है क्योंकि अन्य अकाउंट के नाम असली नाम (पर्सनल पीसी) हैं।

— 22

2

मैं @ZacharyT के सुझाव को तकनीकी रूप से अजगर के पूर्णांक के रूप में असीम रूप से बड़ा होने की अनुमति दे सकता हूं, जब तक कि कंप्यूटर के पास उन्हें रखने के लिए मेमोरी हो

— FlipTack

7

MATL , 36 बाइट्स

1 बाइट को स्ट्रिंग को स्थानांतरित करने के @ दोष के विचार का उपयोग करके हटाया गया

'\-/|'`Xx1YS'Loading... 'y1)hD.25Y.T

यहाँ ऑफ़लाइन कंपाइलर से गिफ़ रिकॉर्डिंग है:

या इसे MATL ऑनलाइन पर आज़माएं! यदि यह प्रारंभ में नहीं चलता है, तो पृष्ठ को फिर से ताज़ा करें और "रन" फिर से दबाएं।

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

'\-/|'           % Push this string
`                % Do...while
  Xx             %   Clear screen
  1YS            %   Circularly shift thr string 1 step to the right
  'Loading... '  %   Push this string
  y              %   Duplicate the string of shifting symbols
  1)             %   Get the first character
  hD             %   Concatenate the two strings and display
  .25Y.          %   Pause for 0.25 seconds
  T              %   Push "true". This is used as loop condition, to it
                 %   generates an infinite loop
                 % End loop implicitly

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

हे लुइस। हमेशा की तरह MATL के साथ किया। यहाँ परिपत्र सूची की थोड़ी भिन्नता है। और प्रदर्शित करें। क्या आपको लगता है कि आप इससे भी छोटे समाधान में अनुवाद कर सकते हैं:a='\|/-';k=1; fprintf('Loading... -') while 1 k=mod(k,4)+1; fprintf('\b\b%c\n',a(k)); pause(.25); end

— होकी

@ होकी विचार के लिए धन्यवाद। वास्तव में मेरे पास शुरू में एक काउंटर काउंटर 4 था, लेकिन यह थोड़ा लंबा था (बिना प्रारंभिक ठहराव की आवश्यकता के कारण मैंने एक बाइट प्राप्त की)। इसके अलावा, मुझे लगता है कि स्पष्ट स्क्रीन और सामान्य डिस्प्ले fprintfबैकस्पेस के मुकाबले कम है

— लुइस मेंडो

7

दिल्लोग एपीएल, 50 बाइट्स

यह केवल विंडोज संस्करण में काम करता है, क्योंकि अन्यथा ⎕SMविंडो को तब तक नहीं दिखाया जाएगा जब तक ⎕SRकि कॉल न किया जाए ।

{⎕SM←1 1,⍨⊂⊃⍵⌽'Loading... '∘,¨'|/-\'⋄∇4|⍵+⌈⎕DL÷4}1

स्पष्टीकरण:

{... }1: फ़ंक्शन को शुरुआत से चलाएं⍵=1
Loading... '∘,¨'|/-\': चार संभावित आउटपुट उत्पन्न करते हैं
⊂⊃⍵⌽: पहले तत्व को लगाने के लिए सूची को घुमाएं, पहले तत्व को लें, और इसे संलग्न करें
⎕SM←1 1,⍨: ⎕SMखिड़की के ऊपरी-बाएँ कोने में स्ट्रिंग रखें ।
⎕DL÷4: एक सेकंड का 1 / 4th इंतजार करें
4|⍵+⌈: परिणामी मूल्य को गोल करें (प्रतीक्षा में बिताए गए सेकंड, इसलिए यह हमेशा 1 होता है), इसे ⍵( इसे बढ़ाकर) जोड़ें , और mod-4 ले लें (अंततः इसे अतिप्रवाह से रोकने के लिए)।
∇: फ़ंक्शन को फिर से नए के साथ चलाएं ⍵।

— मारीनस
स्रोत

किसी तरह मुझे पता था कि कोई इस चुनौती के लिए Dyalog (/ APL) :)

— YoYoYonnY

7

सी #, 187 बाइट्स

golfed:

void L(){Console.Write("Loading...");Action<string>l=(a)=>{Console.SetCursorPosition(11,0);System.Threading.Thread.Sleep(250);Console.Write(a);};while(true){l("|");l("/");l("-");l("\\");}

Ungolfed:

public void L()
{
  Console.Write("Loading...");
  Action<string> l = (a) =>
  {
    Console.SetCursorPosition(11, 0);
    System.Threading.Thread.Sleep(250);
    Console.Write(a);
  };
  while (true)
  {
    l("|");
    l("/");
    l("-");
    l("\\");
  }
}

फिर भी इसके लोड होने का इंतजार ...

— पीट आर्डेन
स्रोत

फिर भी "\" प्रदर्शित करने के लिए यह इंतजार कर रहा है ...

— 13

@manatwork ओह बकवास, आलसी कॉपी और चिपकाना। इसे ठीक करूँगा जब मैं जल्द ही अपनी डेस्क पर वापस आ

— पीट आर्डेन

मेरी टिप्पणी के कारण आपके समाधान को लंबे समय तक देखने के लिए क्षमा करें। क्या आप इसे 186 पर वापस लाने के 1>0बजाय उपयोग नहीं कर सकते true?

— मैनटवर्क

@ErikGolfer エリ fer fer fer fer fer ー based based, C # के बारे में कोई विचार नहीं है, लेकिन इस तथ्य के आधार पर कि भाषा जावा की एक प्रति है और जाहिरा तौर पर यह पुष्टि नहीं की जा सकती है कि यह बूल के लिए अंतर नहीं डाल सकता है , मैंने सोचा कि यह काम नहीं करेगा। (BTW, अगर वह काम करता है, शायद l()हालत के रूप में पहली कॉल का उपयोग करने से भी काम

— चलेगा

2

@ मैनटवर्क ठीक है, ऐसा लगता है कि सी # अजेय है।

— निकोलग्राफ

7

स्नैप !, 8 ब्लॉक

स्नैप के 8 ब्लॉक!

यह बहुत पहले एल्गोरिदम में से एक था जिसे मैंने कभी Apple पर देखा था] [ई

— wyldstallyns
स्रोत

1

हमें अपना

— अप्लेसॉफ्ट

1

मैं ख़ुशी से हाइपरकार्ड में ये करूँगा।

— wyldstallyns

6

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

:i=@C"Loading... "o"|/-\\".iHo14%w.i1+4,

मैं सहित चीजों का एक गुच्छा करने के लिए भूल गया w। ओह अच्छा।

व्याख्या

:i=@C"Loading... "o"|/-\\".iHo14%w.i1+4,
:i=                                       set `i` to the TOS
   @C                                     clear the screen
     "Loading... "o                       output that string
                   "|/-\\"                push that string
                          .i              get `i`
                            H             get the `i`th character of that string
                             o            and output it
                              14%         push 0.25 (1/4)
                                 w        wait that long
                                  .i      get `i`
                                    1+    increment
                                      4,  mod 4
                                          this wraps around the beginning of the program,
                                          setting i to the said value

— कोनोर ओ ब्रायन
स्रोत

6

बैश, 98 69 बाइट्स

while s='\|/-';do
printf "\rLoading... ${s:i=++i%4:1}"
sleep .25
done

कई बाइट के लिए बहुत से लोगों के लिए धन्यवाद बंद गोल्फ!

— जाकारी
स्रोत

इसके अलावा, यदि आप सिंगल कोट्स का उपयोग करते हैं तो आपको बैकस्लैश से बचना नहीं है और इसके लिए तर्क को echo -e -nजोड़ दिया जा सकता हैecho -en

— इवान चेन

इको लाइन को बदलकर आप 2 लाइनों और 13 बाइट्स को बचा सकते हैं:echo -en "\rLoading... ${s:i=(i+1)%4:1}"

— Ipor Sircer

echo -en→ printf; स्थिति बनाने के लिए असाइनमेंट बनाएं while।

— मैनटवर्क

मैनटवर्क की तरह प्रिंटफ का उपयोग करें, प्रतिस्थापन को सरल करें, और इसे सीधे whileस्थिति में डालें while printf "\rLoading... ${s:i++%4:1}";do:। 67 बाइट्स

— डॉमिनिक आर

यह डोमिनिक आर काम नहीं करेगा, यह अंततः अतिप्रवाह होगा।

— Zacharý

6

पर्ल 6 , 72 61 बाइट्स

Supply.interval(1/4).tap: {print "\rLoading... ",<| / - \ >[$/++];$/%=4}

loop {print "\rLoading... ",<| / - \ >[$/++];$/%=4;sleep 1/4}

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

6

> <> , 55 + 4 = 59 बाइट्स

"...gnidaoL"v
l?!voc1. ^:<>
<v<>'\|/-'>^v
^<^<<<8{<<^o<

पासिंग होनी चाहिए -t .01दुभाषिया के लिए अतिरिक्त तर्क के रूप में , यह बाइट काउंट में +4 है।

यह क्या करता है चार पात्रों को ढेर पर मुद्रित करने के लिए डाल रहा है, शीर्ष एक को हटाए बिना इसे प्रिंट करना और एक स्थिति से ढेर को स्थानांतरित करना। फिर यह प्रिंट करता है\b (बैकस्पेस, कैरेक्टर x08) और लूप को रीस्टार्ट करता है।

टाइमिंग इंटरप्रेटर को दिए गए तर्क से हासिल होती है, जो प्रत्येक निर्देश को निष्पादित करने से पहले 0.01 सेकंड इंतजार करने के लिए मजबूर करता है। एक आउटपुट और अगले एक के बीच 23 निर्देश हैं (उनमें से ज्यादातर बस निर्देश कक्ष को अगले सेल में ले जाते हैं), इसलिए यह 0.23 सेकंड तक इंतजार करेगा और निर्देशों को निष्पादित करने के लिए आवश्यक समय होगा, जो अनुरोधित 0.25s में समस्या के बिना फिट बैठता है 10% त्रुटि के साथ।

आप इसे ऑनलाइन आज़मा सकते हैं , लेकिन वह दुभाषिया बैकस्पेस चरित्र को नहीं पहचानता है, इसलिए आउटपुट थोड़ा अजीब होगा।

— सिंह
स्रोत

आम तौर पर झंडे -nको 1 बाइट के रूप में स्कोर किया जाता है, इसलिए मुझे लगता है कि आप तर्क को स्कोर कर सकते हैं t, .01जो कि 4 बाइट्स है। 10% नियम btw का अच्छा उपयोग :)

— FlipTack

@ Flp.Tkc धन्यवाद! मुझे यकीन नहीं था कि तर्क के लिए बाइट्स कैसे गिना जाए, मुझे इस तरह पसंद है :)

— लियो

@Leo - क्या 0.01 का उपयोग करने का एक कारण है और कम निर्देशों के साथ एक बड़ा टिक नहीं है? मैंने अपना संस्करण जोड़ा है जो 8 निर्देशों के लूप और 0.03 के टिक काउंट का उपयोग करता है; # "... gnidaoL" एल?! Vob0। "\ | / -": ओ} 8o51। > #

— टीले पेलिकन

@Tealpelican एक कारण है, लेकिन यह बहुत अच्छा नहीं है: नियम बताता है कि "आपको आउटपुट दिखाने से पहले 0.25 सेकंड इंतजार नहीं करना चाहिए - कार्यक्रम के चलते ही पहला फ्रेम प्रिंट होना चाहिए।", इसलिए मैंने किया। 'टाइमर को बहुत लंबा बनाना चाहते हैं, जबकि दूसरी तरफ यह कोड गोल्फ है, इसलिए मैं इसे बहुत छोटा नहीं बनाना चाहता था। अंत में मैंने एक 25 निर्देश लूप के लिए निश्चय किया कि प्रत्येक को 0.25 का सही समय प्राप्त करने के लिए 0.01 सेकेंड का समय लगेगा; जब मैंने इसे लागू किया था, हालांकि, मुझे एहसास हुआ कि मुझे पूर्ण लूप के लिए पर्याप्त जगह की कमी है, इसलिए मुझे 10% नियम का उपयोग करना पड़ा।

— सिंह

मुझे नियमों को गलत समझना चाहिए था। यह समय के लिए एक अच्छा कारण है :)

— चैले पेलिकन

6

MS-DOS .COM फ़ाइल, 56 बाइट्स

यहाँ हेक्साडेसिमल में फ़ाइल सामग्री:

b4 09 ba 2c 01 cd 21 b2 2f e8 11 00 b2 2d e8 0c
00 b2 5c e8 07 00 b2 7c e8 02 00 eb ea b4 02 cd
21 b2 08 cd 21 b9 05 00 f4 e2 fd c3 4c 6f 61 64
69 6e 67 2e 2e 2e 20 24

मिलान कोडक कोड इस तरह दिखता है:

    mov ah, 9      ; Print "Loading... "
    mov dx, text
    int 21h
theloop:
    mov dl, '/'    ; Call "chrout" for "/", "-", "\" and "|"
    call chrout
    mov dl, '-'
    call chrout
    mov dl, '\'
    call chrout
    mov dl, '|'
    call chrout
    jmp theloop    ; Endless loop

chrout:            ; Sub-Function "chrout"
    mov ah, 2      ; Output the character
    int 21h
    mov dl, 8      ; Output backspace
    int 21h
    mov cx,5       ; Call "HLT" 5 times
timeloop:
    hlt            ; Normally HLT will wait ~55 milliseconds
                   ; (Assuming no keyboard key is pressed)
    loop timeloop
    ret            ; End of the function

text:
    ASCII "Loading... ",'$'

— मार्टिन रोसेनौ
स्रोत

1

कुंजी दबाए रखने से स्पिनर को गति mov al, 0xfe / out 0x21,al

— मिलती है

HLT के लिए टिप्पणी गलत है, आप शायद मतलब है कि HLT ~ 18.2 हर्ट्ज (या, और अधिक सटीक रूप से, NTSC घड़ी / 12/65536 हर्ट्ज पर) जागता है।

— नवजाल

@ninjalj धन्यवाद मैंने टिप्पणी को बदल दिया ...

— मार्टिन रोसेनौ

6

NASM x86_64 - 349 283 बाइट्स

यह 64 बिट लाइनक्स सिस्टम चलाया जाना चाहिए

निर्मित उपयोग:

nasm loading_golfed.asm -felf64 && ld loading_golfed.o

%use altreg
global _start
section .data
o:db"Loading...  "
s:db"|/-\\"
b:db`\bx`
q:dq 0,250000000
_start:mov r0,1
mov r7,1
mov r6,o
mov r2,12
syscall
mov r2,2
l:mov r7,1
mov al,[s+r8]
mov [b+1],al
mov r0,1
mov r6,b
syscall
mov r0,35
lea r7,[q]
mov r6,0
syscall
inc r8
and r8,3
jmp l

एनीमेशन:

सहेजे गए 65 बाइट्स - धन्यवाद user254948

— शमूएल
स्रोत

मैं 349 बाइट्स गिनता हूं, जब तक कि एक नई

— अनुगूंज

^ FLP। Tcc धन्यवाद, अंत में एक जगह के साथ एक पंक्ति थी

— शमूएल

@ शमूएल को १३-१S लाइनों की जरूरत है? यह उन लाइनों के बिना बहुत ज्यादा ठीक काम करने लगता है। जहाँ तक मैं बता सकता हूँ (असेंबली में महान नहीं है कि मुझे डर है) आप Loading .... को प्रिंट करें, तो | चरित्र, फिर उस चरित्र को हटा दें, फिर एक लूप दर्ज करें जहां आप मुद्रण दोहराएं | पहली बार।

— 13:25 पर user254948

@Samuel इसके अलावा xor r8, r8 -> mov r8,0 (1 वर्ण बचाता है), कुछ MOV का एक अतिरिक्त स्थान है (mov r7, 1 -> mov r7,1)। और अधिक निर्देश cmp r8,4, jl l, xor r8, r8, को AND r8,3 (15 वर्णों की बचत) द्वारा प्रतिस्थापित किया जा सकता है। आपको ३४ ९ के बजाय २ then५ बाइट्स से नीचे होना चाहिए! (उपर्युक्त पंक्तियों के संयोजन में)

— user254948

5

आर, 85 89 बाइट्स

repeat{if(T>4)T=1;cat("\fLoading...",c("|","/","-","\\")[T],sep="");T=T+1;Sys.sleep(.25)}

संपादित करें: उत्तर को इस तरह से निर्धारित करें कि Tयदि अधिक से अधिक काउंटर रीसेट करके अतिप्रवाह न हो 4।

इस उत्तर के बारे में एकमात्र दिलचस्प पहलू आर के TRUTHYबिलिन का उपयोग है T। यह प्रभावी रूप से एक पूर्वनिर्धारित चर सेट है, 1/TRUEजिसका अर्थ है कि हमें काउंटर को आरंभीकृत नहीं करना है, लेकिन वृद्धि शुरू कर सकते हैं T।

— Billywob
स्रोत

Tअंततः अतिप्रवाह होगा ?

— FlipTack

@ Flp.Tkc यह अतिप्रवाह नहीं होगा, लेकिन 1e+308इस मामले में अनन्तता के रूप में माना जाता है कि किस स्थिति NAमें लौटा है इसलिए मुझे लगता है कि यह उत्तर अमान्य है (नियमों में इसे नोटिस नहीं किया है)। जल्द ही अपडेट होगा

— बिलीवॉब

1

यदि आप बिल्ट-इन T: i=1;repeat{cat("\rLoading...",c("\\","|","/","-")[i]);Sys.sleep(.25);i=`if`(i>3,1,i+1)}87 बाइट का उपयोग नहीं करते हैं तो वास्तव में आप इसे 2 बाइट्स छोटे कर सकते हैं ।

— प्लेनैपस

हम्म ... क्या आर केवल वैक्टर पर काम करता है? परमाणुओं के लिए कोई मॉडुलो या बिटवाइज़ ऑपरेटर क्यों नहीं हैं? है Tएक सदिश? T=(T+1)%%4काम करता है ? यह एक और 5 बाइट्स को बचाएगा।

— टाइटस

2

... या T=T%%4+1: यहां तक कि 2 बाइट्स छोटे।

— टाइटस

5

हास्केल (GHC), 103 91 बाइट्स

import GHC.Conc
mapM((>>threadDelay 250000).putStr)$("\rLoading... "++).pure<$>cycle"|/-\\"

12 बाइट बचाने के लिए धन्यवाद @nimi!

— अंग
स्रोत

पूर्ण कार्यक्रम के लिए कोई ज़रूरत नहीं है। mapM((threadDelay 250000>>).putStr)$("\rLoading... "++).pure<$>cycle"|/-\\"।

— नागी

दो बाइट्स को 10% सहिष्णुता और जगह 250000और इसके साथ पहले की जगह का उपयोग करके बचाया जा सकता है (4^9)।

— क्रिश्चियन सेवर्स

5

सी (यूनिक्स-जैसी प्रणालियों पर) 88 बाइट्स

main(_){for(;;){_%=4;printf("\rLoading... %c","\\-/|"[_++]);fflush(0);usleep(250000);}}

यह गलत चरित्र से शुरू होता है, लेकिन मुझे लगता है कि यह अच्छा लग रहा है। आप आसानी से वर्ण क्रम बदल सकते हैं "\ / / |" स्ट्रिंग।

— लमबडबेट
स्रोत

आगे चलकर बयानों को आगे बढ़ाया जा सकता है for, उदाहरणार्थ:, ain(_){for(;printf("\rLoading... %c","\\-/|"[_%4]);usleep(250000))_++,fflush(0);}फिर पूर्णांक ओवरफ्लो के लिए रैपराउंड को ग्रहण किया जा सकता है:main(_){for(;printf("\rLoading... %c","\\-/|"[_++%4]);usleep(250000))fflush(0);}

— निंजालज

क्या आपको फफ्लश () की आवश्यकता है ?

— जॉन यू

अधिकांश प्रणालियों पर आपको fflush की आवश्यकता होती है, उनमें से कई newlines के आधार पर बफर होती हैं। हालाँकि यह संभव है कि कुछ प्रणालियों पर यह आवश्यक नहीं है।

— लाम्बेबेटा

आप fprintf(stderr,...इसके बजाय उपयोग कर सकते हैं , क्योंकि यह लाइन की तरह बफर नहीं है stdout। f...stderr,आठ वर्ण लेता है, जबकि fflush(0);दस लेता है, तो यह दो अक्षर का शुद्ध जीत है।

— 10

5

पर्ल, 71 63 61 बाइट्स

s//\rLoading... |/;select$\,$\,$\,y'-|\/'\/|-'/4while$|=print

पुराना वर्जन:

$_="\rLoading... |";{$|=print;y#|/\-\\#/\-\\|#;select$\,$\,$\,.25;redo}

10 बाइट्स के लिए @ximo को Thanx।

— डेनिस इबाव
स्रोत

2

selectइसके बजाय टाइमआउट का उपयोग करने के लिए अच्छी चाल Time::HiRes। आप कुछ बाइट्स का उपयोग करके ... while$|=print, और आगे और अंत में लिप्यंतरण में हाइफ़न ले जाकर बचा सकते हैं । s//\r Loading... |/असाइनमेंट पर एक बाइट भी बचाता है।

— प्रिमो

2

और भी, यदि आप लिप्यंतरण परिसीमन के लिए एकल उद्धरण का उपयोग करते हैं, तो बैकस्लैश से बचने की कोई आवश्यकता नहीं है: या y'-\|/'\|/-'।

— प्रिमो

ऐसा लगता है कि आपके पास अपने कोड से पहले एक अतिरिक्त जगह है।

— निकोलग्राफ

1

आप शाब्दिक रूप से एक और बाइट बचा सकते हैं \r।

— नवजलज

1

2 और y'-|\/'\/|-'/4के .25लिए उपयोग करें ।

— प्रिमो

लोड हो रहा है ... हमेशा के लिए

नियम

उदाहरण

HTML / CSS, 183 180 163 161 160 147 143 बाइट्स

विम, ४३ , ४१ बाइट्स

HTML + JS (ES6), 20 + 51 50 = 70 बाइट्स

विंडोज बैच, 121 114 84 80 79 78 बाइट्स

नोड, 72 70 बाइट्स

कोटलिन, 67 66 बाइट्स

विम, 35 बाइट्स

विम (1 सेकंड की नींद), 27 बाइट्स

पायथ, 31 बाइट्स

व्याख्या

पॉवर्सशेल (v4), 57 56 54 53 58 57 बाइट्स

पायथ - 36 35 बाइट्स

मतलाब, 78 75 बाइट्स

HTML / CSS, 23 + 109 = 132 बाइट्स

गणितज्ञ, atic४ ६ By बाइट्स

सी #, 170 133 बाइट्स

आगे, 72, 73 बाइट्स

पायथन 2, 81 79 78 77 बाइट्स

MATL , 36 बाइट्स

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

दिल्लोग एपीएल, 50 बाइट्स

सी #, 187 बाइट्स

स्नैप !, 8 ब्लॉक

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

व्याख्या

बैश, 98 69 बाइट्स

पर्ल 6 , 72 61 बाइट्स

> <> , 55 + 4 = 59 बाइट्स

MS-DOS .COM फ़ाइल, 56 बाइट्स

NASM x86_64 - 349 283 बाइट्स

आर, 85 89 बाइट्स

हास्केल (GHC), 103 91 बाइट्स

सी (यूनिक्स-जैसी प्रणालियों पर) 88 बाइट्स

पर्ल, 71 63 61 बाइट्स