Ваша задача - создать бесконечный загрузочный экран, который выглядит следующим образом:

Или, чтобы быть более конкретным:

• Не принимайте никаких данных.
• Выходные данные Loading..., с завершающим пробелом, но без завершающего перевода строки.
• Бесконечно цикл через символы |, /, -и \: каждые 0,25 секунд, перезаписать последнюю со следующим в последовательности. Вы можете перезаписать только последний символ или удалить и перезаписать всю строку, так как long Loading...остается неизменным.

правила

• Выходной текст должен выглядеть точно так, как указано. Конечные символы новой строки / пробелы являются приемлемыми.
• Вам не следует ждать 0,25 секунды, прежде чем вы начнете показывать вывод - первый кадр должен быть напечатан сразу после запуска программы.
• Ваша программа должна работать бесконечно долго. Например, если вы используете счетчик для фреймов, он никогда не должен вызывать ошибку, превышая максимум на вашем языке.
• Хотя период ожидания между каждым «кадром» должен составлять 0,25 секунды, очевидно, что он никогда не будет точным - допустимая погрешность составляет около 10%.
• Вы можете отправить функцию, но она должна распечатать stdout.
• Вы можете отправить ответ в неконсольной (но все же основанной на тексте) среде, если она способна создавать загрузочную анимацию.
• Это код-гольф , поэтому выигрывает самое короткое решение (в байтах). Применяются стандартные лазейки для игры в гольф.
• Если возможно, предоставьте gif вашего экрана загрузки в действии.

пример

Вот код 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>

Редактировать: 3 байта сохранены благодаря @betseg. Сохранено 17 байт благодаря @manatwork. Сохранено 1 байт благодаря @Daniel. Сохранено 13 байтов благодаря @Ismael Miguel. Сохранено 4 байта благодаря @Fez Vrasta.

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 байт (Захарий Т)

Проверьте также мой 132-байтовый ответ HTML / CSS .

Пакет Windows, 121 114 84 80 79 78 байт

Просто выбросил это для удовольствия.

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

Я не смог назначить pipe ( |) в массив, поэтому мне пришлось добавить его вручную с другим назначением.Задержка завершена PING, что может быть неточным .

Выход:

Редактировать:

• Спасибо Роману Грефу за сохранение 7 байтов!
• Спасибо Нейлу за сохранение 30 байтов! Я также исправил это немного больше, чтобы сохранить байты на новых строках.
• Спасибо phyrfox за сохранение 4 байта!
• Спасибо YourDeathIsComing за сохранение 2 байта!

Узел, 72 70 байт

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

Замените \x1Bбуквальным escape-символом, чтобы получить правильное количество байтов. Позвоните, f()чтобы начать анимацию. Вот как это выглядит в эмуляторе терминала ConEmu на моем компьютере:

Котлин, 67 66 байт

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

Самоочевидно, использует \rдля очистки линии и использует потрясающую интерполяцию строк Kotlin.

РЕДАКТИРОВАТЬ: Сохранено 1 байт благодаря @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu путем изменения while(true)на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 байт

Вернувшись в Bytecount, я начал с!

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

Интерфейс командной строки PowerShell на некоторых компьютерах будет слегка зависать, поэтому он не выглядит идеально, но он настолько хорош, насколько это возможно.

Переместил $ a ++ в цикл for для сохранения одного байта, (нет ;)

Затем переместил его в индексатор массива, чтобы сохранить еще 2 байта, спасибо Роману за указание на это.

Также сохранен еще 1 байт ( ;) путем перемещения части Clear screen ( cls) в цикл for.

Выпуск и исправление указал TimmyD для бесконечного аспекта вопроса, только +5 Bytes требуется, изменилось $a++%4в ($a=++$a%4)так он никогда не поднимется выше 3.

Сохраните еще один байт, оставив цикл for полностью пустым, благодаря «что угодно» за указание на то, что это действительно возможно в Powershell Version 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]

Огромные 7 байт благодаря @dahnoak

C #, 170 133 байта

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

Большое спасибо Роману Грефу и Разнагулу, которые спасли мне 37 байтов. (Особенно разнагул, который указал, что мое первоначальное решение в любом случае было недействительным. Я что-то там упустил, но оно исправлено и должно отвечать требованиям :)

очень похоже на существующий ответ Пита Ардена на C #, но с некоторыми улучшениями

например, "for (;;)" вместо "while (true)", символ вместо строки

Я бы прокомментировал свои предложения по его ответу, но на самом деле у меня недостаточно репутации, чтобы это сделать

Ungolfed:

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

В-четвертых, 7273 байта

РЕДАКТИРОВАТЬ :

• Добавлена ​​версия только для Gforth, 69 байт (Спасибо @ninjalj!)
• Добавлен пропущенный пробел после «Загрузка ...» (Thx @Roman Gräf!), +1 байт
• Обновлен для более точного соответствия правилам (с тем же количеством байтов)

Golfed

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

Gforth версия

Версия GNU Forth-only может быть уменьшена до 69 байтов следующим образом:

'| '/ '- '\ [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 поколения с 4 ГБ памяти int.

Спасибо @Kade за -1 байт, где отделяютсяprint a,b отпечатки aи bпробел, так что мне не нужно свое собственное пространство.

Вот как это работает на Windows:

Я также проверил его на виртуальной машине Linux. Я не мог проверить это на Mac.

MATL , 36 байт

1 байт удален с использованием идеи @ flawr о круговом сдвиге строки

'\-/|'`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... '∘,¨'|/-\': сгенерировать четыре возможных выхода
• ⊂⊃⍵⌽: Поверните список, чтобы поместить ⍵-й элемент первым, возьмите первый элемент и заключите его
• ⎕SM←1 1,⍨: поместите строку в верхний левый угол ⎕SMокна.
• ⎕DL÷4: подождите 1/4 секунды
• 4|⍵+⌈: округлите результирующее значение (количество секунд, потраченных на ожидание, так что это всегда 1), добавьте его к ⍵(увеличивая его) и возьмите mod-4 (чтобы предотвратить его переполнение).
• ∇: запустите функцию снова с новым ⍵.

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

Все еще жду его загрузки ...

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

Баш, 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,25 с. с ошибкой 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 байт - спасибо пользователю 254948

R 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.

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 байтов.