Zorluk, girdiyi yazdırmak, herhangi bir süre beklemek, girdiyi yazdırmak, başlangıçta iki kez beklemek, girişi yeniden yazdırmak vb. Başlangıç ​​gecikmesi 1 saatten az olmalı ve sonraki gecikmelerde +/-% 5'lik bir doğruluk oranına sahip olmalısınız. Bunun dışında gecikme süresinde herhangi bir kısıtlama yoktur.

Misal:

Girdi: hi.

Çıkış: hi(1ms duraklama) hi(2ms duraklama) hi(4ms duraklama) hi(8ms duraklama) hi(16ms duraklama) vb.

Ayrıca izin verilir:

hi(1 dakika ara) hi(2 dakika ara) hi(4 dakika ara) hi(8 dakika ara) hi(16 dakika ara) vb.

Giriş, programın başında sağlanmalıdır (STDIN, komut satırı parametresi, işlev parametresi, vb.) Ve bir dize olacaktır.

İlk gecikme 0 olamaz.

05AB1E , 6 bayt

Kod:

[=No.W

Açıklama:

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

Çevrimiçi deneyin!

Çizik, 8 blok + 3 bayt

Python'da eşdeğer:

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

Python 3, 60 56 bayt

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

Değişiklikler:

• özyinelemeli lambda'yı özyinelemeli işlev olarak değiştirdi (-4 bayt)

MATL , 8 bayt

`GD@WY.T

İlk duraklama 2 saniyedir.

MATL Online'da deneyin . Veya programın başlamasından bu yana geçen süreyi görüntüleyen değiştirilmiş bir sürüme bakın . (Yorumlayıcı çalışmazsa, lütfen sayfayı yenileyin ve tekrar deneyin).

Veya bir gif bakın:

açıklama

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

Orijinal çözüm 34 Bayt:

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

Do ile 2 bayt tıraş

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

@ MartinEnder'in özyinelemeli çözümü ile bir Byte daha tıraş edin

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

@ngenisis başka bir baytı tıraş etmek için ReplaceRepeated özyineleme kullanır

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

Oktav, 42 41 bayt

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

Rahnema1 sayesinde bir bayt kaydedildi p*=2, daha kısa p=p*2.

Bu golf aşağı mümkün değil inanamıyorum, ama aslında o kadar kolay değildi.

• Giriş başlangıçta olmalıdır, bu nedenle ilk bölümden kaçınmak imkansızdır.
• İki katına çıkacak bir sayıya ihtiyacım var ve döngü önünde başlatılmalı
  • Girdiyi döngü için bir koşullu olarak kullanmak mümkün olurdu, ama sonra p*=2başka bir yere sahip olmalıydım .
  • Duraklatmanın bir dönüş değeri yok, aksi halde while pause(p*=2)

Java (OpenJDK 8) , 113 bayt

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

Çevrimiçi deneyin!

Leaky Nun sayesinde -60 bayt!

R, 50 48 bayt

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

yazdırılacak dize olan bir zorunlu bağımsız değişkeni olan anonim bir işlev döndürür. Yeni satır yazdırmaz, sadece xekranda tükürür . ivarsayılan 1, isaniye bekleyen ve iki katına çıkan isteğe bağlı bir argüman i.

Pajonk sayesinde -2 bayt

Çevrimiçi deneyin!

Yakut, 34 28 23 22 (+2 için -n) = 24 bayt

Value Ink sayesinde 3 bayt tasarruf!

Daniero sayesinde 1 bayt kurtardı

loop{print;sleep$.*=2}

Başlangıç ​​tarihi: 2 , sonra 4vb.

açıklama

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

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

Çevrimiçi deneyin! (Tabii orada görmek için çok fazla değil, ancak bir dakika içinde ne sıklıkta yazdırıldığını kontrol edebilirsiniz.)

açıklama

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 bayt

Çarpılan 44 hala düzenli 44; (

Bu cevap zaten iyi bir çözüm sunuyor, ancak biraz daha byte tasarruf edebiliyoruz.

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

Anonim işlev, pratik olarak argüman olarak yazdırılabilir her şeyi alır x. 2 saniyede başlar ve her seferinde iki katına çıkar. TVarsayılan olarak TRUEdeğerlendirilen olarak tanımlanan gerçeği kötüye kullanır 1.

Ayrıca, bu yorum OP'den hala yeşil bir ışık aldığı sürece , onu daha da kısaltabiliriz, ancak bunun meydan okuma ruhunda olduğunu düşünmüyorum. Artık 0 bekleme süresine izin verilmiyor.

function(x)repeat cat(x)

Cubix , 30 bayt

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

Burada deneyin

Bu, kenar uzunluğu 3 olan bir küp üzerinde eşlenir.

      / ( ?              # 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 bayt

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

Herhangi bir nedenle TIO, program yürütülmesini durdurana kadar çıktıyı göstermez.

Çevrimiçi deneyin!

PHP, 31 bayt

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

1, 2, 4, 8, ... saniye uyur. İle boru olarak çalıştırphp -nR '<code>'

63. baskıya (64 bit makinede) kadar çalışacak, bundan sonra artık beklemeyeceksiniz.
Sürüm 1 uyarı verir sleep() expects parameter 1 to be integer, float given,
Sürüm 2 bir uyarı verirsleep(): Number of seconds must be greater than or equal to 0 .

Uyarıları sessize almak için @önce takın sleep.

TI-Basic, 21 bayt

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

Python 3, 61 bayt

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

@ L3viathan's golf benzer, ancak whiledöngü kullanır

CJam, 26 bayt

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

TIO'da düzgün çalışmıyor.

İlk duraklama 20 milisaniyedir.

açıklama

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 bayt

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

C, fonksiyon olarak 35 bayt

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

Girdiyi komut satırı argümanı olarak alır.

Toplu, 62 bayt

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

Bu t, bir döngüde açıkça ikiye katlanmaktan daha kısa bir bayt olduğu ortaya çıktı :

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

Retiküler , 12 bayt

1idp~dw2*~2j

Çevrimiçi deneyin!

açıklama

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 bayt

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

@Raznagul sayesinde bir bayt kurtardı.

Python 2, 54 bayt

Zamanlama kütüphaneleri yerine uzun bir hesaplama kullanır.

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

PowerShell, 35 33 30 29 Bayt

Joey ve Joey'den faydalı bir ipucu ile

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

açıklama

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

Yürütülen:

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

Python 3, 49 bayt

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

+=İşlemin hafif gecikmesini kullanır ve xsüreleri yürütür . xdeğerine bir kat daha fazla ekleyerek iki katına çıkar.x .

6^6Gecikmede maksimum% 5'lik değişime bağlı kalmak (46656) 'da başlar .

Perl 6 , 39 bayt

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

Deneyin ( printzamanlama bilgisi eklemek için geçersiz kılındı)

Expanded:

  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 bayt

^{44 çarpı hala 44}

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

Uyarı bombalarını sevmiyor musun?

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

Teknik olarak doğru, ancak boşlukları kötüye kullanma:

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

Cyoce sayesinde -3 bayt, Business Cat sayesinde -2, Neil sayesinde -2

Ortak Lisp, 49 bayt

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

ilk gecikme 1ikinci olmalıdır .

Pyth, 7 bayt

#|.d~yT

Açıklama:

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

TI-BASIC, 36 bayt

İlk bekleme süresi 1 saniyedir.

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

Raket, 51 bayt

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

Misal

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