Ihre Herausforderung besteht darin, die Eingabe zu drucken, einen beliebigen Zeitraum zu warten, die Eingabe zu drucken, zweimal so lange zu warten, wie Sie ursprünglich gewartet haben, die Eingabe erneut zu drucken und so weiter. Die anfängliche Verzögerung muss weniger als 1 Stunde betragen und Sie müssen bei den nachfolgenden Verzögerungen eine Genauigkeit von +/- 5% haben. Ansonsten gibt es keine Einschränkung der Verzögerungszeit.

Beispiel:

Input: hi.

Ausgabe: hi(1 hims Pause) hi(2 ms Pause) hi(4 ms Pause) (8 ms Pause) (16 hims Pause) usw.

Auch erlaubt:

hi(1 Minute Pause) hi(2 Minuten Pause) hi(4 Minuten Pause) hi(8 Minuten Pause) hi(16 Minuten Pause) usw.

Die Eingabe muss zu Beginn des Programms erfolgen (STDIN, Befehlszeilenparameter, Funktionsparameter usw.) und ist eine Zeichenfolge.

Die anfängliche Verzögerung kann nicht 0 sein.

05AB1E , 6 Bytes

Code:

[=No.W

Erläuterung:

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

Probieren Sie es online!

Scratch, 8 Blöcke + 3 Bytes

Äquivalent in 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)

Änderungsprotokoll:

• rekursives Lambda in rekursive Funktion geändert (-4 Bytes)

MATL , 8 Bytes

`[email protected]

Die erste Pause dauert 2 Sekunden.

Probieren Sie es bei MATL Online aus . Oder sehen Sie sich eine geänderte Version an , die die seit dem Start des Programms verstrichene Zeit anzeigt. (Wenn der Interpreter nicht funktioniert, aktualisieren Sie die Seite und versuchen Sie es erneut.)

Oder sehen Sie ein GIF:

Erläuterung

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

Originallösung 34 Bytes:

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

2 Bytes mit Do abschneiden

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

Rasiere noch ein Byte mit @ MartinEnders rekursiver Lösung

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

@ngenisis verwendet die ReplaceRepeated-Rekursion, um ein weiteres Byte zu entfernen

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

Oktave, 42 41 Bytes

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

Dank rahnema1 ein Byte gespeichert, p*=2ist kürzer als p=p*2.

Ich kann nicht glauben, dass ich es nicht geschafft habe, Golf zu spielen, aber es war eigentlich nicht so einfach.

• Die Eingabe muss am Anfang sein, damit der erste Teil nicht zu umgehen ist.
• Ich brauche eine Zahl, die verdoppelt wird und die vor der Schleife initialisiert werden muss
  • Es wäre möglich, den Eingang als Bedingung für die Schleife zu verwenden, aber dann müsste ich p*=2irgendwo anders haben.
  • Pause hat keinen Rückgabewert, sonst hätte es sein können while pause(p*=2)

Java (OpenJDK 8) , 113 Byte

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

Probieren Sie es online!

-60 Bytes dank Leaky Nun!

R 50 48 Bytes

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

Gibt eine anonyme Funktion zurück, die ein obligatorisches Argument hat, die zu druckende Zeichenfolge. Druckt keine Zeilenumbrüche, sondern spuckt xnur auf den Bildschirm. iist ein optionales Argument, das standardmäßig auf Sekunden 1wartet iund sich verdoppelt i.

-2 Bytes dank pajonk

Probieren Sie es online!

Ruby, 34 28 23 22 (+2 für -n) = 24 Bytes

3 Bytes gespart dank Value Ink!

Dank daniero 1 Byte gespart

loop{print;sleep$.*=2}

Startet um 2 , dann 4usw.

Erläuterung

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

Probieren Sie es online!(Natürlich gibt es dort nicht viel zu sehen, aber Sie können überprüfen, wie oft es innerhalb einer Minute gedruckt wurde.)

Erläuterung

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

Durchgestrichen 44 ist immer noch regulär 44; (

Diese Antwort bietet bereits eine anständige Lösung, aber wir können noch einige Bytes einsparen.

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

Anonyme Funktion, die praktisch alles druckbare als Argument nimmt x. Beginnt bei 2 Sekunden und verdoppelt sich jedes Mal danach. Missbräuchlich die Tatsache, dass Tstandardmäßig definiert ist, TRUEwas als auswertet 1.

Solange dieser Kommentar noch grünes Licht von OP erhält, können wir ihn noch kürzer machen, aber ich denke nicht, dass dies im Sinne der Herausforderung ist. Wartezeiten von 0 sind nicht mehr erlaubt.

function(x)repeat cat(x)

Cubix , 30 Bytes

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

Probieren Sie es hier aus

Dies wird auf einen Würfel mit der Seitenlänge 3 abgebildet.

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

Aus irgendeinem Grund zeigt TIO die Ausgabe erst an, wenn Sie die Programmausführung stoppen.

Probieren Sie es online!

PHP, 31 Bytes

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

schläft 1, 2, 4, 8, ... Sekunden. Als Rohr mit laufen lassenphp -nR '<code>'

Funktioniert bis zum 63. Druck (auf einer 64-Bit-Maschine), danach wird nicht mehr gewartet.
Version 1 wird Warnungen geben sleep() expects parameter 1 to be integer, float given,
Version 2 gibt eine Warnung aus sleep(): Number of seconds must be greater than or equal to 0.

Legen Sie @vor sleepden Warnungen stumm zu schalten.

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

Ähnlich wie @ L3viathan Golf, aber verwendet whileSchleife

CJam, 26 Bytes

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

Funktioniert bei TIO nicht richtig.

Die erste Pause beträgt 20 Millisekunden.

Erläuterung

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 als Funktion

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

Nimmt Eingaben als Befehlszeilenargument.

Batch, 62 Bytes

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

Dies stellte sich als ein Byte heraus, das kürzer ist als das explizite Verdoppeln tin einer Schleife:

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

Retikular , 12 Bytes

1idp~dw2*~2j

Probieren Sie es online!

Erläuterung

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

1 Byte dank @raznagul gespeichert.

Python 2, 54 Bytes

Verwendet eine lange Berechnung anstelle von Timing-Bibliotheken.

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

PowerShell, 35 33 30 29 Bytes

Mit einem hilfreichen Hinweis von was auch immer und Joey

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

Erläuterung

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

Ausgeführt mit:

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

Python 3, 49 Bytes

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

Nutzt die leichte Verzögerung der +=Operation und führt sie xmal aus. xverdoppelt sich, indem man eins zu sich selbst addiert, so oft wie der Wert vonx .

Es beginnt bei 6^6(46656), um die maximale Abweichung von 5% in der Verzögerung einzuhalten.

Perl 6 , 39 Bytes

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

Probieren Sie es aus (print überschrieben, um Timing-Informationen hinzuzufügen)

Erweitert:

  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

^{Durchgestrichen 44 ist immer noch 44}

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

Magst du keine Alarmbomben?

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

Technisch korrekt, aber lückenhaft:

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

-3 Bytes dank Cyoce, -2 dank Business Cat, -2 dank Neil

Common Lisp, 49 Bytes

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

Die erste Verzögerung sollte die 1zweite sein.

Pyth, 7 Bytes

#|.d~yT

Erläuterung:

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

TI-BASIC, 36 Bytes

Die anfängliche Wartezeit beträgt 1 Sekunde.

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

Schläger, 51 Bytes

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

Beispiel

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