Votre défi est d'imprimer l'entrée, d'attendre n'importe quelle durée, d'imprimer l'entrée, d'attendre deux fois le temps que vous avez initialement attendu, d'imprimer à nouveau l'entrée, etc. Le retard initial doit être inférieur à 1 heure et vous devez avoir une précision de +/- 5% dans les retards suivants. En dehors de cela, il n'y a aucune restriction sur le temps de retard.

Exemple:

Entrée: hi.

Sortie: hi(1ms pause) hi(2ms pause) hi(4ms pause) hi(8ms pause) hi(16ms pause), etc.

Également autorisé:

hi(Pause de 1 minute) hi( pause de 2 minutes) hi( pause de 4 minutes) hi(pause de 8 minutes) hi(pause de 16 minutes), etc.

L'entrée doit être fournie au début du programme (STDIN, paramètre de ligne de commande, paramètre de fonction, etc.) et sera une chaîne.

Le délai initial ne peut pas être 0.

05AB1E , 6 octets

Code:

[=No.W

Explication:

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

Essayez-le en ligne!

Scratch, 8 blocs + 3 octets

Équivalent en Python:

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

Python 3, 60 56 octets

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

Journal des modifications:

• changé lambda récursif en fonction récursive (-4 octets)

MATL , 8 octets

`[email protected]

La première pause est de 2 secondes.

Essayez-le sur MATL Online . Ou consultez une version modifiée qui affiche le temps écoulé depuis le démarrage du programme. (Si l'interprète ne fonctionne pas, veuillez actualiser la page et réessayer).

Ou voyez un gif:

Explication

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

Solution d'origine 34 octets:

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

Raser 2 octets avec Do

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

Rasez un octet de plus avec la solution récursive de @ MartinEnder

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

@ngenisis utilise la récursion ReplaceRepeated pour raser un autre octet

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

Octave, 42 41 octets

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

Un octet enregistré grâce à rahnema1, p*=2est plus court que p=p*2.

Je ne peux pas croire que je n'ai pas pu jouer au golf, mais ce n'était pas si simple.

• L'entrée doit être au début, donc la première partie est impossible à éviter.
• J'ai besoin d'un nombre qui double, et il doit être initialisé devant la boucle
  • Il serait possible d'utiliser l'entrée comme conditionnelle pour la boucle, mais je devrais alors avoir p*=2quelque part ailleurs.
  • La pause n'a pas de valeur de retour, sinon elle aurait pu être while pause(p*=2)

Java (OpenJDK 8) , 113 octets

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

Essayez-le en ligne!

-60 octets grâce à Leaky Nun!

R, 50 48 octets

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

renvoie une fonction anonyme qui a un argument obligatoire, la chaîne à imprimer. N'imprime aucune nouvelle ligne, crache juste xsur l'écran. iest un argument facultatif qui prend par défaut 1, attend les isecondes et double i.

-2 octets grâce à pajonk

Essayez-le en ligne!

Ruby, 34 28 23 22 (+2 pour -n) = 24 octets

3 octets économisés grâce à Value Ink!

1 octet économisé grâce à daniero

loop{print;sleep$.*=2}

Commence 2alors 4, etc.

Explication

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

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

Essayez-le en ligne! (Pas grand-chose à voir bien sûr, mais vous pouvez vérifier la fréquence à laquelle il a été imprimé en une minute.)

Explication

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 octets

Biffé 44 est toujours régulier 44; (

Cette réponse fournit déjà une solution décente, mais nous pouvons économiser quelques octets supplémentaires.

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

Fonction anonyme prenant pratiquement n'importe quoi imprimable comme argument x. Commence à 2 secondes et double à chaque fois par la suite. Abuse le fait qui Test défini par défaut comme TRUEqui s'évalue 1.

Aussi, tant que ce commentaire obtient toujours le feu vert d'OP, nous pouvons le rendre encore plus court, mais je ne pense pas que ce soit dans l'esprit du défi. Les temps d'attente de 0 ne sont plus autorisés.

function(x)repeat cat(x)

Cubix , 30 octets

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

Essayez-le ici

Cela correspond à un cube avec une longueur de côté 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 octets

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

Pour une raison quelconque, TIO n'affiche pas la sortie tant que vous n'avez pas arrêté l'exécution du programme.

Essayez-le en ligne!

PHP, 31 octets

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

dort 1, 2, 4, 8, ... secondes. Exécuter en tant que tuyau avecphp -nR '<code>'

Fonctionnera jusqu'à la 63e impression (sur une machine 64 bits), après quoi il n'y aura plus d'attente.
La version 1 produira des avertissements sleep() expects parameter 1 to be integer, float given, la
version 2 produira un avertissement sleep(): Number of seconds must be greater than or equal to 0.

Insérez @avant sleeppour désactiver les avertissements.

TI-Basic, 21 octets

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

Python 3, 61 octets

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

Similaire au golf de @ L3viathan, mais utilise la whileboucle

CJam, 26 octets

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

Ne fonctionne pas correctement sur TIO.

La première pause est de 20 millisecondes.

Explication

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 octets

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

C, 35 octets en fonction

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

Prend l'entrée comme argument de ligne de commande.

Lot, 62 octets

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

Cela s'est avéré être un octet plus court que le doublement explicite tdans une boucle:

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

Réticulaire , 12 octets

1idp~dw2*~2j

Essayez-le en ligne!

Explication

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 octets

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

Un octet enregistré grâce à @raznagul.

Python 2, 54 octets

Utilise un calcul long au lieu de bibliothèques de synchronisation.

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

PowerShell, 35 33 30 29 octets

Avec un indice utile de tout et Joey

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

Explication

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

Exécuté avec:

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

Python 3, 49 octets

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

Utilise le léger retard de l' +=opération et l'exécute plusieurs xfois. xdouble en s'ajoutant à lui-même autant de fois que la valeur dex .

Il commence à 6^6(46656) pour s'en tenir à la variation maximale de 5% du retard.

Perl 6 , 39 octets

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

Essayez-le (print remplacé pour ajouter des informations de synchronisation)

Étendu:

  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 octets

^{Barré 44 est toujours 44}

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

Vous n'aimez pas les bombes alertes?

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

Techniquement correct, mais abusif:

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

-3 octets grâce à Cyoce, -2 grâce à Business Cat, -2 grâce à Neil

Lisp commun, 49 octets

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

le premier délai devrait être le 1deuxième.

Pyth, 7 octets

#|.d~yT

Explication:

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

TI-BASIC, 36 octets

La période d'attente initiale est de 1 seconde.

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

Raquette, 51 octets

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

Exemple

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