Ce défi est inspiré de xkcd :

Défi:

Vous simulerez la copie d'un fichier volumineux (1 gigaoctet). Le taux de transfert variera entre 10 ko / seconde et 100 Mo / seconde. Votre tâche consiste à afficher le temps restant du transfert de fichier. La sortie devrait ressembler à:

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)

Les zéros au début ne doivent pas nécessairement être affichés pendant des minutes et des heures (facultatif), mais doivent être affichés pendant des secondes. Afficher le temps restant en secondes seulement n’est pas correct.

Le transfert de fichier:

• Le taux de transfert débutera à 10 Mo / seconde.
• Chaque seconde, il y aura 30% de chances que le taux de transfert change
• Le nouveau taux de transfert doit être choisi de manière aléatoire (distribution uniforme) dans la plage [10 kB/s, 100 MB/s], par incréments de 10 kB / s.

Remarque: vous n'avez pas besoin de copier un fichier.

Vous pouvez choisir d'utiliser:, 1 GB = 1000 MB, 1 MB = 1000 kB, 1 kB = 1000 Bou 1 GB = 1024 MB, 1 MB = 1024 kB, 1 kB = 1024 B.

Sortie:

• Vous commencez à 01:40, non 01:39.
• Vous affichez l'heure après que le taux de transfert ait changé, mais avant que rien ne soit transféré à ce taux
• Les secondes doivent être affichées sous forme de nombres entiers et non de décimales. Il est facultatif d'arrondir haut / bas / le plus proche.
• Vous devriez vider l'écran toutes les secondes, à moins que ce ne soit impossible dans votre langue.
• La sortie doit être constante: Time remaining: 00:00lorsque le transfert de fichier est terminé.

Exemple:

J'ai arrondi toutes les secondes décimales. Supposons que les lignes ci-dessous sont affichées avec une seconde d'intervalle et que l'écran est effacé entre elles:

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 octets

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

Essayez-le en ligne sans dormir .

PowerShell , 190 215 187 octets

($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"

Essayez-le en ligne! (TIO ne prend pas en charge le nettoyage d'écran entre les lignes)

Définit notre $ftaille d’ile initiale et notre transfert initial $rmangé sur 1gbet 10mb/ s, respectivement. Puis, tant qu'il nous reste $fencore, nous bouclons.

Dans la boucle, la iftouche sélectionne un nombre compris entre et, et si le nombre est égal 0à 90, 1 ou 2 (c'est-à-dire 30% du temps), nous modifions le taux. Cela prend un entier aléatoire entre 1kbet 10mbalors que ce multiplié par le 10nombre pour obtenir notre étape.

Nous utilisons ensuite la FromSeconds méthode statique de la TimeSpanbibliothèque .NET pour construire le temps restant. Le format de sortie de cet appel correspond exactement aux exigences du challenge, évitant ainsi un formatage supplémentaire.

(Enregistré un tas grâce à @ConnorLSW)

MATL , 78 octets

Merci à @Maltysen et @DigitalTrauma pour les corrections apportées.

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

Essayez-le sur MATL Online! (vous devrez peut-être appuyer sur "Exécuter" plusieurs fois si cela ne fonctionne pas initialement).

L'interprète en ligne expire après 30 secondes. Vous voudrez peut-être changer 10(temps de pause en dixièmes de seconde) pour quelque chose de plus petit, par exemple3 pour augmenter la vitesse d'affichage

Explication

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

Ruby, 116 110 octets

Essayez en ligne, à l' exception repl.it lit \rcomme un saut de ligne et ne peut pas utiliser $><<donc il est remplacé par son équivalent de 5 octets, print.

Shoutout à JonasWielicki pour l’idée initiale d’utiliser \rpour réinitialiser la ligne.

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

Cette version n'a pas été testée sous Windows, mais fonctionne sous Unix.

Bash + utils communs, 117

Mise en œuvre simple. Quelques octets économisés en divisant par 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
}

Essayez-le en ligne . Utilisation sleep 0sur le TIO pour ne pas avoir à attendre. clearne fonctionne pas sur TIO.

JavaScript (ES6), 162 octets

Affiche les minutes telles quelles avec des secondes rembourrées (sol)

Par exemple, 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 octets)

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

Assez simple, je pense. Efface la ligne à l'aide de la séquence et de la Kcommande d' échappement ANSI .

• 9 octets sauvés grâce à @ValueInk

Lot, 193 octets

@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

Remarque: Léger biais vers des taux de 27,68 Mo / s ou moins.

C 184 171 155 octets

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

J'espère que cela se qualifie.

Version non-golfée:

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;          



   }

}

Explication: Dans la version golfée, icorrespond à la sizeversion non-golfée et rest rateen version non-golfée. jstocke le temps restant en secondes.

• J'ai 10 ^ 9 octets à copier. Je commence à copier à la vitesse de 10 mégaoctets / seconde,
• Si la probabilité est inférieure à 30%, modifiez le taux (de 10 kilo-octets à 100 mégaoctets par seconde).

@ValueInk Merci d'avoir économisé 13 octets.

@ nmjcman101 Merci d'avoir économisé 16 octets.