Caricamento in corso ... Per sempre


106

La tua sfida è quella di creare una schermata di caricamento infinita, che assomigli a questa:

inserisci qui la descrizione dell'immagine


O, per essere più specifici:

  • Non dare input.
  • Output Loading..., con uno spazio finale, ma nessuna riga finale finale.
  • Ciclo all'infinito attraverso i caratteri |, /, -e \: ogni 0,25 secondi, sovrascrivere l'ultimo con il successivo nella sequenza. È possibile sovrascrivere solo l'ultimo carattere oppure eliminare e riscrivere l'intera riga, a condizione che Loading...rimanga invariato.

Regole

  • Il testo di output deve apparire esattamente come specificato. Newline / spazi finali sono accettabili.
  • Si dovrebbe Non attendere 0.25 secondi prima di mostrare inizialmente in uscita - il primo fotogramma deve essere stampato non appena il programma viene eseguito.
  • Il tuo programma dovrebbe essere in grado di funzionare all'infinito. Ad esempio, se si utilizza un contatore per i frame, il contatore non dovrebbe mai causare un errore superando il massimo nella propria lingua.
  • Sebbene il periodo di attesa tra ciascun "frame" dovrebbe essere di 0,25 secondi, ovviamente questo non sarà mai esatto - è consentito un margine di errore del 10% circa.
  • È possibile inviare una funzione, ma deve stampare su stdout.
  • È possibile inviare una risposta in un ambiente non console (ma ancora basato su testo), purché sia ​​in grado di produrre l'animazione di caricamento.
  • Questo è , quindi vince la soluzione più breve (in byte). Si applicano scappatoie standard per il golf da codice.
  • Se possibile, fornisci una gif della schermata di caricamento in azione.

Esempio

Ecco il codice C ++ che ho usato per creare l'esempio (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;
    }
}

Che vinca il migliore golfista!


3
Gli invii possono attendere 0,25 secondi prima di visualizzare l'output?
ETHproductions

2
No, ma grazie per averlo menzionato, lo aggiungerò alle regole @ETHproductions
FlipTack

È accettabile una nuova riga finale (dopo il simbolo di animazione)?
Rame

Certo :) @Copper
FlipTack

1
@TheBitByte significa che, teoricamente, nulla all'interno del programma può causare errori, ad esempio un contatore traboccante o il raggiungimento della massima profondità di ricorsione.
FlipTack,

Risposte:


76

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

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>

Modifica: 3 byte salvati grazie a @betseg. Risparmiato 17 byte grazie a @manatwork. Salvato 1 byte grazie a @Daniel. Salvato 13 byte grazie a @Ismael Miguel. Salvato 4 byte grazie a @Fez Vrasta.


4
Secondo meta, CSS + HTML va bene per rispondere alle domande. Inoltre ho permesso questo nella descrizione della sfida. Quindi questa risposta è perfettamente valida :)
FlipTack

5
HTML + CSS è TC, quindi non vedo perché potrebbe non essere competitivo
TuxCrafting

1
@ TùxCräftîñg Il CSS non è assolutamente completo in quanto puoi risolvere il problema di arresto in esso (Se non c'è animazione infinita, si ferma). Penso che lo stesso valga per l'HTML (se non includi JS).
Artyer,

4
@Artyer stackoverflow.com/a/5239256/3273184 è qualcosa da prendere in considerazione.
Mama Fun Roll

4
@MamaFunRoll Un commento su quel post menziona che non lo dimostra davvero TC perché non può essere eseguito senza l'intervento dell'utente. Tuttavia, può risolvere questa particolare sfida, quindi non vedo alcun problema con questa risposta.
ETHproductions

57

Vim, 43 , 41 byte

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

Due byte salvati grazie a @Udioica!

Ecco un'animazione (leggermente obsoleta) che accade in tempo reale!

enter image description here

Ed ecco una spiegazione:

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

1
solo curiosità: viola "Il tuo programma dovrebbe essere in grado di funzionare indefinitamente"? può eventualmente raggiungere un overflow dello stack? :)
Dan Oak,

4
@dahnoak Beh, ovviamente non posso testarlo all'infinito, ma non alloca memoria aggiuntiva, quindi non vedo alcun motivo per cui non funzionerebbe indefinitamente.
DJMcMayhem

1
Se passi ia Se lo sposti all'interno della macro, puoi saltare r|.
udioica,

2
@dahnoak Non c'è motivo per cui il motore vi non possa notare la ricorsione della coda. E alcune implementazioni della ricorsione lo farebbero naturalmente (immagina se ci sono un vettore di comandi da eseguire e una posizione di esecuzione corrente. Quindi @qinserisce nella posizione corrente il contenuto dello script di registro q. memoria allocata a meno che non ci sono i comandi da eseguire dopo @q all'interno q).
Yakk

Quasi ogni volta che pubblichi una risposta a una sfida, imparo qualcosa di nuovo (in questo caso @:e :sl), quindi grazie e continua a farli venire :)
Christian Rondeau,

37

HTML + JS (ES6), 20 + 51 50 = 70 byte

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

-1 byte (Zachary T)

Scopri anche la mia risposta HTML / CSS a 132 byte .


Potrebbe straripare i?
Zacharý,

Sì, alla fine lo sarebbe. Risolto questo!
darrylyeo,

1
Potresti sostituire i++,i%=4con i=-~i%4un byte?
Zacharý,

2
@Xufox L' <pre>unico modo sicuro per usare un carattere a spaziatura fissa era che le chunità funzionassero. Le regole non menzionano nulla sulla famiglia di caratteri utilizzata. ;)
darrylyeo,

1
Se non sbaglio, il primo carattere stampato da JS sarà l'ultimo nella stringa; quindi dovresti iniziare con -invece di /. O init con |e loop through '-\\|/'. Bel incremento però.
Tito

21

Windows Batch, 121 114 84 80 79 78 byte

Basta buttarlo fuori per divertimento.

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

Non sono stato in grado di assegnare pipe ( |) nell'array, quindi ho dovuto aggiungerlo manualmente con un altro compito.Il ritardo è terminato PING, il che potrebbe non essere preciso .

Produzione:

enter image description here

Modificare:

  • Grazie a Roman Gräf per aver salvato 7 byte!
  • Grazie a Neil per aver salvato 30 byte! L'ho anche modificato un po 'di più per salvare byte sulle newline.
  • Grazie a phyrfox per aver salvato 4 byte!
  • Grazie a YourDeathIsComing per aver salvato 2 byte!

3
Puoi rimuovere @echo offe mettere un @davanti a ogni seto echocomando
Roman Gräf,

1
Non hai bisogno dell'array, in (/ - \ ^|)funziona. Inoltre,% 0 è un modo più breve per eseguire il ciclo di goto.
Neil,

2
Dovresti essere in grado di utilizzare l'indirizzo IP "1.1" (-4 byte), poiché la maggior parte delle piattaforme lo espanderà automaticamente a 1.0.0.1.
phyrfox

1
È possibile salvare 1 byte rimuovendo lo spazio davanti >nul.
YourDeathIsComing

1
Intendevo lo spazio prima, non dopo.
YourDeathIsComing

20

Nodo, 72 70 byte

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

Sostituisci \x1Bcon il carattere di escape letterale per ottenere il conteggio di byte corretto. Chiama f()per avviare l'animazione. Ecco come appare nell'emulatore di terminale ConEmu sul mio computer:

enter image description here


Prova a utilizzare \033c(sostituisci \033con la sua rappresentazione char effettiva). Non sembra buono, ma ti fa risparmiare qualche byte.
Mama Fun Roll

Non itraboccare?
Zacharý,

12
@ZacharyT Lo farà dopo 71 milioni di anni, ma posso aggiustarlo se necessario
ETHproductions

3
"Il tuo programma dovrebbe essere in grado di funzionare all'infinito. Ad esempio, se usi un contatore per i frame, il contatore non dovrebbe mai causare un errore superando il massimo nella tua lingua.", Sì, è necessario.
Zacharý,

3
@Florent Ma poi non funzionerebbe su Node ;-)
ETHproductions

14

Kotlin, 67 66 byte

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

enter image description here

Abbastanza autoesplicativo, usando \rper cancellare la linea e approfittare della straordinaria interpolazione di stringhe di Kotlin.

EDIT: salvato 1 byte grazie a @ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu cambiando while(true)inwhile(1>0)


1
Puoi salvare un byte usando while(1>0)invece di while(true)(-1) e probabilmente dovresti includere la sintassi della funzione effettiva nella tua risposta ( fun a(){<code>}, +9). Se vuoi essere un po 'economico, puoi usare store a function come variabile ( val a={<code>}, +8).
F. George,

2
@ mEQ5aNLrK3lqs3kfSa5HbvsTWe0nIu La modalità "programma completo" non è accettabile? Questo può essere eseguito come uno script Kotlin .ktssenza definizioni di classe o funzione. Inoltre, ottima chiamata con while(1>0)!
Tyler MacDonell,

3
Ma cosa succede se, un giorno, 0 diventa maggiore di 1 ???? : P
FlipTack,

Ottima idea di usare lo script Kotlin. @ Flp.Tkc Il tuo commento mi ha ricordato questo: codegolf.stackexchange.com/a/101131/62024 . Rabbrividendo ancora che questo è possibile.
F. George,

@TylerMacDonell Davvero? Non sapevo che avresti potuto eseguire kotlin direttamente come script. Grazie per le informazioni.
TheNumberOne

14

Vim, 35 byte

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

La versione noiosa. Ecco una soluzione non conforme che è meglio:

Vim (1 secondo di sospensione), 27 byte

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

L'uso gsnon solo è molto più breve, ma non è necessario premere Invio. Ciò significa che la macro si adatta in linea e posso salvare byte passando a @.. (Dal momento che nulla dopo la chiamata ricorsiva può mai essere eseguito, posso digitare quello che voglio.)


Grazie per questa risposta! Ho imparato gs, @.e @@all'interno @.ancora mi fa male la testa!
Christian Rondeau,

14

Pyth, 31 byte

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

Interprete qui .

Loading GIF

Spiegazione

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

13

Powershell (v4), 57 56 54 53 58 57 byte

Torna al Bytecount con cui ho iniziato!

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

L'interfaccia della riga di comando in PowerShell si spegnerà leggermente su alcuni computer, quindi non sembra perfetta, ma è buona quanto posso ottenere.

Spostato $ a ++ nel ciclo for per salvare un byte, (no ;)

Quindi lo ha spostato nell'indicizzatore di array, per un altro salvataggio di 2 byte, grazie a Roman per averlo sottolineato.

Inoltre ho salvato un altro byte ( ;) spostando la parte Clear screen ( cls) nel ciclo for ..

Problema e correzione segnalati da TimmyD per l'aspetto infinito della domanda, richiesti solo +5 byte, modificati $a++%4in ($a=++$a%4)modo che non superino mai i 3.

Hai salvato un altro byte lasciando vuoto il ciclo for, grazie a "qualunque" per aver sottolineato che ciò è effettivamente possibile nella versione 4 di Powershell!

Nuova gif aggiornata per la versione (finale?) Di questa risposta.

Loading 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}


2
for(;;){"Loading... "+"|/-\"[$a++%4];sleep -m 250;cls}(spostare l' $a++ultimo utilizzo di $a)
Roman Gräf,

dimenticando sempre qualcosa - grazie per quello!
Colsw,

2
Non sono molto esperto in Powershell, ma quando ho visto la voce di Windows Batch, ho pensato "Potrebbe Powershell battere questo?". Ed eccolo qui!
Jakub Jankowski il

1
Almeno su ps v4 dovresti essere in grado di golf un altro byte mantenendo la condizione for totalmente vuota:for(){cls;"Loading... "+"|/-\"[($a=++$a%4)];sleep -m 250}
qualunque sia il

1
Prego. In realtà sembra funzionare per la versione 2+, era troppo pigro per controllare prima;)
qualunque sia il

11

Pyth - 36 35 byte

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

Non funziona online, ovviamente.


Hai una gif di questo in azione? Inoltre, c'è qualche contatore che potrebbe traboccare?
FlipTack,

@ Flp.Tkc l'unico contatore è Zquale è un numero intero in Python, che non trabocca. Stavo cercando di fare una gif ma non sono riuscito a farlo funzionare. Se sai come crearne uno, puoi eseguirlo con l'interprete pyth su github.com/isaacg1/pyth
Maltysen

4
Se il numero intero non trabocca, probabilmente crescerà fino a riempire tutta la memoria, il che farebbe fallire almeno dopo 10⁶⁵⁰⁰⁰⁰⁰⁰⁰ anni sulla maggior parte dei sistemi a 32 bit. Certo, la morte termica dell'universo accadrà per prima, ma comunque ...
jjrv,

11

Matlab, 78 75 byte

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

enter image description here


11

HTML / CSS, 23 + 109 = 132 byte

Migliorato sulla risposta di Neil .

pre{display:flex}a{overflow:hidden;animation:a 1s steps(4)infinite;width:1ch}@keyframes a{to{text-indent:-4ch
<pre>Loading... <a>|/-\


9

Mathematica, 74 67 byte

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

Un enorme 7 byte grazie a @dahnoak


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

1
@dahnoak cheers! Non avevo capito che ListAnimate era una cosa. È un peccato che <>sia piatto non elencabile, altrimenti potrebbero essere eliminati altri 4 byte!
A Simmons,

Solo per divertimento:Dynamic["Loading... "<>{"|","/","-","\\"}[[1+Round[4Now@"Second"]~Mod~4]],UpdateInterval->.25]
Shrx il

9

C #, 170 133 byte

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

Grazie mille a Roman Gräf e raznagul, che mi hanno salvato 37 byte. (Soprattutto raznagul, che ha sottolineato, che la mia soluzione originale non era valida comunque. Mi sono perso qualcosa, ma ora è stato risolto e dovrebbe soddisfare i requisiti :)

abbastanza simile alla risposta C # esistente di Pete Arden ma con alcuni miglioramenti

ad es. "for (;;)" invece di "while (true)", char anziché string

Avrei commentato i miei suggerimenti sulla sua risposta, ma in realtà non ho abbastanza reputazione per farlo.

Ungolfed:

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

2
Perché non rimuovere il primo Console.Write("\b");e cambiare il secondo in Console.Write("\b"+a);?
Roman Gräf,

La definizione di un'azione è superflua e l'utilizzo prolungato di un ciclo simile foreach(var a in"|/-\\")e l'aggiunta del codice attualmente presente nell'azione in quanto il corpo ti farà risparmiare ~ 20 byte.
raznagul

Inoltre, il compito è quello di creare esattamente l'output richiesto. Che attualmente non è il caso.
raznagul

Dovrebbe essere il caso adesso, ho dimenticato '|' e lo spazio finale dopo "Caricamento in corso ...".
Snowfire

Nella tua versione non golfata (poiché non corrisponde alla versione giocata a golf), puoi rimuovere la prima Console.Write()e usare solo una Console.Write($"Loading... {c}\r")invece della seconda.
latte,

9

Via, 72, 73 byte

MODIFICA :

  • Aggiunta la versione solo Gforth, 69 byte (Grazie @ninjalj!)
  • Aggiunto spazio vuoto mancante dopo "Caricamento in corso ..." (Thx @Roman Gräf!), +1 byte
  • Aggiornato per abbinare le regole in modo più preciso (nello stesso conteggio byte)

golfed

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

Versione Gforth

La versione solo per GNU Forth può essere ridotta a 69 byte in questo modo:

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

screencast

enter image description here

Provalo online!


1
Dato che stai usando gforth, se non ti interessa la portabilità ad altri Forth, puoi usare [begin]e [again]al di fuori di una definizione di parola.
ninjalj,

9

Python 2, 81 79 78 77 byte

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

Piuttosto una soluzione semplice che dorme usando time .

Io uso \r (Ritorno a capo) per tornare all'inizio della riga e quindi stampare il messaggio sovrascrivendo la riga.

Comincio con i=1per evitare il doppio escape del \'\|/-'invece di '|/-\\').

In passato, avevo usato -~iper significare i + 1per evitare parentesi. (Grazie a @ Flp.Tkc per questi -2 byte!) (Era i=(i+1)%4vs. i=-~i%4)

Ora, sto solo lasciando che il contatore salga per sempre, dal momento che tecnicamente Python intnon può traboccare. Grazie a @Zachary T per averlo sottolineato e salvato un byte!
Si ferma solo su una macchina perché la macchina ha esaurito la memoria, ma ciò richiede 9,7 generazioni con 4 GB di memoria per quella int.

Grazie a @Kade per il -1 byte in cui print a,bstampe ae bspazio sono separati, quindi non ho bisogno del mio spazio.

Ecco una gif che funziona su Windows:

Loading

L'ho provato anche su una VM Linux. Non ho potuto provarlo su un Mac.


1
Se ricordo bene, puoi usare i=-~i%4per salvare i byte per le parentesi :)
FlipTack

2
Non sostituirà [i],;i=-~i%4con [i%4],;i+=1un byte di salvataggio poiché non supera il massimo per Python, solo la memoria massima?
Zacharý,

9
Dovrei sottovalutarti per aver effettuato l'accesso come Administrator...
Neil,

5
@Neil Ad essere sincero, ho appena messo il file Python in Administrator e l'ho eseguito da lì perché gli altri nomi di account sono nomi reali (Personal PC).
Artyer,

2
Consentirei il suggerimento di @ZacharyT dato che tecnicamente gli interi Python possono essere infinitamente grandi, purché il computer abbia memoria per trattenerli
FlipTack,

7

MATL , 36 byte

1 byte rimosso usando l'idea di @ flawr di spostare circolarmente la stringa

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

Ecco una registrazione gif dal compilatore offline:

enter image description here

Oppure provalo su MATL Online! Se inizialmente non viene eseguito, aggiornare la pagina e premere nuovamente "Esegui".

Come funziona

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

Ehi Luis. ben fatto con MATL come sempre. Ecco una leggera variazione dell'elenco circolare. e display. Pensi di poterlo tradurre in una soluzione ancora più breve:a='\|/-';k=1; fprintf('Loading... -') while 1 k=mod(k,4)+1; fprintf('\b\b%c\n',a(k)); pause(.25); end
Hoki,

@Hoki Grazie per l'idea. In realtà inizialmente avevo un contatore crescente modulo 4, ma era un po 'più lungo (poi ho guadagnato un byte a causa del requisito di nessuna pausa iniziale). Inoltre, penso che lo schermo chiaro e il display normale siano più brevi rispetto fprintfa quelli posteriori
Luis Mendo il

7

Dyalog APL, 50 byte

Funziona solo nella versione Windows, altrimenti la ⎕SMfinestra non mostrerà se non ⎕SRviene chiamata.

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

Spiegazione:

  • {... }1: avvia la funzione che inizia con⍵=1
  • Loading... '∘,¨'|/-\': genera le quattro possibili uscite
  • ⊂⊃⍵⌽: Ruota l'elenco per inserire prima il primo elemento, prendi il primo elemento e racchiudilo
  • ⎕SM←1 1,⍨: posiziona la stringa nell'angolo in alto a sinistra della ⎕SMfinestra.
  • ⎕DL÷4: attendere 1/4 di secondo
  • 4|⍵+⌈: arrotondare per eccesso il valore risultante (secondi trascorsi in attesa, quindi è sempre 1), aggiungerlo a (incrementandolo) e prendere il mod-4 (per evitare che alla fine trabocchi).
  • : esegue nuovamente la funzione con il nuovo .

Animation


In qualche modo sapevo che qualcuno avrebbe inviato una risposta a questa sfida per Dyalog (/ APL) :)
YoYoYonnY,

7

C #, 187 byte

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

Aspetto ancora che si carichi ...

enter image description here



@manatwork Oh merda, copia e incolla pigri. Risolverò quando tornerò alla mia scrivania a breve :)
Pete Arden,

Mi dispiace vedere la tua soluzione allungarsi a causa del mio commento. Non puoi usare 1>0invece di trueriportarlo a 186?
arte

@ErikGolfer エ リ ッ ク ゴ ル フ ァ ー, nessuna idea su C #, ma in base al fatto che il linguaggio è una copia di Java e apparentemente confermato da Can't cast int to bool , ho pensato che non avrebbe funzionato. (A proposito, se funziona, forse usare la prima chiamata di l()come condizione funzionerebbe anche?)
manatwork

2
@manatwork Beh, sembra che C # sia ungolfabile.
Erik the Outgolfer,


6

reticolare, non competitivo, 40 byte

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

enter image description here

Ho dimenticato di commettere un sacco di cose, incluso w. Oh bene.

Spiegazione

: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

Bash, 98 69 byte

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

Grazie a molte persone per i tanti byte giocati a golf!


Inoltre, non devi sfuggire alla barra rovesciata se usi virgolette singole e gli argomenti per echo -e -npossono essere combinati aecho -en
Evan Chen,

È possibile salvare 2 righe e 13 byte sostituendo la riga dell'eco in:echo -en "\rLoading... ${s:i=(i+1)%4:1}"
Ipor Sircer,

echo -enprintf; rendere il compito s whilecondizione.
arte

utilizzare printf come manatwork detto, semplificare la stringa, e metterlo direttamente nella whilecondizione: while printf "\rLoading... ${s:i++%4:1}";do. 67 byte
Dominik R,

Non funzionerà Dominik R, potrebbe eventualmente traboccare.
Zacharý,

6

Perl 6 , 72 61 byte

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

6

> <> , 55 + 4 = 59 byte

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

Deve essere eseguito passando -t .01 come argomento aggiuntivo all'interprete, ovvero il +4 nel conteggio dei byte.

Ciò che fa è mettere i quattro personaggi da stampare in pila, stampando quello in alto senza rimuoverlo e spostando la pila di una posizione. Quindi stampa\b (backspace, carattere x08) e riavvia il ciclo.

Il tempismo è raggiunto dall'argomento passato all'interprete, che forza ad attendere 0,01 secondi prima di eseguire ciascuna istruzione. Esistono 23 istruzioni tra un'uscita e la successiva (la maggior parte di esse sposta semplicemente il puntatore delle istruzioni sulla cella successiva), quindi questo attenderà 0,23 secondi più il tempo necessario per eseguire le istruzioni, che si adatta senza problemi agli 0,25 richiesti con errore del 10%.

Potresti provarlo online , ma quell'interprete non riconosce il carattere backspace, quindi l'output sarà un po 'strano lì.


Normalmente i flag come -nvengono segnati come 1 byte, quindi penso che puoi segnare l'argomento come t, .01che è di 4 byte. Buon uso della regola del 10% tra l'altro :)
FlipTack,

@ Flp.Tkc Grazie! Non ero sicuro di come contare i byte per l'argomento, mi piace così :)
Leo,

@Leo - C'è un motivo per usare 0.01 e non un segno di spunta più grande con meno istruzioni? Ho aggiunto la mia versione che utilizza un ciclo di 8 istruzioni e il conteggio dei tick di 0,03; # "... gnidaoL" l?! vob0. "\ | / -": o} 8o51. > #
Teal pelican

@Tealpelican C'è una ragione, ma non è molto buona: le regole affermano che "Non dovresti aspettare 0,25 secondi prima di mostrare inizialmente l'output - il primo fotogramma dovrebbe essere stampato non appena il programma viene eseguito", quindi non ho fatto non voglio allungare troppo il timer, mentre d'altra parte si tratta di code golf, quindi non volevo renderlo troppo breve. Alla fine ho deciso per un ciclo di 25 istruzioni che impiegava 0,01 ciascuna per ottenere il tempo esatto di 0,25 richieste; quando l'ho implementato, però, mi sono reso conto che mi mancava abbastanza spazio per l'intero ciclo, quindi ho dovuto ricorrere all'uso della regola del 10%.
Leone,

Devo aver letto male le regole. Questa è una ragione perfettamente valida per i tempi :)
Pellicano verde acqua

6

File .COM MS-DOS, 56 byte

Qui il contenuto del file in esadecimale:

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

Il codice dell'assemblatore corrispondente è simile al seguente:

    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
Tenendo premuto un tasto si accelera lo spinner, che può essere risolto mascherando interruzioni diverse dall'interruzione del timer, ad esempio:mov al, 0xfe / out 0x21,al
ninjalj

Il commento per HLT è errato, probabilmente intendevi che HLT si sveglia a ~ 18,2 Hz (o, più precisamente, con orologio NTSC / 12/65536 Hz).
ninjalj,

@ninjalj Grazie. Ho cambiato il commento ...
Martin Rosenau il

6

NASM x86_64 - 349 283 byte

Dovrebbero essere eseguiti sistemi Linux a 64 bit

costruito usando:

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

animazione:

salvato 65 byte - grazie user254948

enter image description here


Conto 349 byte, a meno che non ci sia una nuova riga / spazio finale
FlipTack,

^ Flp. Grazie, c'era una linea con uno spazio alla fine
Samuel,

@ Samuel sono necessarie le linee 13-17? Sembra funzionare abbastanza bene senza quelle linee. Per quanto ne so (temo che non sia fantastico nell'assemblaggio) stampi il caricamento ...., quindi il | carattere, quindi rimuovere quel carattere, quindi inserire un ciclo in cui si ripete la stampa di | per la prima volta.
user254948

@Samuel inoltre xor r8, r8 -> mov r8,0 (salva 1 carattere), alcuni MOV hanno uno spazio extra (mov r7, 1 -> mov r7,1). inoltre le istruzioni cmp r8,4, jl l, xor r8, r8, possono essere sostituite da AND r8,3 (salvataggio di 15 caratteri). Dovresti essere giù a 285 byte invece di 349! (in combinazione con le righe sopra menzionate)
user254948

5

R, 85 89 byte

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

Modifica: risolto il problema in modo tale che Tnon traboccasse ripristinando il contatore se maggiore di 4.

L'unico aspetto interessante di questa risposta è l'uso di R TRUTHYintegrato T. È effettivamente un set di variabili predefinito, il 1/TRUEche significa che non è necessario inizializzare il contatore, ma è possibile iniziare l'incremento T.


Sarebbe Tfinalmente traboccare?
FlipTack,

@ Flp.Tkc Non traboccherebbe ma verrebbe trattato come un passato infinito, 1e+308nel qual caso NAviene restituito, quindi suppongo che questa risposta non sia valida allora (non l'ho notato nelle regole). Si aggiornerà presto
Billywob il

1
In realtà è possibile ottenerlo più corto di 2 byte se non si utilizza il built-in T: i=1;repeat{cat("\rLoading...",c("\\","|","/","-")[i]);Sys.sleep(.25);i=`if`(i>3,1,i+1)}è di 87 byte.
plannapus,

Hmm ... R funziona solo su vettori? Perché non ci sono operatori modulo o bit a bit per gli atomi? è Tun vettore? Funziona T=(T+1)%%4? Salverebbe altri 5 byte.
Tito

2
... oppure T=T%%4+1: anche 2 byte più brevi.
Tito

5

Haskell (GHC), 103 91 byte

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

Grazie @nimi per aver salvato 12 byte!


Non è necessario un programma completo. mapM((threadDelay 250000>>).putStr)$("\rLoading... "++).pure<$>cycle"|/-\\".
nimi,

Due byte possono essere salvati utilizzando la tolleranza del 10% e la sostituzione 250000e lo spazio precedente (4^9).
Christian Sievers,

5

C (su sistemi tipo UNIX) 88 byte

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

Inizia con il personaggio sbagliato, ma penso che sia più bello. Puoi facilmente cambiare l'ordine dei caratteri modificando "\ - / |" corda.


Potrebbe essere ulteriormente golfato spostando le dichiarazioni in for, ad esempio ain(_){for(;printf("\rLoading... %c","\\-/|"[_%4]);usleep(250000))_++,fflush(0);}main(_){for(;printf("\rLoading... %c","\\-/|"[_++%4]);usleep(250000))fflush(0);}
:,

Hai bisogno di fflush () lì dentro?
Giovanni U

Sulla maggior parte dei sistemi è necessario il fflush, molti dei quali basati su newline buffer. Tuttavia è possibile che non sia necessario su alcuni sistemi.
LambdaBeta,

È possibile utilizzare fprintf(stderr,...invece, poiché non è un buffer di linea come stdout. Il f...stderr,prende otto personaggi, mentre il fflush(0);prende dieci, quindi è una vittoria netta di due personaggi.
cmaster

5

Perl, 71 63 61 byte

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

Versione precedente:

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

Grazie a @primo per 10 byte.


2
Bel trucco per usare il selecttimeout piuttosto che Time::HiRes. È possibile salvare alcuni byte utilizzando ... while$|=printe spostando i trattini nella traslitterazione in primo piano e in fondo. s//\r Loading... |/salva anche un byte sull'assegnazione.
primo

2
E anche, se si utilizza virgolette singole per il delimitatore traslitterazione, non c'è bisogno di sfuggire al backslash o: y'-\|/'\|/-'.
primo

Sembra che tu abbia uno spazio extra prima del tuo codice.
Erik the Outgolfer,

1
È possibile salvare un altro byte utilizzando un valore letterale \r.
ninjalj,

1
Utilizzare y'-|\/'\/|-'/4al posto di .25per altri 2.
primo
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.