Su desafío es imprimir la entrada, esperar cualquier cantidad de tiempo, imprimir la entrada, esperar dos veces el tiempo que inicialmente esperó, imprimir la entrada nuevamente, y así sucesivamente. El retraso inicial debe ser inferior a 1 hora y debe tener una precisión de +/- 5% en los retrasos posteriores. Aparte de eso, no hay restricción en el tiempo de retraso.

Ejemplo:

Entrada: hi.

Salida: hi(pausa de 1 hims ) (pausa de 2 ms ) (pausa de 4 ms ) (pausa de 8 ms) hi(pausa de hi16 hims), etc.

También permitido:

hi(Pausa de 1 minuto) hi( pausa de 2 minutos) hi( pausa de 4 minutos) hi(pausa de 8 minutos) hi(pausa de 16 minutos), etc.

La entrada debe proporcionarse al inicio del programa (STDIN, parámetro de línea de comando, parámetro de función, etc.) y será una cadena.

El retraso inicial no puede ser 0.

05AB1E , 6 bytes

Código:

[=No.W

Explicación:

[        # Start an infinite loop
 =       # Print the top of the stack without popping
  No     # Compute 2 ** (iteration index)
    .W   # Wait that many milliseconds

Pruébalo en línea!

Scratch, 8 bloques + 3 bytes

Equivalente en Python:

import time
n = 1
while 1:
    print("x")
    time.sleep(n)
    n = n * 2

Python 3, 60 56 bytes

import time
def f(x,i=1):print(x);time.sleep(i);f(x,i*2)

Registro de cambios:

• cambió lambda recursiva a función recursiva (-4 bytes)

MATL , 8 bytes

`GD@WY.T

La primera pausa es de 2 segundos.

Pruébalo en MATL Online . O ver una versión modificada que muestre el tiempo transcurrido desde que se inició el programa. (Si el intérprete no funciona, actualice la página e intente nuevamente).

O ver un gif:

Explicación

`     % Do...while
  G   %   Push input
  D   %   Display
  @   %   Push iteration index (1-based)
  W   %   2 raised to that
  Y.  %   Pause for that time
  T   %   Push true. This will be used as loop confition
      % End (implicit). The top of the stack is true, which produces an infinite loop 

Mathematica 34 32 30 29 Bytes

Solución original 34 Bytes:

For[x=.1,1<2,Pause[x*=2];Print@#]&

Afeite 2 bytes con Do

x=1;Do[Pause[x*=2];Print@#,∞]&

Elimine un byte más con la solución recursiva de @ MartinEnder

±n_:=#0[Print@n;Pause@#;2#]&@1

@ngenisis usa la recursividad ReemplazarRepetida para eliminar otro byte

1//.n_:>(Print@#;Pause@n;2n)&

Octava, 42 41 bytes

x=input('');p=1;while p*=2,pause(p),x,end

Guardado un byte gracias a rahnema1, p*=2es más corto que p=p*2.

No puedo creer que no haya podido jugar golf, pero en realidad no fue tan fácil.

• La entrada debe estar en el inicio, por lo que la primera parte es imposible de evitar.
• Necesito un número que se duplique y debe inicializarse delante del bucle
  • Sería posible usar la entrada como condicional para el ciclo, pero luego tendría que tener p*=2otro lugar.
  • La pausa no tiene un valor de retorno, de lo contrario podría haber sido while pause(p*=2)

Java (OpenJDK 8) , 113 bytes

interface M{static void main(String[]a)throws Exception{for(int i=1;;Thread.sleep(i*=2))System.out.print(a[0]);}}

Pruébalo en línea!

-60 bytes gracias a Leaky Nun!

R, 50 48 bytes

function(x,i=1)repeat{cat(x);Sys.sleep(i);i=i*2}

devuelve una función anónima que tiene un argumento obligatorio, la cadena para imprimir. No imprime nuevas líneas, solo escupe xen la pantalla. ies un argumento opcional que por defecto es 1, espera isegundos y se duplica i.

-2 bytes gracias a pajonk

Pruébalo en línea!

Ruby, 34 28 23 22 (+2 para -n) = 24 bytes

¡3 bytes guardados gracias a Value Ink!

1 byte guardado gracias a daniero

loop{print;sleep$.*=2}

Comienza en 2, entonces 4, etc.

Explicación

-n                       # read a line from STDIN
  loop{                } # while(true):
       print;            # print that line
             sleep$.*=2  # multiply $. by 2, then sleep that many seconds. 
                         # $. is a Ruby special variable that starts at 1.

Alice , 16 bytes

1/?!\v
T\io/>2*.

Pruébalo en línea! (No hay mucho que ver allí, por supuesto, pero puede verificar con qué frecuencia se imprimió en un minuto).

Explicación

1    Push 1 to the stack. The initial pause duration in milliseconds.
/    Reflect to SE. Switch to Ordinal.
i    Read all input.
!    Store it on the tape.
/    Reflect to E. Switch to Cardinal.
>    Move east (does nothing but it's the entry of the main loop).
2*   Double the pause duration.
.    Duplicate it.
     The IP wraps around to the first column.
T    Sleep for that many milliseconds.
\    Reflect to NE. Switch to Ordinal.
?    Retrieve the input from the tape.
o    Print it.
\    Reflect to E. Switch to Cardinal.
v    Move south.
>    Move east. Run another iteration of the main loop.

R, 44 43 bytes

Tachado 44 sigue siendo regular 44; (

Esta respuesta ya proporciona una solución decente, pero podemos guardar algunos bytes más.

function(x)repeat{cat(x);Sys.sleep(T<-T*2)}

Función anónima que toma prácticamente cualquier cosa imprimible como argumento x. Comienza a los 2 segundos y luego se duplica cada vez. Abusa del hecho que Tse define por defecto como el TRUEque evalúa 1.

Además, mientras este comentario todavía reciba luz verde de OP, podemos hacerlo aún más corto, pero no creo que sea en el espíritu del desafío. Los tiempos de espera de 0 ya no están permitidos.

function(x)repeat cat(x)

Cubix , 30 bytes

/(?:u<q.;1A>?ou2$/r;w;q^_q.\*/

Pruébalo aquí

Esto se asigna a un cubo con longitud lateral 3.

      / ( ?              # The top face does the delay.  It takes the stack element with the
      : u <              # delay value, duplicates and decrements it to 0.  When 0 is hit the
      q . ;              # IP moves into the sequence which doubles the delay value.
1 A > ? o u 2 $ / r ; w  # Initiates the stack with one and the input.  For input hi this
; q ^ _ q . \ * / . . .  # gives us 1, -1, 10, 105, 104.  There is a little loop that prints 
. . . . . . . . . . . .  # each item in the stack dropping it to the bottom until -1 is hit.
      . . .              # Then the delay sequence is started om the top face
      . . .
      . . .

Bash , 37 bytes

for((t=1;;t*=2)){ sleep $t;echo $1;};

Por alguna razón, TIO no mostrará el resultado hasta que detenga la ejecución del programa.

Pruébalo en línea!

PHP, 31 bytes

for(;;sleep(2**$i++))echo$argn;
for(;;sleep(1<<$i++))echo$argn;

duerme 1, 2, 4, 8, ... segundos. Corre como tubería conphp -nR '<code>'

Funcionará hasta la impresión 63 (en una máquina de 64 bits), después de eso no habrá más esperas.
La versión 1 arrojará advertencias sleep() expects parameter 1 to be integer, float given,
versión 2 generará una advertencia sleep(): Number of seconds must be greater than or equal to 0.

Inserte @antes sleeppara silenciar las advertencias.

TI-Basic, 21 bytes

Prompt Str0
1
While 1
Disp Str0
Wait Ans
2Ans
End

Python 3, 61 bytes

import time;i=1;x=input()
while 1:print(x);time.sleep(i);i*=2

Similar al golf de @ L3viathan, pero usa whileloop

CJam, 26 bytes

qKes{es1$-Y$<{W$o;2*es}|}h

No funciona correctamente en TIO.

La primera pausa es de 20 milisegundos.

Explicación

q                           e# Push the input.
 K                          e# Push 20 (the pause time).
  es                        e# Push the time (number of milliseconds since the Unix epoch).
    {                       e# Do:
     es1$-                  e#  Subtract the stored time from the current time.
          Y$<{              e#  If it's not less than the pause time:
              W$o           e#   Print the input.
                 ;2*es      e#   Delete the stored time, multiply the pause time by 2, push
                            e#     the new time.
                      }|    e#  (end if)
                        }h  e# While the top of stack (not popped) is truthy.
                            e#  (It always is since the time is a positive integer)

C, 51 bytes

main(c,v)char**v;{puts(v[1]);sleep(c);main(2*c,v);}

C, 35 bytes como una función

c=1;f(n){puts(n);sleep(c*=2);f(n);}

Toma datos como argumento de línea de comando.

Lote, 62 bytes

@set/at=%2+0,t+=t+!t
@echo %1
@timeout/t>nul %t%
@%0 %1 %t%

Esto resultó ser un byte más corto que duplicar explícitamente ten un bucle:

@set t=1
:g
@echo %1
@timeout/t>nul %t%
@set/at*=2
@goto g

Reticular , 12 bytes.

1idp~dw2*~2j

Pruébalo en línea!

Explicación

1idp~dw2*~2j
1               push 1 (initial delay)
 i              take line of input
  d             duplicate it
   p            print it
    ~           swap
     d          duplicate it
      w         wait (in seconds)
       2*       double it
         ~      swap
          2j    skip next two characters
1i              (skipped)
  d             duplicate input
   p            print...
                etc.

C #, 80 79 bytes

s=>{for(int i=1;;System.Threading.Thread.Sleep(i*=2))System.Console.Write(s);};

Guardado un byte gracias a @raznagul.

Python 2, 54 bytes

Utiliza un cálculo largo en lugar de bibliotecas de temporización.

def f(x,a=1):
 while 1:a*=2;exec'v=9**9**6;'*a;print x

PowerShell, 35 33 30 29 Bytes

Con una pista útil de lo que sea y Joey

%{for($a=1){$_;sleep($a*=2)}}

Explicación

%{          # Foreach
for($a=1){  # empty for loop makes this infinite and sets $a
$_;         # prints current foreach item
sleep($a*=2)# Start-Sleep alias for $a seconds, reassign $a to itself times 2           
}}          # close while and foreach

Ejecutado con:

"hi"|%{for($a=1){$_;sleep($a*=2)}}

Python 3, 49 bytes

b=input();x=6**6
while 1:print(b);exec("x+=1;"*x)

Utiliza el ligero retraso de la +=operación y la ejecuta xveces. xse duplica agregando uno a sí mismo tantas veces como el valor dex .

Comienza en 6^6(46656) para mantener la variación máxima del 5% en el retraso.

Perl 6 , 39 bytes

print(once slurp),.&sleep for 1,2,4...* 

Pruébelo ( printanulado para agregar información de tiempo)

Expandido:

  print(        # print to $*OUT
    once slurp  # slurp from $*IN, but only once
  ), 
  .&sleep       # then call sleep as if it was a method on $_

for             # do that for (sets $_ to each of the following)

  1, 2, 4 ... * # deductive sequence generator

JS (ES6), 44 42 40 38 36 bytes

^{Tachado 44 sigue siendo 44}

i=1,y=x=>setTimeout(y,i*=2,alert(x))

¿No te gustan las bombas de alerta?

i=1,y=x=>setTimeout(y,i*=2,console.log(x))

Técnicamente correcto, pero abusivo de lagunas:

y=x=>(x&&alert(x),y())

-3 bytes gracias a Cyoce, -2 gracias a Business Cat, -2 gracias a Neil

Lisp común, 49 bytes

(do((a(read))(i 1(* 2 i)))(())(print a)(sleep i))

El primer retraso debe ser el 1segundo.

Pyth, 7 bytes

#|.d~yT

Explicación:

#           Infinitely loop
  .d         Delay for 
      T      10 seconds
    ~y       and double T each time
 |           print input every iteration, too

TI-BASIC, 36 bytes

El período de espera inicial es de 1 segundo.

1→L
Input Str1
checkTmr(0→T
While 1
While L>checkTmr(T
End
Disp Str1
2L→L
End

Raqueta, 51 bytes

(λ(s)(do([n 1(* n 2)])(#f)(displayln s)(sleep n)))

Ejemplo

➜  ~  racket -e '((λ(s)(do([n 1(* n 2)])(#f)(displayln s)(sleep n)))"Hello")'
Hello
Hello
Hello
Hello
Hello
^Cuser break