Haga una barra de carga de estilo Windows siguiendo las siguientes instrucciones.

^{(tenga en cuenta que esto es diferente a Cargando ... para siempre )}

Su salida debe comenzar por [.... ].

Cada tic, debe esperar 100 ms, luego mover cada punto un carácter a la derecha. Si el punto está en el décimo carácter, muévalo al primero. Tenga en cuenta que debe borrar la pantalla antes de volver a mostrar. La salida se ordena de la siguiente manera:

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

.. Luego se repite para siempre.

Reglas

• Este es el código de golf , por lo que gana la respuesta más corta ^{. Dudo que incluso acepte una respuesta ganadora aunque}
• Proporcione un archivo gif de la barra de carga en acción si es posible.

V, 17 16 15 bytes

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

<esc>es 0x1b.

Y el hexdump:

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

Explicación

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

Editar: Guardado 12 14 bytes gracias a @Luke.

PowerShell, 67 66 bytes

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

-1 mediante el uso de constructor acortado gracias a Beatcracker

reemplaza la cadena con una copia de la cadena donde se coloca el último carácter delante de los caracteres restantes, borra la pantalla, la imprime y luego duerme durante 100 ms.

ahorró muchos bytes usando el constructor del bucle for en lugar de envolver la lógica dentro de la cadena.

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

^{-12 bytes thanks to ovs
-2 bytes thanks to totallyhuman}

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

Try it online!

Windows batch , 201 181 bytes

Turns out using the old-school method actually saves bytes!

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

Note:

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

Please note that my GIF recorder skipped a few frames, making the loading bar jumps :(

Mathematica, 67 77 Bytes

+10 Bytes as I forgot the square brackets.

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

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

This one uses a bitmask to keep track of where the dots are.

I had to add another byte as I was only outputting 5 spaces before.

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

Try it 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

• Saved 2 bytes thanks to Johan's suggestion that I use an input instead of a pre.

Try It

Requires a closing > on the input tag in order to function in a 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

Try it:)

How it works

]ʠ⁶¤⁴.ȧ[ėÐḷẸḍ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.

Update

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

Try it:)

Don’t know why this took me a while to think of. Anyways, this places it at 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]";

no comment

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

o como 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();}}}}

Puro golpe, 68

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

MATL , 24 bytes

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

¡Pruébalo en MATL Online! O vea un gif del compilador fuera de línea:

Explicación

`        % 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)

Jalea , 28 27 bytes

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

¿Cómo?

ṙ©-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

Guardado 7 8 bytes gracias a Digital Trauma .

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

O, si su sistema es stdout no necesita ser vaciado después de cada escritura sin una nueva línea:

C (gcc), 70 bytes

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

Cómo funciona

• usleep( duerme para el próximo valor de retorno en microsegundos.
• dprintf(2,imprime en el descriptor de archivo 2, o stderr. Esto es necesario porque mientras stdoutestá almacenado en línea (lo que significa que la salida no se mostrará hasta que imprima una nueva línea),stderr está almacenada en caracteres (toda la salida se muestra inmediatamente).
• "\r imprime un retorno de carro (borra la línea actual).
• [%-10.10s]" es el printf especificador de formato para una cadena con una longitud exacta de 10 (sin importar qué cadena siempre que la salida sea siempre una cadena con una longitud de 10), rellenada con espacios a la derecha si es necesario. Esto se incluirá entre paréntesis.
• ".... ...." es la barra de carga
• +i%10compensa la barra de carga por el módulo de índice actual 10. Por ejemplo, si i == 3,i % 10 es igual a 3. La compensación de la barra de carga por 3 hace que sea igual a ". ....".
• Cuando la cadena desplazada se pasa al printfespecificador de formato, se limita a una longitud de 10 si es necesario y agrega espacios al final si es necesario. Por lo tanto, la barra de carga siempre estará entre [.... ]y [. ...].

Java 7, 139124 bytes

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

• Mención de \ragradecimiento a @ Phoenix .

El retorno del carro \r restablece el 'cursor' al comienzo de la línea, que luego se puede sobrescribir. Desafortunadamente, los compiladores en línea ni el IDE de Eclipse no admiten esto, por lo que agregué un gif al final de esta respuesta para mostrarlo desde el símbolo del sistema de Windows.

Pruébalo aquí(Ligeramente modificado para que no tenga que esperar el tiempo de espera antes de ver el resultado. Además, el TIO no admite retornos de carro, por lo que cada línea se imprime sin sobrescribir la línea anterior).

Explicación:

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

Salida gif:

Python 2 , 81 78 bytes

-1 byte (notando que perdí el uso de %s cuando Rod presentó una versión de Python 3 casi idéntica al mismo tiempo)
-2 bytes (usando la idea totalmente humana - reemplazar s[-1]+s[:-1]con s[9]+s[:9])

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

Ir , 150 145 132 129 124 bytes

-5 bytes gracias a sudee.

Siento que no veo lo suficiente Vaya aquí ... Pero mi respuesta está superando a C así que ... por favor, ¿halp golf?

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

Pruébalo en línea!

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

VBA no tiene una función integrada que permita esperar períodos de tiempo inferiores a un segundo, por lo que debemos declarar una función desde kernel32.dll

Declaración de declaración de 32 bits (41 bytes)

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

Declaración de declaración de 64 bits (49 bytes)

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

Además, debemos incluir un DoEvents bandera para evitar que el bucle infinito haga que Excel parezca no responder. La función final es entonces una subrutina que no lleva entradas y salidas a la ventana inmediata de VBE.

Función de ventana inmediata, 93 bytes

Función de ventana inmediata anónima de VBE que no lleva entradas y salidas al rango A1de ActiveSheet

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

Versión antigua, 109 bytes

Función de ventana inmediata que no lleva entradas y salidas a la ventana inmediata de VBE.

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

No golfted y formateado

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 eliminar espacios en blanco

-30 bytes para contar correctamente

-14 Bytes para convertir a la función de ventana inmediata

Salida

El siguiente gif usa la versión de subrutina completa porque era demasiado vago para volver a grabar esto con la función de ventana inmediata.

05AB1E , 23 bytes

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

Pruébalo en línea!

Explicación

'.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 gracias a SteveFest!

(Podría eliminarlo \rdel código, pero en el espíritu del golf por lotes, no lo haré).

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

Hay cuatro espacios después de la primera línea.

La lógica principal es modificar la cadena. %s:~-1%es el último carácter de %s%y %s:~0,-1%es todo menos el último carácter de %s%. Por lo tanto, estamos moviendo el último carácter al frente de la cadena, que gira la cadena.

Ruby, 57 56 bytes

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

Muy influenciado por otras respuestas aquí.

Salvó un byte gracias a @manatwork. También, aparentemente, tengo problemas para contar caracteres: uso ST3 y aparentemente incluirá nuevas líneas en el recuento de caracteres en la línea si no está atento.

Perl, 69 bytes

-3 bytes gracias a @Dom Hastings .

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

Esa select undef,undef,undef,.1es la forma más corta de dormir menos de 1 segundo en Perl, y requiere muchos bytes ...

Un poco más largo (79 bytes), hay:

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

Golpetazo, 93 90 96 bytes

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

ver aquí

no se pudo anidar {} en sintaxis

Groovy, 72 bytes

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

Explicación

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

Explicación

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

La pureza de Haskell hizo que la generación del patrón de puntos de ciclismo fuera algo compleja. Terminé creando una comprensión de lista anidada que generó una lista infinita de cadenas en el orden en que deberían salir, luego volví a agregar las operaciones de E / S apropiadas.

Ruby, 61 bytes

Si la especificación fuera que los puntos se desplazaran hacia la izquierda en lugar de hacia la derecha, ahorraría 1 byte porque rotate!sin argumentos desplaza la matriz una vez hacia la izquierda.

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

GNU sed (con extensión exec), 64

La puntuación incluye +1 para la -rbandera.

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