Crie uma barra de carregamento no estilo Windows seguindo as seguintes instruções.

^{(observe que isso é diferente de Loading ... Forever )}

Sua saída deve começar por [.... ].

A cada tick, você deve esperar 100 ms e depois mover cada ponto um caractere para a direita. se o ponto estiver no décimo caractere, mova-o para o primeiro. Observe que você deve limpar a tela antes de imprimir novamente. A saída é ordenada da seguinte forma:

[....      ]
[ ....     ]
[  ....    ]
[   ....   ]
[    ....  ]
[     .... ]
[      ....]
[.      ...]
[..      ..]
[...      .]

..Then loops para sempre.

Regras

• Isso é código-golfe , então a resposta mais curta ganha ^{, duvido que eu aceitaria uma resposta vencedora.}
• Forneça um arquivo gif da barra de carregamento em ação, se possível.

V, 17 16 15 bytes

i[´.¶ ]<esc>ògó$X|p

<esc>é 0x1b.

E o hexdump:

00000000: 695b b42e b620 5d1b f267 f324 587c 70    i[... ]..g.$X|p

Explicação

i                       " Insert
[                       " a [
´.                      " 4 .s
¶<space>                " 6 spaces
]<esc>                  " and a ]. Then return to normal mode
ò                       " Recursively do:
 gó                     "  Sleep for 100 milliseconds
 $                      "  Go to the ]
 X                      "  Delete the character to the left of the ]
 |                      "  Go to the [
 p                      "  And paste the deleted character right after the [
                        " Implicit ending ò

CSS / HTML, 202 190 186 + 45 = 247 235 231 bytes

pre{position:relative}x{position:absolute;display:inline-block;width:10ch;height:1em;overflow:hidden}x>x{width:14ch;left:-10ch;animation:1s steps(10,end)infinite l}@keyframes l{to{left:0

<pre>[<x><x>....      ....</x></x>          ]

Edit: Salvo 12 14 bytes graças a @Luke.

PowerShell, 67 66 bytes

for($s='.'*4+' '*6;$s=-join($s[,9+0..8])){cls;"[$s]";sleep -m 100}

-1 usando o construtor reduzido, graças ao Beatcracker

substitui a sequência por uma cópia da sequência em que o último caractere é colocado na frente dos caracteres restantes, limpa a tela, imprime e dorme por 100 ms.

economizou muitos bytes usando o construtor de loop for em vez de quebrar a lógica dentro da string.

Python 3 , 99 93 85 83 + 2 ( sinalizador -u ) bytes

^{-12 bytes graças a ovs
-2 bytes graças a totallyhuman}

import time
s=4*'.'+6*' '
while 1:print(end='\r[%s]'%s);time.sleep(.1);s=s[9]+s[:9]

Experimente online!

Lote do Windows, 201 181 bytes

Acontece que o método da velha escola realmente salva bytes!

@for %%p in ("....      " " ....     " "  ....    " "   ....   " "    ....  " "     .... " "      ...." ".      ..." "..      .." "...      .")do @echo [%%~p]&timeout 0 >nul&cls
@%0

Nota:

get-screenrecorder.level
- low grade

get-gpu.level
- horrible

if get-screenrecorder.level == low grade || get-gpu.level == horrible {
     say("GIF may not be accurate");
}

Observe que meu gravador GIF pulou alguns quadros, fazendo a barra de carregamento saltar :(

Mathematica, 67 77 Bytes

10 bytes como eu esqueci os colchetes.

Animate["["<>"....      "~StringRotateRight~n<>"]",{n,1,10,1},RefreshRate->10]

C (gcc) , 126 125 124 123 122 121 119 118 117 114 115 bytes

Este usa uma máscara de bits para acompanhar onde estão os pontos.

Eu tive que adicionar outro byte, pois estava produzindo apenas 5 espaços antes.

m=30;f(i){usleep(3<<15);system("clear");for(i=1;i<1920;i*=2)putchar(i^1?i&m?46:32:91);m+=m&512?m+1:m;f(puts("]"));}

Experimente online!

Javascript (ES6), 86 bytes

setInterval('with(console)clear(),log(`[${x=x[9]+x.slice(0,9)}]`)',100,x='...      .')

JavaScript (ES6) + HTML, 104 85 83 bytes

f=(s="....      ")=>setTimeout(f,100,s[9]+s.slice(0,9),o.value=`[${s}]`)
<input id=o

• Economizei 2 bytes graças à sugestão de Johan de usar um em inputvez de um pre.

Tente

Requer um fechamento >na inputtag para funcionar em um snippet.

(f=(s="....      ")=>setTimeout(f,100,s[9]+s.slice(0,9),o.value=`[${s}]`))()

<input id=o>

Noodel , 16 15 14 13 bytes

[CỤ'Ṁ ~ ððÐ] ʠḷẸḍt

] ʠ [Ð. × 4¤ × 6⁺ḷẸḍt

] ʠ⁶¤⁴.ȧ [ėÐḷẸḍt

Tente:)

Como funciona

]ʠ⁶¤⁴.ȧ[ėÐḷẸḍt

]ʠ⁶¤⁴.ȧ[ėÐ     # Set up for the animation.
]              # Pushes the literal string "]" onto the stack.
 ʠ             # Move the top of the stack down by one such that the "]" will remain on top.
  ⁶¤           # Pushes the string "¤" six times onto the stack where "¤" represents a space.
    ⁴.         # Pushes the string "." four times onto the stack.
      ȧ        # Take everything on the stack and create an array.
       [       # Pushes on the string literal "[".
        ė      # Take what is on the top of the stack and place it at the bottom (moves the "[" to the bottom).
         Ð     # Pushes the stack to the screen which in Noodel means by reference.

          ḷẸḍt # The main animation loop.
          ḷ    # Loop endlessly the following code.
           Ẹ   # Take the last character of the array and move it to the front.
            ḍt # Delay for a tenth of a second.
               # Implicit end of loop.

Atualizar

[Ð]ıʠ⁶¤⁴.ḷėḍt

Tente:)

Não sei por que isso me levou um tempo para pensar. De qualquer forma, isso coloca em 13 bytes .

[Ð]ıʠ⁶¤⁴.ḷėḍt

[Ð]ıʠ⁶¤⁴.     # Sets up the animation.
[             # Push on the character "["
 Ð            # Push the stack as an array (which is by reference) to the screen.
  ]           # Push on the character "]"
   ı          # Jump into a new stack placing the "[" on top.
    ʠ         # Move the top of the stack down one.
     ⁶¤       # Push on six spaces.
       ⁴.     # Push on four dots.

         ḷėḍt # The main loop that does the animation.
         ḷ    # Loop the following code endlessly.
          ė   # Take the top of the stack and put it at the bottom.
           ḍt # Delay for a tenth of a second.

<div id="noodel" code="[Ð]ıʠ⁶¤⁴.ḷėḍt" input="" cols="12" rows="2"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

PHP, 67 bytes

for($s="...      .";$s=substr($s.$s,9,10);usleep(1e5))echo"\r[$s]";

sem comentários

C #, 162 157 bytes

()=>{for(string o="[....      ]";;){o=o.Insert(1,o[10]+"").Remove(11,1);System.Console.Write(o);System.Threading.Thread.Sleep(100);System.Console.Clear();}};

ou como um programa completo para 177 bytes

namespace System{class P{static void Main(){for(string o="[....      ]";;){o=o.Insert(1,o[10]+"").Remove(11,1);Console.Write(o);Threading.Thread.Sleep(100);Console.Clear();}}}}

Festa pura, 68

s=${1:-....      }
printf "[$s]\r"
sleep .1
exec $0 "${s: -1}${s%?}"

MATL , 24 bytes

`1&Xx'['897B@YS46*93hhDT

Experimente no MATL Online! Ou veja um gif do compilador offline:

Explicação

`        % Do...while
  1&Xx   %   Pause for 0.1 s and clear screen
  '['    %   Push this character
  897B   %   Push [1 1 1 0 0 0 0 0 0 1]
  @      %   Push current iteration index, 1-based
  YS     %   Circularly shift the array by that amount
  46*    %   Multiply by 46 (code point of '.')
  93     %   Push 93 (code point of ']')
  hh     %   Concatenate horizontally twice. Numbers are interpreted as chars
         %   with the corresponding code points
  D      %   Display
  T      %   Push true. Used as loop condition. Results in an infinite loop
         % End (implicit)

Geléia , 28 27 bytes

ṙ©-j@⁾[]ṭ”ÆȮœS.1®ß
897ṃ⁾. Ç

Quão?

ṙ©-j@⁾[]ṭ”ÆȮœS.1®ß - Link 1, the infinite loop: list of characters s
ṙ                  - rotate s left by:
  -                -   -1 (e.g. "...      ." -> "....      ")
 ©                 -   copy to the register and yield
     ⁾[]           - literal ['[',']']
   j@              - join with reversed @rguments
         Ӯ        - literal '\r'
        ṭ          - tack (append the display text to the '\r')
           Ȯ       - print with no newline ending
              .1   - literal 0.1
            œS     - sleep for 0.1 seconds then yield the printed text (unused)
                ®  - recall the value from the register
                 ß - call this link (1) again with the same arity

897ṃ⁾. Ç - Main link: no arguments
897      - literal 897
    ⁾.   - literal ['.',' ']
   ṃ     - base decompression: convert 897 to base ['.',' '] = "...      ."

C (gcc), 202 198 196 189 96 99 88 86 79 77 75 74 73 bytes

Economizou 7 8 bytes graças ao Digital Trauma .

f(i){usleep(dprintf(2,"\r[%-10.10s]","....      ...."+i%10)<<13);f(i+9);}

Ou, se o sistema stdoutnão precisar ser liberado após cada gravação sem uma nova linha:

C (gcc), 70 bytes

f(i){usleep(printf("\r[%-10.10s]","....      ...."+i%10)<<13);f(i+9);}

Como funciona

• usleep( dorme pelo próximo valor de retorno em microssegundos.
• dprintf(2,imprime no descritor de arquivo 2 ou stderr. Isso é necessário porque enquanto stdoutestiver com buffer de linha (o que significa que a saída não será exibida até que ela imprima uma nova linha), stderré com buffer de caracteres (toda a saída é mostrada imediatamente).
• "\r imprime um retorno de carro (limpa a linha atual).
• [%-10.10s]" é o printf especificador de formato para uma sequência com o comprimento exato 10 (independentemente da sequência fornecida, a saída sempre será uma sequência com o comprimento 10), preenchida com espaços à direita, se necessário. Isso será incluído entre colchetes.
• ".... ...." é a barra de carregamento.
• +i%10compensações da barra de carregamento pela corrente módulo índice de 10. Por exemplo, se i == 3, i % 10é igual a 3. Compensação a barra de carregamento por 3 faz com que seja igual a". ...." .
• Quando a sequência deslocada é passada para o printfespecificador de formato, ela limita a um comprimento de 10, se necessário, e adiciona espaços ao final, se necessário. Portanto, a barra de carregamento estará sempre entre [.... ]e [. ...].

Java 7, 139 124 bytes

String s="....      ";void c()throws Exception{System.out.print("["+s+"]\r");s=(s+s).substring(9,19);Thread.sleep(100);c();}

• Menção de \ragradecimento a @Phoenix .

O retorno de carro \r redefine o 'cursor' de volta ao início da linha, que pode ser substituído. Infelizmente, os compiladores on-line nem o IDE Eclipse não suportam isso, então adicionei um gif no final desta resposta para mostrá-lo no prompt de comando do Windows.

Experimente aqui. (Levemente modificado para que você não precise esperar o tempo limite antes de visualizar o resultado. Além disso, o TIO não oferece suporte a retornos de carro, portanto, cada linha é impressa sem substituir a linha anterior.)

Explicação:

String s="....      ";            // Starting String "....      " on class level
void c()                          // Method without parameter nor return-type
 throws Exception{                // throws-clause/try-catch is mandatory for Thread.sleep
  System.out.print("["+s+"]\r");  //  Print the String between square-brackets,
                                  //  and reset the 'cursor' to the start of the line
  s=(s+s).substring(9,19);        //  Set `s` to the next String in line
  Thread.sleep(100);              //  Wait 100 ms
  c();                            //  Recursive call to same method
}                                 // End of method

Gif de saída:

Python 2 , 81 78 bytes

-1 byte (percebendo que eu perdi o uso %squando Rod enviou uma versão quase idêntica do Python 3 ao mesmo tempo!)
-2 bytes (usando a idéia de totalmente humano - substitua s[-1]+s[:-1]por s[9]+s[:9])

import time
s='.'*4+' '*6
while s:print'\r[%s]'%s,;s=s[9]+s[:9];time.sleep(.1)

Go , 150 145 132 129 124 bytes

-5 bytes graças ao sudee.

Eu sinto que não vejo o suficiente. Vá aqui ... Mas minha resposta está no topo de C, então ... pls halp golf?

package main
import(."fmt"
."time")
func main(){s:="....      ";for{Print("\r["+s+"]");Sleep(Duration(1e8));s=(s+s)[9:19];}}

Experimente online!

VBA de 32 bits, _{159 157 143 141} 134 Bytes

O VBA não possui uma função integrada que permita aguardar períodos inferiores a um segundo, portanto, devemos declarar uma função de kernel32.dll

Declaração de declaração de 32 bits (41 bytes)

Declare Sub Sleep Lib"kernel32"(ByVal M&)

Declaração de declaração de 64 bits (49 bytes)

Declare PtrSafe Sub Sleep Lib"kernel32"(ByVal M&)

Além disso, devemos incluir um DoEvents sinalizador para evitar que o loop infinito faça com que o Excel apareça como não responsivo. A função final é então uma sub-rotina que não recebe nenhuma entrada e sai para a janela imediata do VBE.

Função imediata da janela, 93 bytes

Função de janela imediata VBE anônima que não leva nenhuma entrada e saída para o intervalo A1no ActiveSheet

s="...      ....      .":Do:DoEvents:Sleep 100:[A1]="["&Mid(s,10-i,10)&"]":i=(i+1)Mod 10:Loop

Versão antiga, 109 bytes

Função de janela imediata que não recebe entradas e saídas para a janela imediata do VBE.

s="...      ....      .":i=0:Do:DoEvents:Sleep 100:Debug.?"["&Mid(s,10-i,10)&"]":i=(i+1) Mod 10:Loop

Ungolfted e formatado

Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal M&)
Sub a()
    Dim i As Integer, s As String
    s = "...      ....      ."
    i = 0
    Do
        Debug.Print [REPT(CHAR(10),99]; "["; Mid(s, 10 - i, 10); "]"
        DoEvents
        Sleep 100
        i = (i + 1) Mod 10
    Loop
End Sub

-2 bytes para remover espaços em branco

-30 bytes para contar corretamente

-14 bytes para converter em função de janela imediata

Saída

O gif abaixo usa a versão completa da sub-rotina porque eu estava com preguiça de gravar novamente isso com a função imediata da janela.

05AB1E , 23 bytes

'.4×ð6×J[D…[ÿ],Á¶т×,т.W

Experimente online!

Explicação

'.4×ð6×J                  # push the string "....      "
        [                 # forever do:
         D                # duplicate
          …[ÿ],           # interpolate the copy between brackets and print
               Á          # rotate the remaining copy right
                ¶т×,      # print 100 newlines
                    т.W   # wait 100ms

Lote, 99 98 bytes

Guardado 1 byte graças ao SteveFest!

(Eu poderia remover \rdo código, mas no espírito do golfe em lotes, não vou.)

@SET s=....      
:g
@CLS
@ECHO [%s%]
@SET s=%s:~-1%%s:~,-1%
@ping 0 -n 1 -w 100>nul
@GOTO g

Existem quatro espaços após a primeira linha.

A lógica principal é modificar a string. %s:~-1%é o último caractere de %s%e %s:~0,-1%é quase o último caractere de %s%. Assim, estamos movendo o último caractere para a frente da string, que gira a string.

Ruby, 57 56 bytes

s=?.*4+' '*6;loop{$><<"[%s]\r"%s=s[-1]+s.chop;sleep 0.1}

Fortemente influenciado por outras respostas aqui.

Guardou um byte graças a @manatwork. Aparentemente, também tenho problemas para contar caracteres - eu uso o ST3 e, aparentemente, incluirá novas linhas na contagem de caracteres da linha, se você não estiver atento.

Perl, 69 bytes

-3 bytes graças a @Dom Hastings .

$_="....".$"x6;{print"\ec[$_]
";select$a,$a,!s/(.*)(.)/$2$1/,.1;redo}

Essa select undef,undef,undef,.1é a maneira mais curta de dormir menos de 1 segundo em Perl, e são necessários muitos bytes ...

Um pouco mais longo (79 bytes), existe:

@F=((".")x4,($")x6);{print"\ec[",@F,"]\n";@F=@F[9,0..8];select$a,$a,$a,.1;redo}

Bater, 93 90 96 bytes

s="...      ....      ."
for((;;)){ for i in {0..9};do printf "\r[${s:10-i:10}]";sleep .1;done;}

veja aqui

não foi possível aninhar {} a sintaxe

Groovy, 72 bytes

s="*"*4+" "*6
for(;;){print("["+s+"]"+"\n"*20);s=s[9]+s[0..8];sleep 100}

Explaination

s="*"*4+" "*6 //creates the string "****      "
for(;;){ //classic infinite loop
    print("["+s+"]"+"\n"*20) //prints the string with [ at the beginning and ] at the end. After that some newlines
    s=s[9]+s[0..8] //appends the final char of the string to beginning, creating a cycling illusion
    sleep 100 //100 ms delay
}

Haskell (Windows), 159 bytes

import System.Process
import Control.Concurrent
main=mapM id[do system"cls";putStrLn('[':["....      "!!mod(i-n)10|i<-[0..9]]++"]");threadDelay(10^5)|n<-[0..]]

Explanation

mapM id             sequentially perform each IO action in the following list
[                   start a list comprehension where each element is...
  do                  an IO operation where
    system "cls";       we clear the screen by calling the windows builtin "cls"
    putStrLn(           then display the string...
      '[':                with '[' appended to
      [                   a list comprehension where each character is...
        "....      "!!       the character in literal string "....      " at the index
        mod(i-n)10          (i - n) % 10
      |i<-[0..9]]         where i goes from 0 to 9
      ++"]"             and that ends with ']'
    );
    threadDelay(10^5)   then sleep for 100,000 microseconds (100 ms)
|n<-[0..]]          where n starts at 0 and increments without bound

Haskell's purity made generating the cycling dot pattern somewhat complex. I ended up creating a nested list comprehension that generated an infinite list of strings in the order they should be output, then went back added the appropriate IO operations.

Ruby, 61 bytes

If the spec were for the dots to scroll left instead of right, it would save 1 byte because rotate! with no arguments shifts the array once to the left.

s=[?.]*4+[' ']*6
loop{print ?[,*s,"]\r";s.rotate!9;sleep 0.1}

GNU sed (with exec extension), 64

Score includes +1 for -r flag.

s/^/[....      ]/
:
esleep .1
s/[^. ]*(.+)(.)].*/\c[c[\2\1]/p
b

c, 100

char *s="....      ....     ";main(i){for(i=0;;i=(i+9)%10)dprintf(2,"[%.10s]\r",s+i),usleep(3<<15);}