您的挑战是制作一个无限的加载屏幕，如下所示：

或者，更具体地说：

• 不输入任何内容。
• 输出Loading...，带有尾随空格，但没有尾随换行符。
• 通过字符无限循环|，/，-和\：每0.25秒，覆盖最后一个与序列中的下一个。您可以只覆盖最后一个字符，或者删除并重写整行，只要Loading...保持不变即可。

规则

• 输出文本必须与指定的外观完全相同。尾随换行符/空格是可以接受的。
• 应该不最初显示输出之前等待0.25秒-第一帧应当被尽快程序运行打印。
• 您的程序应该可以无限期地运行。例如，如果您将计数器用于帧，则计数器绝不能超过您所用语言的最大值而不会导致错误。
• 尽管每个“帧”之间的等待时间应该为0.25秒，但显然这永远都不是精确的-允许10％左右的误差范围。
• 您可以提交功能，但必须将其打印到stdout。
• 您可以在非控制台（但仍基于文本）的环境中提交答案，只要它能够生成加载动画即可。
• 这是代码高尔夫球，因此最短的解决方案（以字节为单位）获胜。适用标准代码高尔夫球漏洞。
• 如有可能，请提供您正在使用的加载屏幕的gif。

例

这是我用来创建示例（unolfed）的C ++代码：

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

编辑：由于@betseg，节省了3个字节。@manatwork节省了17个字节。感谢@Daniel，节省了1个字节。@Ismael Miguel节省了13个字节。@Fez Vrasta节省了4个字节。

Vim，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）

还要查看我的132字节HTML / CSS答案。

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，可能不准确。

输出：

编辑：

• 感谢RomanGräf节省了7个字节！
• 感谢尼尔节省了30个字节！我还修改了一点以节省换行符上的字节。
• 感谢phyrfox节省了4个字节！
• 感谢YourDeathIsComing节省了2个字节！

节点，72 70字节

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

替换\x1B为原义转义字符以获取正确的字节数。调用f()以开始动画。这是我计算机上的ConEmu终端模拟器中的外观：

Kotlin，67 66字节

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

完全可以自我解释，\r用于清理线条并利用Kotlin出色的字符串插值功能。

编辑：通过更改while(true)为@ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu，节省了1个字节while(1>0)

Vim，35个字节

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

无聊的版本。这是一个更好的非遵从解决方案：

Vim（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字节

回到我开始的字节数！

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

在某些计算机上，powershell中的CLI可能会出现一点故障，因此它看起来并不完美，但我可以尽其所能。

将$ a ++移至for循环以保存一个字节，（否;）

然后将其移到数组索引器中，以节省另外2个字节，这要感谢Roman指出了这一点。

;通过将“清除屏幕”（cls）部分移到for循环中，还节省了1个字节（）。

TimmyD针对问题的无限方面指出的问题和解决方案，只需将+5字节更改$a++%4为，($a=++$a%4)因此它将永远不会超过3。

感谢'whatever'指出在Powershell版本4中这实际上是可能的，从而使for循环完全空白，从而节省了另一个字节！

此答案（最终版本）的新更新的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]

多亏了@dahnoak，可节省多达7个字节

C＃，170个 133字节

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

非常感谢RomanGräf和raznagul，他们为我节省了37个字节。（尤其是raznagul，他指出，我的原始解决方案无论如何都是无效的。我有点错过了那里的内容，但现在已修复，应该可以满足要求：）

与Pete Arden现有的C＃答案非常相似，但有一些改进

例如，“ for（;;）”代替“ while（true）”，用char代替字符串

我会对他的回答发表意见，但实际上我没有足够的声誉来做到这一点。

取消高尔夫：

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

向前， 72，73字节

编辑：

• 添加了仅Gforth版本的69字节（感谢@ninjalj！）
• 在“正在加载...”（Thx @RomanGräf！）之后添加了缺失的空格，+ 1字节
• 更新以更精确地匹配规则（在相同字节数中）

打高尔夫球

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

Gforth版本

GNU仅Forth版本可以减少到69个字节，如下所示：

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

截屏

在线尝试！

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)%4vs。i=-~i%4）

现在，我只是让计数器永远增加，因为从技术上讲Python int不会溢出。感谢@Zachary T指出这一点并节省了一个字节！
它仅在计算机上停止，因为计算机内存不足，但这需要9.7代，而该计算机需要4GB的内存int。

感谢@Kade提供的-1个字节，其中print a,b打印a和b空格是分开的，因此我不需要自己的空格。

这是在Windows上运行的gif图像：

我也在Linux VM上进行了测试。我无法在Mac上进行测试。

MATL，36字节

使用@flawr循环移动字符串的想法删除了1个字节

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

这是离线编译器的gif记录：

或在MATL Online上尝试！如果最初没有运行，请刷新页面，然后再次按“运行”。

这个怎么运作

'\-/|'           % 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... '∘,¨'|/-\'：生成四个可能的输出
• ⊂⊃⍵⌽：旋转列表以将第element个元素放在第一位，采用第一个元素并将其括起来
• ⎕SM←1 1,⍨：将字符串放在⎕SM窗口的左上角。
• ⎕DL÷4：等待1/4秒
• 4|⍵+⌈：将结果值四舍五入（等待所花费的秒数，因此始终为1），将其添加到⍵（递增），然后采用mod-4（以防止最终溢出）。
• ∇：使用new再次运行该功能⍵。

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

取消高尔夫：

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上迷惑过的最早的算法之一。

网状，无竞争性，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

感谢许多人打了很多球！

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（退格，字符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字节

这应该在64位linux系统上运行

使用：

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

R，85 89字节

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

编辑：修正了答案，使得T如果大于，则不会通过重置计数器来溢出4。

关于此答案的唯一有趣的方面是R的TRUTHY内建函数的使用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}

感谢@primo 10个字节。