문제는 입력을 인쇄하고, 일정 시간 동안 기다렸다가, 입력을 인쇄하고, 처음 대기 한 시간의 두 배를 대기하고, 입력을 다시 인쇄하는 등의 작업을 수행하는 것입니다. 초기 지연 시간은 1 시간 미만이어야하며 이후 지연 시간의 정확도는 +/- 5 % 여야합니다. 그 외에는 지연 시간에 제한이 없습니다.

예:

입력 : hi.

출력 : hi(1ms 일시 정지) hi(2ms 일시 정지) hi(4ms 일시 정지) hi(8ms 일시 정지) hi(16ms 일시 정지) 등

또한 허용 :

hi(1 분 멈춤) hi(2 분 멈춤) hi(4 분 멈춤) hi(8 분 멈춤) hi(16 분 멈춤) 등

입력은 프로그램 시작시 제공되어야하며 (STDIN, 명령 행 매개 변수, 함수 매개 변수 등) 문자열입니다.

초기 지연은 0 일 수 없습니다.

05AB1E , 6 바이트

암호:

[=No.W

설명:

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

온라인으로 사용해보십시오!

스크래치, 8 블록 + 3 바이트

파이썬과 동일하다 :

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

파이썬 3, 60 56 바이트

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

변경 로그:

• 재귀 람다를 재귀 함수로 변경했습니다 (-4 바이트)

MATL , 8 바이트

`GD@WY.T

첫 번째 일시 중지는 2 초입니다.

MATL Online 에서 사용해보십시오 . 또는 프로그램이 시작된 후 경과 된 시간을 표시 하는 수정 된 버전 을 참조하십시오 . (인터프리터가 작동하지 않으면 페이지를 새로 고치고 다시 시도하십시오).

또는 GIF를 참조하십시오 :

설명

`     % 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 바이트

원래 솔루션 34 바이트 :

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

Do로 2 바이트를 면도

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

@MartinEnder의 재귀 솔루션으로 하나 이상의 바이트를 제거하십시오.

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

@ngenisis는 ReplaceRepeated 재귀를 사용하여 다른 바이트를 제거합니다.

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

옥타브, 42 41 바이트

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

rahnema1 덕분에 1 바이트를 절약했습니다 . p*=2보다 짧습니다 p=p*2.

나는 이것을 골프화 할 수 없었다는 것을 믿을 수 없지만 실제로는 쉽지 않았습니다.

• 입력은 시작에 있어야하므로 첫 번째 부분을 피할 수 없습니다.
• 두 배가되는 숫자가 필요하며 루프 앞에서 초기화해야합니다.
  • 입력을 루프의 조건부로 사용할 수는 있지만 p*=2다른 곳에 있어야 합니다.
  • 일시 중지에는 반환 값이 없습니다. 그렇지 않으면 while pause(p*=2)

자바 (OpenJDK 8) 113 바이트

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

온라인으로 사용해보십시오!

Leaky Nun 덕분에 -60 바이트!

R, 50 48 바이트

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

하나의 필수 인수 인 인쇄 할 문자열이있는 익명 함수를 반환합니다. 줄 바꿈을 인쇄하지 않고 x화면에서 뱉어 냅니다. i선택적인 인수는 기본값 1이며 i초 동안 기다렸다가 두 배가됩니다.i 됩니다.

pajonk 덕분에 -2 바이트

온라인으로 사용해보십시오!

루비, 34 28 23 22 (+2의 경우 -n) = 24 바이트

Value Ink 덕분에 3 바이트 절약!

daniero 덕분에 1 바이트 절약

loop{print;sleep$.*=2}

시작에서 2, 다음 4등

설명

-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 바이트

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

온라인으로 사용해보십시오! (물론 그다지 볼 필요는 없지만 1 분 안에 얼마나 자주 인쇄되는지 확인할 수 있습니다.)

설명

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 바이트

44가 여전히 똑같습니다. 44; (

이 답변은 이미 적절한 솔루션을 제공하지만 더 많은 바이트를 절약 할 수 있습니다.

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

실제로 인쇄 가능한 모든 것을 인수로 취하는 익명 함수 x. 2 초에 시작하여 매번 두 배가됩니다. T기본적으로 TRUE로 평가 되는 것으로 정의 된 사실을 남용합니다 1.

또한 이 의견이 OP에서 녹색 빛을 얻는 한 더 짧게 만들 수는 있지만 도전의 정신에 있다고 생각하지 않습니다. 대기 시간 0은 더 이상 허용되지 않습니다.

function(x)repeat cat(x)

Cubix , 30 바이트

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

여기 사용해보십시오

측면 길이가 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
      . . .
      . . .

배쉬 , 37 바이트

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

어떤 이유로 든 TIO는 프로그램 실행을 중지 할 때까지 출력을 표시하지 않습니다.

온라인으로 사용해보십시오!

PHP, 31 바이트

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

1, 2, 4, 8, ... 초 동안 대기합니다. 파이프로 실행php -nR '<code>'

64 비트 머신에서 63 번째 프린트까지는 더 이상 기다릴 필요가 없습니다.
버전 1은 경고를 sleep() expects parameter 1 to be integer, float given,
버전 2는 경고를 생성 sleep(): Number of seconds must be greater than or equal to 0합니다.

경고음을 소거 @하기 전에 삽입하십시오 sleep.

TI 기본, 21 바이트

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

파이썬 3, 61 바이트

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

@ L3viathan의 골프와 유사하지만 while루프를 사용 합니다.

CJam, 26 바이트

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

TIO에서 제대로 작동하지 않습니다.

첫 번째 일시 정지는 20 밀리 초입니다.

설명

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 바이트

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

C, 함수로서 35 바이트

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

입력을 명령 행 인수로 사용합니다.

배치, 62 바이트

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

이것은 t루프에서 명시 적으로 배가 하는 것보다 짧은 바이트로 판명되었습니다 .

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

망상 , 12 바이트

1idp~dw2*~2j

온라인으로 사용해보십시오!

설명

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 바이트

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

@raznagul 덕분에 1 바이트를 절약했습니다.

파이썬 2, 54 바이트

타이밍 라이브러리 대신 긴 계산을 사용합니다.

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

PowerShell, 35 33 30 29 바이트

Joey의 도움이되는 힌트

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

설명

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

다음으로 실행 :

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

파이썬 3, 49 바이트

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

약간의 +=작업 지연을 사용하고 시간을 실행합니다 x. x하나의 값을 여러 번 추가하여x .

~에서 시작 6^6(46656) 하여 지연의 최대 5 % 변동을 고수합니다.

펄 6 , 39 바이트

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

시도해보십시오 ( print타이밍 정보를 추가하도록 재정의 됨)

넓히는:

  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 바이트

^{44가 여전히 44}

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

경고 폭탄을 좋아하지 않습니까?

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

기술적으로 정확하지만 허점 남용 :

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

Cyoce 덕분에 -3 바이트, Business Cat 덕분에 -2, Neil 덕분에 -2

공통 리스프, 49 바이트

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

첫 번째 지연은 1두 번째 여야합니다 .

Pyth, 7 바이트

#|.d~yT

설명:

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

TI-BASIC, 36 바이트

초기 대기 시간은 1 초입니다.

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

라켓, 51 바이트

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

예

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