ความท้าทายของคุณคือสร้างหน้าจอการโหลดแบบไม่ จำกัด ซึ่งมีลักษณะดังนี้:

หรือจะเจาะจงมากขึ้น:

• ไม่มีการป้อนข้อมูล
• เอาท์พุทที่Loading...มีพื้นที่ต่อท้าย แต่ไม่มีการขึ้นบรรทัดใหม่
• วงจรอนันต์ผ่านตัวอักษร|, /, -และ\ทุก 0.25 วินาทีเขียนทับคนสุดท้ายที่มีต่อไปในลำดับ คุณสามารถเขียนทับอักขระตัวสุดท้ายหรือลบและเขียนทั้งบรรทัดใหม่ได้ตราบใดที่Loading...ยังคงไม่เปลี่ยนแปลง

กฎระเบียบ

• ข้อความที่ส่งออกจะต้องมีลักษณะตรงตามที่ระบุไว้ ขึ้นบรรทัดใหม่ / ช่องว่างเป็นที่ยอมรับ
• คุณไม่ควรรอ 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;
    }
}

ขอให้นักกอล์ฟที่ดีที่สุดชนะ!

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>

แก้ไข: บันทึกแล้ว 3 ไบต์ด้วย @betseg บันทึกแล้ว 17 ไบต์ขอบคุณ @manatwork บันทึก 1 ไบต์ขอบคุณ @Daniel บันทึกแล้ว 13 ไบต์ขอบคุณ @Ismael Miguel บันทึกแล้ว 4 ไบต์ขอบคุณ @Fez Vrasta

เป็นกลุ่ม43 , 41 ไบต์

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

HTML + JS (ES6), 20 + 51 50 = 70 ไบต์

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

Loading... <a id=a>-

-1 ไบต์ (Zachary T)

ตรวจสอบคำตอบ HTML / CSS 132 ไบต์ของฉันเช่นกัน

Windows Batch 121 114 84 80 79 78 ไบต์

เพียงแค่โยนมันออกมาเพื่อความสนุก

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

ฉันไม่สามารถกำหนดไพพ์ ( |) ลงในอาร์เรย์ได้ดังนั้นฉันต้องเพิ่มมันด้วยตนเองด้วยการมอบหมายอื่นความล่าช้าจะทำด้วยPINGซึ่งอาจไม่ถูกต้อง

เอาท์พุท:

แก้ไข:

• ขอบคุณ Roman Gräfสำหรับการบันทึก 7 ไบต์!
• ขอบคุณ Neil สำหรับการบันทึก 30 ไบต์! ฉันยังจัดการมันอีกเล็กน้อยเพื่อประหยัดไบต์บนบรรทัดใหม่
• ขอบคุณ phyrfox สำหรับการบันทึก 4 ไบต์!
• ขอบคุณ YourDeathIsComing ที่ช่วยประหยัด 2 ไบต์!

โหนด, 72 70 ไบต์

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

แทนที่\x1Bด้วยอักขระ escape ตามตัวอักษรเพื่อรับจำนวนไบต์ที่ถูกต้อง โทรf()เพื่อเริ่มภาพเคลื่อนไหว นี่คือลักษณะที่ปรากฏในเครื่องจำลองเทอร์มินัล ConEmu บนคอมพิวเตอร์ของฉัน:

Kotlin, 67 66 ไบต์

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

อธิบายตนเองได้อย่างเป็นธรรมใช้\rเพื่อลบล้างเส้นและใช้ประโยชน์จากการแก้ไขข้อความที่น่ากลัวของ Kotlin

แก้ไข: บันทึก 1 ไบต์ขอบคุณ @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu โดยเปลี่ยนwhile(true)เป็นwhile(1>0)

เป็นกลุ่ม 35 ไบต์

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

รุ่นที่น่าเบื่อ นี่เป็นวิธีแก้ไขปัญหาที่ไม่สอดคล้องซึ่งดีกว่า:

เป็นกลุ่ม (สลีป 1 วินาที), 27 ไบต์

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

การใช้gsไม่เพียงสั้นกว่ามาก แต่คุณไม่จำเป็นต้องกด Enter @.นั่นหมายความว่าเหมาะกับแมโครในบรรทัดและฉันสามารถบันทึกไบต์โดยการเปลี่ยนไป (เนื่องจากไม่มีอะไรหลังจากการเรียกซ้ำเกิดขึ้นฉันจึงสามารถพิมพ์สิ่งที่ฉันต้องการได้)

Pyth, 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

Powershell (v4), 57 56 54 53 58 57 ไบต์

กลับมาที่ Bytecount ฉันเริ่มด้วย!

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

CLI in powershell จะผิดพลาดเล็กน้อยในคอมพิวเตอร์บางเครื่องดังนั้นมันจึงดูไม่สมบูรณ์แบบ แต่มันดีเท่าที่จะทำได้

ย้าย $ a ++ ไปที่ for loop เพื่อบันทึกหนึ่งไบต์ (ไม่ใช่;)

จากนั้นย้ายไปไว้ในตัวทำดัชนีอาร์เรย์สำหรับการบันทึกอีก 2 ไบต์ต้องขอบคุณ Roman สำหรับการชี้ให้เห็น

บันทึกอีก 1 ไบต์ ( ;) โดยการย้ายส่วน Clear screen ( cls) ไปยังวง for ..

ปัญหาและการแก้ไขที่ TimmyD ชี้ให้เห็นสำหรับประเด็นที่ไม่มีที่สิ้นสุดของคำถามต้องการเพียง 5 ไบต์เท่านั้นเปลี่ยน$a++%4เป็น($a=++$a%4)ดังนั้นจึงไม่มีทางเหนือกว่า 3

บันทึกไบต์อื่นโดยปล่อยให้ลูปว่างเปล่าโดยสิ้นเชิงขอบคุณ 'อะไรก็ตาม' สำหรับการชี้ให้เห็นว่านี่เป็นไปได้จริงใน Powershell เวอร์ชัน 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}

Pyth - 36 35 ไบต์

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

ไม่ทำงานออนไลน์แน่นอน

Matlab, 78 75 ไบต์

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

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>|/-\

Mathematica, 74 67 ไบต์

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

A มหันต์ไป 7 ไบต์ขอบคุณ @dahnoak

C #, 170 133 ไบต์

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

ขอขอบคุณ Roman Gräfและ raznagul ที่ช่วยฉันได้ 37 ไบต์ (โดยเฉพาะ raznagul ผู้ชี้ให้เห็นว่าโซลูชันดั้งเดิมของฉันไม่ถูกต้องอย่างไรก็ตามฉันพลาดบางอย่างที่นั่น แต่ตอนนี้ได้รับการแก้ไขแล้วและควรเป็นไปตามข้อกำหนด :)

ค่อนข้างคล้ายกับคำตอบ C # ที่มีอยู่ของ Pete Arden แต่มีการปรับปรุงบางอย่าง

เช่น "for (;;)" แทนที่จะเป็น "while (true)", char แทนที่จะเป็นสตริง

ฉันจะแสดงความคิดเห็นคำแนะนำของฉันเกี่ยวกับคำตอบของเขา แต่จริง ๆ แล้วฉันไม่มีชื่อเสียงเพียงพอที่จะทำเช่นนั้น

Ungolfed:

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

มา 72, 73 ไบต์

แก้ไข :

• เพิ่ม Gforth-only version, 69 bytes (ขอบคุณ @ninjalj!)
• เพิ่มช่องว่างที่หายไปหลังจาก "กำลังโหลด ... " (ขอบคุณ @Roman Gräf!), +1 ไบต์
• อัปเดตเพื่อให้ตรงกับกฎอย่างแม่นยำมากขึ้น (ในจำนวนไบต์เดียวกัน)

แข็งแรงเล่นกอล์ฟ

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

รุ่น Gforth

GNU Forth-only version สามารถลดขนาดลงเหลือ 69 bytes ดังนี้:

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

screencast

ลองออนไลน์!

Python 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การหลีกเลี่ยงวงเล็บ (ขอบคุณ@ Flp.Tkcสำหรับ -2 ไบต์เหล่านี้!) ( i=(i+1)%4เทียบกับi=-~i%4)

ตอนนี้ฉันแค่ปล่อยให้ตัวนับเพิ่มขึ้นตลอดกาลเพราะเทคนิคของ Python intไม่สามารถล้นได้ ขอบคุณ@Zachary Tสำหรับการชี้และบันทึกไบต์!
มันหยุดบนเครื่องเพราะเครื่องวิ่งออกไปจากหน่วยความจำ แต่นี้จะใช้เวลา9.7 คนรุ่นที่มีหน่วยความจำ 4GB intสำหรับที่หนึ่ง

ขอบคุณ@Kadeสำหรับ -1 ไบต์ที่การprint a,bพิมพ์aและการbแยกพื้นที่ดังนั้นฉันไม่ต้องการพื้นที่ของตัวเอง

นี่คือ gif ของมันทำงานบน Windows:

ฉันทดสอบบน Linux VM ด้วย ฉันไม่สามารถทดสอบบน Mac ได้

MATL , 36 ไบต์

ลบ 1 ไบต์โดยใช้แนวคิดของ@ flawr เพื่อเปลี่ยนสตริงเป็นวงกลม

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

นี่คือการบันทึก gif จากคอมไพเลอร์ออฟไลน์:

หรือลองที่MATL Online! หากไม่ได้เริ่มต้นให้รีเฟรชหน้าเว็บแล้วกด "Run" อีกครั้ง

มันทำงานอย่างไร

'\-/|'           % 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

Dyalog APL ขนาด 50 ไบต์

ใช้งานได้ในเวอร์ชั่น Windows เท่านั้นมิฉะนั้น⎕SMหน้าต่างจะไม่ปรากฏขึ้นเว้นแต่⎕SRจะมีการเรียก

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

คำอธิบาย:

• {... }1: เรียกใช้ฟังก์ชันที่ขึ้นต้นด้วย⍵=1
• Loading... '∘,¨'|/-\': สร้างสี่เอาต์พุตที่เป็นไปได้
• ⊂⊃⍵⌽: หมุนรายการเพื่อให้องค์ประกอบที่ first เป็นอันดับแรกนำองค์ประกอบที่หนึ่งแล้วใส่ไว้ในรายการ
• ⎕SM←1 1,⍨: ใส่สตริงที่มุมบนซ้ายของ⎕SMหน้าต่าง
• ⎕DL÷4: รอ 1 / 4th ของวินาที
• 4|⍵+⌈: ปัดค่าผลลัพธ์ (วินาทีที่ใช้ในการรอดังนั้นจึงเป็น 1 เสมอ) เพิ่มไปที่⍵(เพิ่มค่า) และใช้ mod-4 (เพื่อป้องกันไม่ให้ล้นในที่สุด)
• ∇: ⍵เรียกใช้ฟังก์ชั่นอีกครั้งกับใหม่

C #, 187 ไบต์

แข็งแรงเล่นกอล์ฟ:

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

ยังรอให้โหลด ...

Snap !, 8 บล็อก

นี่เป็นหนึ่งในอัลกอริธึมแรกที่ฉันเคยสงสัยใน Apple] [e

ไขว้กันเหมือนแหกปาก, 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

Bash, 98 69 ไบต์

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

ขอบคุณหลาย ๆ คนสำหรับหลายไบต์ที่ golfed off!

Perl 6 , 72 61 ไบต์

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

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

> <> , 55 + 4 = 59 ไบต์

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

ต้องเรียกใช้ผ่าน-t .01เป็นอาร์กิวเมนต์เพิ่มเติมเพื่อล่ามนั่นคือ +4 ในการนับไบต์

สิ่งนี้จะทำให้ตัวละครสี่ตัวที่จะพิมพ์บนสแต็คพิมพ์ด้านบนโดยไม่ต้องลบมันและขยับกองโดยตำแหน่งหนึ่ง จากนั้นมันจะพิมพ์\b(backspace อักขระ x08) และรีสตาร์ทลูป

การจับเวลาทำได้โดยการโต้แย้งที่ส่งไปยังล่ามซึ่งบังคับให้รอ 0.01 วินาทีก่อนที่จะดำเนินการแต่ละคำสั่ง มีคำสั่ง 23 คำสั่งระหว่างเอาท์พุทและคำสั่งถัดไป (ส่วนใหญ่เพียงแค่เลื่อนตัวชี้คำสั่งไปยังเซลล์ถัดไป) ดังนั้นมันจะรอ 0.23 วินาทีพร้อมเวลาที่จำเป็นสำหรับการดำเนินการคำสั่งซึ่งเหมาะกับไม่มีปัญหาใน 0.25s ที่ร้องขอ มีข้อผิดพลาด 10%

คุณสามารถลองออนไลน์ได้ แต่ล่ามนั้นไม่รู้จักอักขระแบ็คสเปซดังนั้นผลลัพธ์จะแปลกไปที่นั่น

ไฟล์ 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... ",'$'

NASM x86_64 - 349 283 ไบต์

สิ่งนี้ควรเรียกใช้ระบบ Linux 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 ไบต์ - ขอบคุณผู้ใช้ 254948

R, 85 89 ไบต์

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

แก้ไข: แก้ไขคำตอบดังกล่าวที่ล้นเคยชินโดยการรีเซ็ตเคาน์เตอร์ถ้ามากกว่าT4

เพียงด้านที่น่าสนใจเกี่ยวกับคำตอบนี้คือการใช้ R ของbuiltinTRUTHY Tมันเป็นชุดตัวแปรที่กำหนดไว้ล่วงหน้าอย่างมีประสิทธิภาพ1/TRUEซึ่งหมายความว่าเราไม่จำเป็นต้องเริ่มต้นตัวนับ แต่สามารถเริ่มเพิ่มขึ้นTได้

Haskell (GHC), 103 91 ไบต์

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

ขอบคุณ @nimi สำหรับการบันทึก 12 ไบต์!

C (บนระบบเหมือน UNIX) 88 ไบต์

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

มันเริ่มต้นด้วยตัวละครที่ผิด แต่ฉันคิดว่ามันดูดีกว่า คุณสามารถเปลี่ยนลำดับตัวอักษรได้อย่างง่ายดายโดยการแก้ไข "\ - / |" เชือก

Perl, 71 63 61 ไบต์

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

รุ่นก่อนหน้า:

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

Thanx ถึง @primo เป็นเวลา 10 ไบต์