Wyzwanie polega na wydrukowaniu danych wejściowych, odczekaniu dowolnej ilości czasu, wydrukowaniu danych wejściowych, odczekaniu dwukrotnie czasu początkowego oczekiwania, wydrukowaniu danych wejściowych ponownie itd. Początkowe opóźnienie musi wynosić mniej niż 1 godzinę, a dokładność kolejnych opóźnień musi wynosić +/- 5%. Poza tym nie ma ograniczenia czasu opóźnienia.

Przykład:

Wejście: hi.

Wyjście: hi(przerwa 1ms) hi(przerwa 2ms) hi(przerwa 4ms) hi(przerwa 8ms) hi(przerwa 16ms) itp.

Dozwolone są również:

hi(Przerwa 1 minuta) hi( przerwa 2 minuty) hi( przerwa 4 minuty) hi(przerwa 8 minut) hi(przerwa 16 minut) itp.

Dane wejściowe należy podać na początku programu (STDIN, parametr wiersza polecenia, parametr funkcji itp.) I będzie to ciąg znaków.

Początkowe opóźnienie nie może wynosić 0.

05AB1E , 6 bajtów

Kod:

[=No.W

Wyjaśnienie:

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

Wypróbuj online!

Scratch, 8 bloków + 3 bajty

Odpowiednik w Pythonie:

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

Python 3, 60 56 bajtów

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

Dziennik zmian:

• zmieniono funkcję rekurencyjnej lambda na funkcję rekurencyjną (-4 bajty)

MATL , 8 bajtów

`GD@WY.T

Pierwsza przerwa to 2 sekundy.

Wypróbuj w MATL Online . Lub zobacz zmodyfikowaną wersję, która wyświetla czas, jaki upłynął od uruchomienia programu. (Jeśli interpreter nie działa, odśwież stronę i spróbuj ponownie).

Lub zobacz gif:

Wyjaśnienie

`     % 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 bajtów

Oryginalne rozwiązanie 34 bajtów:

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

Ogol 2 bajty za pomocą Do

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

Ogol jeszcze jeden bajt dzięki rekurencyjnemu rozwiązaniu @ MartinEnder

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

@ngenisis używa rekurencji ReplaceRepeated, aby zgolić kolejny bajt

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

Oktawa, 42 41 bajtów

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

Zapisany jeden bajt dzięki rahnema1 p*=2jest krótszy niż p=p*2.

Nie mogę uwierzyć, że nie byłem w stanie zagrać w golfa, ale tak naprawdę nie było to takie łatwe.

• Dane wejściowe muszą być na początku, więc nie można uniknąć pierwszej części.
• Potrzebuję liczby, która się podwoi, i musi być zainicjowana przed pętlą
  • Można by użyć danych wejściowych jako warunku dla pętli, ale wtedy musiałbym mieć p*=2gdzie indziej.
  • Pauza nie ma wartości zwracanej, w przeciwnym razie mogłaby być while pause(p*=2)

Java (OpenJDK 8) , 113 bajtów

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

Wypróbuj online!

-60 bajtów dzięki Leaky Nun!

R, 50 48 bajtów

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

zwraca anonimową funkcję, która ma jeden obowiązkowy argument, ciąg do wydrukowania. Nie drukuje nowych wierszy, po prostu wypluwa xna ekranie. ijest opcjonalnym argumentem, domyślnie ustawiony na 1, czeka na isekundy i podwaja sięi .

-2 bajty dzięki pajonk

Wypróbuj online!

Rubinowy, 34 28 23 22 (+2 za -n) = 24 bajty

3 bajty zapisane dzięki Value Ink!

1 bajt zapisany dzięki Daniero

loop{print;sleep$.*=2}

Rozpoczyna się 2, a następnie 4, etc.

Wyjaśnienie

-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 bajtów

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

Wypróbuj online! (Oczywiście nie ma tam wiele do zobaczenia, ale możesz sprawdzić, jak często drukowano w ciągu jednej minuty).

Wyjaśnienie

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 bajtów

Przekreślone 44 jest nadal regularne 44; (

Ta odpowiedź już zapewnia przyzwoite rozwiązanie, ale możemy zaoszczędzić trochę więcej bajtów.

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

Anonimowa funkcja przyjmująca praktycznie wszystko do wydrukowania jako argument x. Zaczyna się po 2 sekundach i podwaja się za każdym razem. Nadużywa Tdomyślnie zdefiniowanego TRUEkryterium oceny 1.

Tak długo, jak długo ten komentarz otrzyma zielone światło od OP, możemy go jeszcze skrócić, ale nie sądzę, że jest to zgodne z duchem wyzwania. Czasy oczekiwania 0 nie są już dozwolone.

function(x)repeat cat(x)

Cubix , 30 bajtów

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

Wypróbuj tutaj

Mapuje to na sześcian o długości boku 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 bajtów

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

Z jakiegoś powodu TIO nie wyświetli wyniku, dopóki nie zatrzymasz wykonywania programu.

Wypróbuj online!

PHP, 31 bajtów

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

śpi 1, 2, 4, 8, ... sekund. Uruchom jako potok zphp -nR '<code>'

Będzie działał do 63. wydruku (na komputerze 64-bitowym), po tym nie będzie już czekania.
Wersja 1 wyświetla ostrzeżenia sleep() expects parameter 1 to be integer, float given,
wersja 2 wyświetla jedno ostrzeżenie sleep(): Number of seconds must be greater than or equal to 0.

Włóż @wcześniej, sleepaby wyciszyć ostrzeżenia.

TI-Basic, 21 bajtów

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

Python 3, 61 bajtów

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

Podobne do golfa @ L3viathan, ale używa whilepętli

CJam, 26 bajtów

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

Nie działa poprawnie w TIO.

Pierwsza przerwa to 20 milisekund.

Wyjaśnienie

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 bajtów

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

C, 35 bajtów jako funkcja

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

Pobiera dane wejściowe jako argument wiersza poleceń.

Partia, 62 bajty

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

Okazało się, że jest to bajt krótszy niż jawne podwojenie tw pętli:

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

Siatka , 12 bajtów

1idp~dw2*~2j

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Oszczędność jednego bajtu dzięki @raznagul.

Python 2, 54 bajty

Wykorzystuje długie obliczenia zamiast bibliotek czasowych.

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

PowerShell, 35 33 30 29 bajtów

Z pomocną wskazówką od czegokolwiek i Joeya

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

Wyjaśnienie

%{          # 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

Wykonano z:

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

Python 3, 49 bajtów

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

Wykorzystuje niewielkie opóźnienie +=operacji i wykonuje je xrazy. xpodwaja się, dodając jeden do siebie tyle razy, ile wartość x.

Zaczyna się od 6^6(46656), aby trzymać się maksymalnie 5% zmienności opóźnienia.

Perl 6 , 39 bajtów

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

Spróbuj ( printzastąpione, aby dodać informacje o czasie)

Rozszerzony:

  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 bajtów

^{Przekreślone 44 to wciąż 44}

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

Nie lubisz bomb ostrzegawczych?

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

Technicznie poprawne, ale nadużywające luk prawnych:

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

-3 bajty dzięki Cyoce, -2 dzięki Business Cat, -2 dzięki Neilowi

Common Lisp, 49 bajtów

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

pierwsze opóźnienie powinno być 1drugie.

Pyth, 7 bytes

#|.d~yT

Explanation:

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

TI-BASIC, 36 bytes

Initial wait period is 1 second.

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

Racket, 51 bytes

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

Example

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