Pausa doppia


15

La tua sfida è stampare l'input, attendere qualsiasi tempo, stampare l'input, attendere due volte il tempo che hai inizialmente aspettato, stampare di nuovo l'input e così via. Il ritardo iniziale deve essere inferiore a 1 ora e nei ritardi successivi devi avere un'accuratezza del +/- 5%. A parte questo, non ci sono restrizioni sul tempo di ritardo.

Esempio:

Ingresso: hi.

Uscita: hi(pausa 1ms) hi(pausa 2ms) hi(pausa 4ms hi) hi(pausa 8ms ) (pausa 16ms), ecc.

Inoltre consentito:

hi(Pausa di 1 minuto) hi( pausa di 2 minuti) hi( pausa di 4 minuti) hi(pausa di 8 minuti) hi(pausa di 16 minuti), ecc.

L'input deve essere fornito all'avvio del programma (STDIN, parametro della riga di comando, parametro della funzione, ecc.) E sarà una stringa.

Il ritardo iniziale non può essere 0.


L'output deve essere infinito o può arrestarsi dopo un certo periodo di tempo?
Compagno SparklePony

1
@ComradeSparklePony deve emettere il più a lungo possibile (fino alla morte per calore dell'universo, crash del computer, stackoverflow, memoria insufficiente, ecc.)
programmatore

@ComradeSparklePony solo se si tratta di qualcosa come stackoverflow, memoria insufficiente, ecc. Ciò y=x=>(x&&alert(x),y())sarebbe tecnicamente consentito, ma lo declasserei.
programmatore

@ programmer5000 Grazie, capito.
Compagno SparklePony,

Posso stampare una nuova riga?
MD XF,

Risposte:


12

05AB1E , 6 byte

Codice:

[=No.W

Spiegazione:

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

Provalo online!


Se inizi aspettando 1 secondo puoi usare winvece di .W.
Riley,

@Riley Non penso che funzionerebbe. waspetta un secondo, qualunque cosa .Waccada , fa scoppiare una e aspetta molti millisecondi.
Compagno SparklePony

@ComradeSparklePony Hai ragione. dovrebbe essere Gw.
Riley,

Non so se rifletta necessariamente qualsiasi problema nel codice, ma nel momento in cui eseguo l'esempio collegato, il motore mi dà: "Avviso: la richiesta ha superato il limite di 60 secondi ed è stata terminata".
doppelgreener,

@doppelgreener Sì, l'interprete online potrebbe non essere l'opzione migliore in questo caso. Offline funziona come un fascino però.
Adnan,

15

Scratch, 8 blocchi + 3 byte

set [n] to [1]; forever { say [x]; wait (n) secs; set [n] to ((n) * (2)) }

Equivalente in Python:

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

1
perché "+ 3 byte"?
Cole Johnson,

2
9 blocchi (ad esempio Forever, n) + 3 byte (ad esempio x, 2)
OldBunny2800

5

Python 3, 60 56 byte

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

changelog:

  • modificato lambda ricorsivo in funzione ricorsiva (-4 byte)

È possibile salvare un byte print
sull'istruzione

1
@numbermaniac Sì, ma poi dovrei passare a Python 2.: P
L3viathan

5

MATL , 8 byte

`GD@WY.T

La prima pausa è di 2 secondi.

Provalo su MATL Online . Oppure vedi una versione modificata che visualizza il tempo trascorso dall'avvio del programma. (Se l'interprete non funziona, aggiorna la pagina e riprova).

O vedi una gif:

enter image description here

Spiegazione

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

@ programmer5000 Per curiosità: l'interprete online ha funzionato per te?
Luis Mendo,

Sì, perché?
programmatore

@ programmer5000 Grazie. Solo per controllare. A volte ci sono problemi di timeout
Luis Mendo

5

Mathematica 34 32 30 29 byte

Soluzione originale 34 byte:

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

Radere 2 byte con Do

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

Elimina un altro byte con la soluzione ricorsiva di @ MartinEnder

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

@ngenisis usa la ricorsione di ReplaceRepeated per radere via un altro byte

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

4
Truelo è 1>0. Ma qualcosa del genere è un po 'più breve:±n_:=#0[Print@n;Pause@#;2#]&@1
Martin Ender

Ho messo il 1<2precedente al tuo commento. Tuttavia, la soluzione ricorsiva salva un byte. Grazie @MartinEnder
Kelly Lowder

±è un byte nella codifica CP-1252 (codifica Windows predefinita).
JungHwan Min,

3
Ancora più breve:1//.n_:>(Print@#;Pause@n;2n)&
ngenisi,

5

Ottava, 42 41 byte

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

Un byte salvato grazie a rahnema1, p*=2è più corto di p=p*2.

Non riesco a credere di non essere riuscito a giocare a golf, ma in realtà non è stato così facile.

  • L'ingresso deve essere all'inizio, quindi la prima parte è impossibile da evitare.
  • Ho bisogno di un numero che viene raddoppiato e deve essere inizializzato davanti al ciclo
    • Sarebbe possibile usare l'input come condizionale per il loop, ma poi dovrei avere p*=2altrove.
    • Pausa non ha un valore di ritorno, altrimenti avrebbe potuto essere while pause(p*=2)

2
Un trucco che ho imparato da rahnema1: input(0)funziona
Luis Mendo

1
@LuisMendo Purtroppo il trucco non funziona nella recente versione di ottava :(
rahnema1

4

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

Provalo online!

-60 byte grazie a Leaky Nun!


2
+1 per "Non usare Java per giocare a golf. È una cattiva idea." Potresti aggiungere un link TIO?
programmatore

@ programmer5000 Certo, ma non funziona, perché TIO attende che il codice finisca.
HyperNeutrino

2
Perché un'interfaccia anziché una classe?
destra

2
@rightfold Un'interfaccia ti consente di omettere l' publicin public static void main.
Leaky Nun,

1
@ColeJohnson sono richiesti gli argomenti.
Leaky Nun,

4

R, 50 48 byte

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

restituisce una funzione anonima che ha un argomento obbligatorio, la stringa da stampare. Non stampa nuove righe, sputa semplicemente xsullo schermo. iè un argomento facoltativo predefinito 1, attende isecondi e raddoppia i.

-2 byte grazie a Pajonk

Provalo online!


Perché non iniziare da i=1allora usare i=i*2alla fine e dormire solo i?
Pajonk,

è un'ottima idea ... lo cambierò.
Giuseppe,

4

Rubino, 34 28 23 22 (+2 per -n) = 24 byte

3 byte risparmiati grazie a Value Ink!

1 byte salvato grazie a daniero

loop{print;sleep$.*=2}

Inizia a 2, quindi 4, ecc.

Spiegazione

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

Dormirà un secondo prima di leggere l'input, ma è già possibile inserirlo
John Dvorak

L'avvio del programma Ruby con il -nflag ti consente di saltare la getschiamata iniziale , perché il flag lo gestirà per te
Value Ink

printsenza argomento equivale a puts$_- un byte salvato
daniero

4

Alice , 16 byte

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

Provalo online! (Non c'è molto da vedere lì, ovviamente, ma puoi controllare la frequenza con cui è stato stampato entro un minuto.)

Spiegazione

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.

4

R, 44 43 byte

Cancellato 44 è ancora regolare 44; (

Questa risposta fornisce già una soluzione decente, ma possiamo risparmiare ancora qualche byte.

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

Funzione anonima che prende praticamente qualsiasi cosa stampabile come argomento x. Inizia a 2 secondi e raddoppia ogni volta in seguito. Abusa del fatto che Tper impostazione predefinita è definito come TRUEvalutato 1.

Inoltre, fintanto che questo commento ottiene ancora il via libera da OP, possiamo renderlo ancora più breve, ma non penso che sia nello spirito della sfida. I tempi di attesa di 0 non sono più consentiti.

function(x)repeat cat(x)

2
guardati, abusando dei poveri Tcosì. nella versione più breve della risposta, non hai nemmeno bisogno di parentesi graffe, solo uno spazio.
Giuseppe,

1
Ehi, se Tnon ti piace, Tpuò difendersi da solo. Inoltre, bella scoperta :)
JAD,

3

Cubix , 30 byte

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

Provalo qui

Questa mappa su un cubo con lunghezza laterale 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
      . . .
      . . .

oh wow, questo sembra un linguaggio pulito
Skidsdev,


3

PHP, 31 byte

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

dorme 1, 2, 4, 8, ... secondi. Esegui come pipe conphp -nR '<code>'

Funzionerà fino alla 63a stampa (su una macchina a 64 bit), dopodiché non ci sarà più attesa.
La versione 1 genererà avvisi sleep() expects parameter 1 to be integer, float given, la
versione 2 genererà un avviso sleep(): Number of seconds must be greater than or equal to 0.

Inserisci @prima sleepper silenziare gli avvisi.



2

Python 3, 61 byte

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

Simile al golf di @ L3viathan, ma utilizza il whileloop


2

CJam, 26 byte

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

Non funziona correttamente su TIO.

La prima pausa è di 20 millisecondi.

Spiegazione

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)

2

C, 51 byte

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

C, 35 byte in funzione

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

Accetta input come argomento della riga di comando.


2

Lotto, 62 byte

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

Questo si è rivelato essere un byte più breve del raddoppio esplicito tin un ciclo:

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

2

Reticolare , 12 byte

1idp~dw2*~2j

Provalo online!

Spiegazione

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.

2

C #, 80 79 byte

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

Salvato un byte grazie a @raznagul.


È possibile salvare 1 byte spostando l' Writeistruzione nel corpo del loop.
raznagul,

@raznagul Non so come mi sia perso quello, grazie!
TheLethalCoder

2

Python 2, 54 byte

Utilizza un lungo calcolo anziché librerie di temporizzazione.

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

Ora noto che la mia risposta è simile alla tua. Non avevo letto la tua risposta quando ho pubblicato, ma se desideri incorporare la mia soluzione nella tua, rimuoverò felicemente la mia risposta.
Tim

2

PowerShell, 35 33 30 29 byte

Con un suggerimento utile da qualunque cosa e Joey

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

Spiegazione

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

Eseguito con:

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

1
dovresti essere in grado di usare un vuoto invece del tempo:% {$ a = 1; for () {$ _; sleep ($ a * = 2)}} ``
qualunque sia

Grazie! Avevo provato a usare un ciclo for prima, ma ho messo for(;;). Non ho nemmeno provato a rimuovere i punti e virgola.
SomeShinyMonica

1
Inserisci $a=1come inizializzazione in forper salvare un altro byte ( for($a=1){...}). Inoltre, non sono sicuro di contare %, poiché la routine effettiva che stai eseguendo è solo un blocco di script. (Le mie sfide tendono ad essere piuttosto rigide nel richiedere un programma, eludendo tali ponderazioni, ma per qualsiasi cosa vada in dubbio non sono ancora del tutto sicuro di come contare i vari modi di usare PowerShell.)
Joey,

@Joey, dolce che funziona. Grazie per la punta
SomeShinyMonica

2

Python 3, 49 byte

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

Utilizza il leggero ritardo +=dell'operazione ed esegue i xtempi. xraddoppia aggiungendone uno a se stesso quante volte il valore di x.

Inizia da 6^6(46656) per attenersi alla variazione massima del 5% nel ritardo.


Intelligente, ma questo è un maialino della memoria.
eush77,

@ eush77 sì, sul mio tablet è terminato dopo solo 7 iterazioni del loop! Mi aspetto che duri ancora un po 'sul mio desktop.
Tim

1

Perl 6 , 39 byte

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

Provalo ( printsovrascritto per aggiungere informazioni sui tempi)

Allargato:

  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

1

JS (ES6), 44 42 40 38 36 byte

Cancellato 44 è ancora 44

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

Non ti piacciono le bombe di allarme?

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

Tecnicamente corretto, ma abusivo di scappatoie:

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

-3 byte grazie a Cyoce, -2 grazie a Business Cat, -2 grazie a Neil


2
Non riesco a testarlo correttamente, ma probabilmente potresti farlo i=1,y=x=>(alert(x),setTimeout(y,i*=2))per salvare un paio di byte
Business Cat

1
Sono andato avanti e modificato in un messaggio di credito per Cyoce; se vuoi cambiarlo, sentiti libero di modificare / ripristinare.
HyperNeutrino,

1
Che ne dici i=1,y=x=>setTimeout(y,i*=2,console.log(x))?
Neil,

1

Lisp comune, 49 byte

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

il primo ritardo dovrebbe essere il 1secondo.


1
Hai 321 rappresentanti!
programmatore

@ programmer5000 hai 3683 rappresentanti!
Cyoce,

1

Pyth, 7 byte

#|.d~yT

Spiegazione:

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

1

TI-BASIC, 36 byte

Il periodo di attesa iniziale è di 1 secondo.

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

1

Racchetta, 51 byte

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

Esempio

➜  ~  racket -e '((λ(s)(do([n 1(* n 2)])(#f)(displayln s)(sleep n)))"Hello")'
Hello
Hello
Hello
Hello
Hello
^Cuser break
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.