Votre défi consiste à créer un écran de chargement infini, qui ressemble à ceci:

Ou, pour être plus précis:

• Ne prenez aucune entrée.
• Sortie Loading..., avec un espace de fin, mais pas de nouvelle ligne.
• Le cycle en continu à travers les caractères |, /, -et \: toutes les 0,25 secondes, écrasent la dernière avec le suivant dans la séquence. Vous pouvez écraser le dernier caractère ou effacer et réécrire la ligne entière tant que le temps Loading...reste inchangé.

Règles

• Le texte de sortie doit ressembler exactement à celui spécifié. Les retours à la ligne / espaces sont acceptables.
• Vous ne devez pas attendre 0,25 seconde avant d’afficher la sortie. La première image doit être imprimée dès que le programme est exécuté.
• Votre programme devrait pouvoir fonctionner indéfiniment. Par exemple, si vous utilisez un compteur pour les images, celui-ci ne devrait jamais provoquer d'erreur en dépassant le maximum dans votre langue.
• Bien que le délai d'attente entre chaque "trame" devrait être de 0,25 seconde, il est évident que cela ne sera jamais exact - une marge d'erreur de 10% environ est autorisée.
• Vous pouvez soumettre une fonction, mais elle doit être imprimée sur stdout.
• Vous pouvez soumettre une réponse dans un environnement non console (mais toujours basé sur du texte), à ​​condition qu'il soit capable de produire l'animation de chargement.
• C'est du code-golf , donc la solution la plus courte (en octets) est gagnante. Les échappatoires standard de code-golf s'appliquent.
• Si possible, veuillez fournir un gif de votre écran de chargement en action.

Exemple

Voici le code C ++ que j'ai utilisé pour créer l'exemple (non-golfé):

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

Que le meilleur golfeur gagne!

HTML / CSS, 183 180 163 161 160 147 143 octets

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>

Edit: 3 octets sauvegardés grâce à @betseg. Sauvegardé 17 octets grâce à @manatwork. Enregistré 1 octet grâce à @Daniel. Sauvegardé 13 octets grâce à @Ismael Miguel. Sauvegardé 4 octets grâce à @Fez Vrasta.

Vim, 43 , 41 octets

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

Deux octets enregistrés grâce à @Udioica!

Voici une animation (légèrement dépassée) de ce qui se passe en temps réel!

Et voici une explication:

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 octets

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

Loading... <a id=a>-

-1 octet (Zachary T)

Découvrez aussi ma réponse HTML / CSS de 132 octets .

Lot Windows, 121 114 84 80 79 78 octets

Je lance ça pour le plaisir.

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

Je ne pouvais pas assigner pipe ( |) au tableau, je devais donc l'ajouter manuellement avec une autre affectation.Le retard est fait avec PING, ce qui pourrait ne pas être précis .

Sortie:

Modifier:

• Merci à Roman Gräf d'avoir économisé 7 octets!
• Merci à Neil d'avoir économisé 30 octets! Je l'ai aussi malmené un peu plus pour économiser des octets sur les nouvelles lignes.
• Merci à phyrfox pour la sauvegarde de 4 octets!
• Merci à YourDeathIsComing d'avoir économisé 2 octets!

Noeud, 72 70 octets

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

Remplacez-le \x1Bpar le caractère d'échappement littéral pour obtenir le nombre d'octets correct. Appelez f()pour lancer l'animation. Voici à quoi cela ressemble dans l'émulateur de terminal ConEmu sur mon ordinateur:

Kotlin, 67 66 octets

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

Plutôt explicite, utiliser \rpour effacer la ligne et tirer parti de l'impressionnante interpolation des cordes de Kotlin.

EDIT: 1 octet enregistré grâce à @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu en passant while(true)àwhile(1>0)

Vim, 35 octets

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

La version ennuyeuse. Voici une solution non conforme qui vaut mieux:

Vim (1 seconde de sommeil), 27 octets

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

L'utilisation est gsnon seulement beaucoup plus courte, mais vous n'avez pas besoin d'appuyer sur Entrée. Cela signifie que la macro s'adapte en ligne et que je peux économiser des octets en basculant sur @.. (Puisqu'aucun appel ne peut être exécuté après l'appel récursif, je peux saisir ce que je veux.)

Pyth, 31 octets

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

Interprète ici .

Explication

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 octets

De retour au Bytecount, j'ai commencé avec!

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

La CLI de PowerShell ne fonctionnera pas très bien sur certains ordinateurs. Elle n’est donc pas parfaite, mais c’est aussi bon que possible.

Déplacé $ a ++ dans la boucle for pour enregistrer un octet, (non ;)

Puis déplacé dans l'indexeur de tableau, pour une autre sauvegarde de 2 octets, grâce à Roman pour l'avoir signalé.

Également enregistré 1 octet supplémentaire ( ;) en déplaçant la partie Clear screen ( cls) dans la boucle for.

Problème et fixer souligné TimmyD pour l'aspect infini de la question, seulement 5 octets requis, changé $a++%4en ($a=++$a%4)sorte qu'il ne sera jamais au- dessus de 3.

Vous avez sauvé un autre octet en laissant la boucle for totalement vide, grâce à "quoique ce soit" pour avoir signalé que ceci est réellement possible dans Powershell Version 4!

Nouvelle mise à jour pour la version (finale?) De cette réponse.

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 octets

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

Ne fonctionne pas en ligne, évidemment.

Matlab, 78 75 octets

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

HTML / CSS, 23 + 109 = 132 octets

Amélioré sur la réponse de Neil .

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 octets

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

Un énorme 7 octets grâce à @dahnoak

C #, 170 133 octets

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

Un grand merci à Roman Gräf et à raznagul, qui m'ont sauvé 37 octets. (Surtout raznagul, qui a souligné que ma solution initiale était de toute façon invalide. J'ai un peu raté quelque chose là-bas, mais c'est réparé maintenant et devrait répondre aux exigences :)

assez similaire à la réponse C # existante de Pete Arden mais avec quelques améliorations

Par exemple, "pour (;;)" au lieu de "while (true)", un caractère au lieu de chaîne

J'aurais commenté mes suggestions sur sa réponse, mais je n'ai pas assez de réputation pour le faire.

Ungolfed:

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

4ème 72, 73 octets

EDIT :

• Ajout de la version réservée à Gforth, 69 octets (Merci @ninjalj!)
• Ajout d'espaces manquants après "Loading ..." (Thx @Roman Gräf!), +1 octet
• Mis à jour pour correspondre aux règles plus précisément (dans le même nombre d'octets)

Golfé

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

Version Gforth

La version GNU Forth uniquement peut être réduite à 69 octets comme ceci:

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

Screencast

Essayez-le en ligne!

Python 2, 81 79 78 77 octets

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

Une solution assez simple qui dort en utilisant time.

J'utilise \r(retour chariot) pour revenir au début de la ligne, puis imprimer le message en remplaçant la ligne.

Je commence par i=1éviter de double échapper à la \(c'est '\|/-'au lieu de '|/-\\').

Dans le passé, j'avais l'habitude -~ide vouloir i + 1éviter les parenthèses. (Merci à @ Flp.Tkc pour ces -2 octets!) (C'était i=(i+1)%4contre i=-~i%4)

Maintenant, je laisse simplement le compteur monter pour toujours, car techniquement, les Python intne peuvent pas déborder. Merci à @Zachary T pour l'avoir signalé et avoir sauvegardé un octet!
Il ne s’arrête que sur une machine car elle manque de mémoire, mais cela prend 9,7 générations avec 4 Go de mémoire pour celle-ci int.

Merci à @Kade pour l'octet -1 où les print a,bimpressions aet l' bespace sont séparés, pour que je n'aie pas besoin de mon propre espace.

Voici un exemple de travail sur Windows:

Je l'ai également testé sur une machine virtuelle Linux. Je n'ai pas pu le tester sur un Mac.

MATL , 36 octets

1 octet supprimé en utilisant l'idée de @ flawr de décaler la chaîne de façon circulaire

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

Voici un enregistrement gif du compilateur hors ligne:

Ou essayez-le sur MATL Online! S'il ne s'exécute pas initialement, actualisez la page et appuyez à nouveau sur "Exécuter".

Comment ça fonctionne

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

Cela ne fonctionne que dans la version Windows, sinon la ⎕SMfenêtre ne s'affichera que si elle ⎕SRest appelée.

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

Explication:

• {... }1: lance la fonction commençant par⍵=1
• Loading... '∘,¨'|/-\': générer les quatre sorties possibles
• ⊂⊃⍵⌽: Faites pivoter la liste pour placer le th élément en premier, prenez le premier élément et entourez-le
• ⎕SM←1 1,⍨: placez la chaîne dans le coin supérieur gauche de la ⎕SMfenêtre.
• ⎕DL÷4: attendez 1/4 de seconde
• 4|⍵+⌈: arrondissez la valeur résultante (secondes passées en attente, donc toujours 1), ajoutez-la à ⍵(incrémentez-la) et prenez le mod-4 (pour l’empêcher de déborder éventuellement).
• ∇: exécutez à nouveau la fonction avec le nouveau ⍵.

C #, 187 octets

Golfé:

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

J'attends toujours qu'il soit chargé ...

Snap !, 8 blocs

C’était l’un des tout premiers algorithmes que je me suis jamais imaginé sur une pomme] [e

réticulaire, non compétitif, 40 octets

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

J'ai oublié de commettre un tas de choses, y compris w. Tant pis.

Explication

: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 octets

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

Merci à beaucoup de gens pour les nombreux octets qui ont été joués au golf!

Perl 6 , 72 61 octets

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

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

> <> , 55 + 4 = 59 octets

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

Doit être exécuté en passant -t .01comme argument supplémentaire à l'interpréteur, c'est le +4 dans le nombre d'octets.

Cela permet de mettre les quatre caractères à imprimer sur la pile, d’imprimer le premier sans l’enlever et de décaler la pile d’une position. Ensuite, il imprime \b(retour arrière, caractère x08) et redémarre la boucle.

Le timing est obtenu par l'argument transmis à l'interprète, ce qui oblige à attendre 0,01 seconde avant d'exécuter chaque instruction. Il y a 23 instructions entre une sortie et la suivante (la plupart d'entre elles déplacent simplement le pointeur d'instruction vers la cellule suivante), de sorte que cela attend 0,23 seconde plus le temps nécessaire à l'exécution des instructions, ce qui correspond sans problème aux 0,25 demandés. avec 10% d'erreur.

Vous pouvez l' essayer en ligne , mais cet interprète ne reconnaît pas le caractère de retour arrière. Le résultat sera donc un peu étrange.

Fichier .COM MS-DOS, 56 octets

Voici le contenu du fichier en hexadécimal:

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

Le code assembleur correspondant ressemble à ceci:

    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 octets

Cela devrait être exécuté systèmes linux 64 bits

construit en utilisant:

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

animation:

enregistré 65 octets - merci utilisateur254948

R, 85 89 octets

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

Edit: Correction de la réponse telle que Tne débordera pas en réinitialisant le compteur si supérieur à 4.

Le seul aspect intéressant de cette réponse est l'utilisation de R de TRUTHYla builtin T. Il s’agit en fait d’une variable prédéfinie, 1/TRUEce qui signifie que nous n’avons pas à initialiser le compteur, mais que nous pouvons commencer à incrémenter T.

Haskell (GHC), 103 91 octets

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

Merci @nimi d'avoir économisé 12 octets!

C (sur les systèmes de type UNIX) 88 octets

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

Cela commence avec le mauvais personnage, mais je pense que ça a l'air plus joli. Vous pouvez facilement changer l'ordre des caractères en modifiant le "\ - / |" chaîne.

Perl, 71 63 61 octets

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

La version précédente:

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

Merci à @primo pour 10 octets.