Questa sfida è ispirata a xkcd :

Sfida:

Simulerai la copia di un file di grandi dimensioni (1 Gigabyte). La velocità di trasferimento varierà tra 10 kB / secondo a 100 MB / secondo. Il tuo compito è di generare il tempo rimanente del trasferimento di file. L'output dovrebbe apparire come:

Time remaining: 03:12    (meaning it's 3 minutes and 12 seconds left)
Time remaining: 123:12   (meaning it's 2 hours, 3 minutes and 12 seconds left)
Time remaining: 02:03:12 (optional output, meaning the same as above)

Gli zeri iniziali non devono essere visualizzati per minuti e ore (facoltativo), ma devono essere visualizzati per secondi. Mostrare il tempo rimanente usando solo i secondi non è OK.

Il trasferimento di file:

• La velocità di trasferimento inizierà a 10 MB / secondo.
• Ogni secondo, ci sarà una probabilità del 30% che la velocità di trasferimento cambierà
• La nuova velocità di trasferimento deve essere selezionata in modo casuale (distribuzione uniforme) nell'intervallo [10 kB/s, 100 MB/s], con incrementi di 10 kB / s.

Nota: non è necessario copiare effettivamente un file.

Puoi scegliere di usare:, 1 GB = 1000 MB, 1 MB = 1000 kB, 1 kB = 1000 Bo 1 GB = 1024 MB, 1 MB = 1024 kB, 1 kB = 1024 B.

Produzione:

• Inizi a 01:40, no 01:39.
• Si visualizza il tempo dopo la modifica della velocità di trasferimento, ma prima che qualcosa venga trasferito a tale velocità
• I secondi dovrebbero essere visualizzati come numeri interi, non decimali. È facoltativo arrotondare per eccesso / per difetto / il più vicino.
• Dovresti cancellare lo schermo ogni secondo, a meno che non sia impossibile nella tua lingua.
• L'output dovrebbe essere costante: al Time remaining: 00:00termine del trasferimento dei file.

Esempio:

Ho arrotondato tutti i secondi decimali. Supponiamo che le linee sottostanti vengano visualizzate con un secondo in mezzo e che lo schermo venga cancellato tra ognuna:

Time remaining: 01:40  (Transfer rate: 10 MB/s)
Time remaining: 01:39      1 GB - 10 MB
Time remaining: 01:38      1 GB - 2*10 MB
Time remaining: 01:37      1 GB - 3*10 MB
Time remaining: 01:28:54   1 GB - 4*10 MB  (TR: 180 kB/s)
Time remaining: 01:28:53   1 GB - 4*10 MB - 180 kB
Time remaining: 01:28:52   1 GB - 4*10 MB - 2*180 kB  
Time remaining: 00:13      1 GB - 4*10 MB - 3*180 kB  (TR: 75 MB/s)
Time remaining: 00:12      1 GB - 4*10 MB - 3*180 kB - 75 MB
Time remaining: 00:11      1 GB - 4*10 MB - 3*180 kB - 2*75 MB
Time remaining: 00:10      1 GB - 4*10 MB - 3*180 kB - 3*75 MB
Time remaining: 00:09      1 GB - 4*10 MB - 3*180 kB - 4*75 MB
Time remaining: 00:08      1 GB - 4*10 MB - 3*180 kB - 5*75 MB
Time remaining: 14:09:06   1 GB - 4*10 MB - 3*180 kB - 6*75 MB  (TR: 10 kB/s)
Time remaining: 14:09:05   1 GB - 4*10 MB - 3*180 kB - 6*75 MB - 10 kB
Time remaining: 00:06      1 GB - 4*10 MB - 3*180 kB - 6*75 MB - 20 kB  (TR: 88.110 MB/s)
Time remaining: 00:05
Time remaining: 00:04
Time remaining: 00:03
Time remaining: 00:02
Time remaining: 00:01
Time remaining: 00:00     <- Transfer is finished. Display this.

Pyth - 70 68 byte

K^T5J^T3W>KZ%." r3úBTê;¥
í".D/KJ60=J?<OT3O^T4J=-KJ.d1.

Provalo online senza dormire .

PowerShell , 190 215 187 byte

($t="Time remaining: ")+"00:01:42";for($f,$r=1gb,10mb;$f-gt0;$f-=$r){if((Random 10)-lt3){$r=(Random -mi 1kb -ma (10mb+1))*10}$t+[Timespan]::FromSeconds([int]($f/$r));sleep 1}$t+"00:00:00"

Provalo online! (TIO non supporta la cancellazione dello schermo tra le righe)

Imposta la nostra $fdimensione iniziale di ile e il nostro trasferimento iniziale $ra 1gbe 10mb/ s, rispettivamente. Quindi, fintanto che rimane ancora $file, eseguiamo il loop.

All'interno del ciclo, le ifseleziona un numero da 0a 9compreso, e se è 0, 1 o 2 (cioè il 30% del tempo), si cambia il tasso. Questo seleziona un numero intero casuale tra 1kbe 10mbquindi viene moltiplicato 10per ottenere il conteggio dei passi.

Quindi sfruttiamo il FromSeconds metodo statico dalla TimeSpanlibreria .NET per costruire il tempo rimanente. Il formato di output di quella chiamata corrisponde esattamente ai requisiti della sfida, quindi non è necessaria una formattazione aggiuntiva.

(Ho salvato un sacco grazie a @ConnorLSW)

MATL , 78 byte

Grazie a @Maltysen e @DigitalTrauma per le correzioni.

1e5 1e3`XK10&XxyXIy/t0>*12L/'MM:SS'XO'Time remaining: 'whD-r.3<?1e4Yr}K]I0>]xx

Provalo su MATL Online! (potrebbe essere necessario premere più volte "Esegui" se inizialmente non funziona).

L'interprete online scade dopo 30 secondi. Potresti voler cambiare 10(tempo di pausa in decimi di secondo) in qualcosa di più piccolo, ad esempio3 per aumentare la velocità di visualizzazione

Spiegazione

1e5                  % Push 1e5: file size in 10-kB units
1e3                  % Push 1e3: initial rate in 10-kB/s units
`                    % Do...while
  XK                 %   Copy current rate into clipboard K (doesn't consume it)
  10&Xx              %   Wait 1 second and clear screen
  y                  %   Duplicate current file size onto the top of the stack
  XI                 %   Copy it to clipboard I (doesn't consume it)
  y                  %   Duplicate current rate onto the top of the stack
  /                  %   Divide. This gives the estimated remaining time in seconds
                     %   It may be negative in the last iteration, because the
                     %   "remaining" file size may have become negative
  t0>*               %   If negative, convert to 0
  12L/               %   Push 86400 and divide, to convert from seconds to days
  'MM:SS'XO          %   Format as a MM:SS string, rounding down
  'Time remaining: ' %   Push this string
  wh                 %   Swap, concatenate
  D                  %   Display
  -                  %   Subtract. This gives the new remaining file size
  r                  %   Push random number uniformly distributed in (0,1)
  .3<                %   Is it less than 0.3?
  ?                  %   If so
    1e4Yr            %     Random integer between 1 and 1e4. This is the new rate 
                     %     in 10-kB/s units
  }                  %   Else
    K                %     Push rate that was copied into clipboard K
  ]                  %   End
  I                  %   Push previous remaining file size from clipboard I
  0>                 %   Is it positive?
]                    % End. If top of the stack is true: next iteration
xx                   % Delete the two numbers that are on the stack

Rubino, 116 110 byte

Provalo in rete, ad eccezione repl.it si legge \rcome un ritorno a capo e, inoltre, non può essere utilizzato $><<in modo che sia sostituito con il suo equivalente 5-byte print.

Invia a JonasWielicki l'idea iniziale di utilizzare \rper ripristinare la linea.

f=1e5;r=1e3;(k=f/r=rand<0.3?1+rand(1e4):r;$><<"\rTime remaining: %02d:%02d"%[k/60,k%60];f-=r;sleep 1)while f>0

Questa versione non è testata su Windows, ma funziona su Unix.

Bash + utils comuni, 117

Implementazione semplice. Alcuni byte salvati dividendo per 10000:

for((b=10**5,r=1000;b>0;r=RANDOM%10<3?RANDOM%10000+1:r,b-=r));{
clear
date -ud@$[b/r] "+Time remaining: %T"
sleep 1
}

Provalo online . Usando sleep 0sul TIO in modo da non dover aspettare. clearnon funziona su TIO.

JavaScript (ES6), 162 byte

Mostra i minuti così come con i secondi imbottiti (a pavimento)

Per esempio, 123:45

t=1e5
s=1e3
setInterval(c=>c.log(`Time remaining: ${c.clear(d=t/s),d/60|0}:`+`0${t-=s>t?t:s,r=Math.random,s=r()<0.3?1+r()*1e4|0:s,d%60|0}`.slice(-2)),1e3,console)

Python 3.6 ( 212 203 byte)

from random import*
import time,datetime
r=1e7
d=1e9
while 1:
 print(f"\x1b[KTime remaining: {datetime.timedelta(seconds=d//r)}",end="\r");d=max(0,d-r);time.sleep(1)
 if random()>.7:r=randint(1,1e4)*1e4

Abbastanza semplice, penso. Cancella la linea usando la sequenza e il Kcomando di escape ANSI .

• Salvataggio di 9 byte grazie a @ValueInk

Lotto, 193 byte

@set/ap=10000,s=p*10,r=p/10
:l
@set/at=s/r,m=t/60,n=t%%60+100,s-=r
@cls
@echo Time remaining: %m%:%n:~1%
@timeout/t>nul 1
@if %random:~-1% lss 3 set/ar=%random%%%p+1
@if %t% gtr 0 goto l

Nota: leggera inclinazione verso tassi di 27,68 MB / s o meno.

C 184 171 155 byte

f(){i,j=0,r=1e7;for(i=1e9;i>0;i-=r){j=i/r;printf("Time remaining: %02d:%02d:%02d\r",j/3600,(j/60)%60,j%60);sleep(1);if(rand()%10<3)r=(rand()%10000)*1e4;}}

Spero che questo si qualifichi.

Versione non golfata:

void f()
{
    int j=0;
    float rate=1e7; 
    for(int size=1e9;i>0; size-=rate)
    {     
       j=size/rate;      
       printf("Time remaining: %02d:%02d:%02d\r",j/3600,(j/60)%60,j%60);
       sleep(1);

       if(rand()%10<3)
          rate=(rand()%10000)*1e4;          



   }

}

Spiegazione: Nella versione golfed icorrisponde sizenella versione ungolfed ed rè ratenella versione ungolfed. jmemorizza il tempo rimanente in secondi.

• Ho 10 ^ 9 byte da copiare. Inizio a copiare alla velocità di 10 Megabyte / secondo,
• Se la probabilità è inferiore al 30%, modificare la velocità (da 10 kilobyte a 100 Megabyte al secondo)

@ValueInk Grazie per aver salvato 13 byte.

@ nmjcman101 Grazie per aver salvato 16 byte.