Mettez en place un chronomètre numérique simple , qui affichera le temps écoulé en secondes et minutes, comme décrit ci-dessous.

Important

Veuillez lire les sections Affichage et Commandes !

Afficher

Le temps écoulé, doit être affiché au MM:SSformat, en remplaçant la chaîne de temps précédemment affichée "en place" (l'effacement de tout ou partie de l'écran est également autorisé).

Le chronomètre doit être mis à jour au moins toutes les secondes.

Exemples:

0 minutes, 0 secondes

00:00

0 minutes, 33 secondes

00:33

1 minute, 50 secondes

01:50

Initialement, vous pouvez commencer par '00: 00 'ou avec toute autre valeur dans la plage [00: 00-59: 59].

Une fois votre chronomètre atteint 59:59, il devrait se réinitialiser 00:00et recommencer.

Vous pouvez utiliser une base différente (au lieu de décimale) ou même un système numérique différent si vous le souhaitez, tant que vous suivez le schéma général.

Par exemple, 13:03peut être affiché comme:

Décimal

13:03

Hexadécimal

0D:03

Base64

N:D

Base quater-imaginaire

10101:3

Chiffres romains

XIII:III

Attention, si vous utilisez un système / base numérique non décimal, il doit être codé en utilisant des caractères ASCII (ou Unicode) imprimables, par exemple en utilisant deux octets binaires (non imprimables) pendant minutes et secondes n'est pas autorisé.

Vous devez également remplir votre sortie avec des zéros, le cas échéant, si votre système numérique le permet.

Le remplacement du caractère séparateur :par tout autre caractère imprimable (y compris les chiffres) est également acceptable.

Les contrôles

Le chronomètre doit démarrer en pause , et rester dans cet état, jusqu'à ce que l'utilisateur le démarre explicitement , en appuyant sur la touche «contrôle» (voir ci-dessous).

Si, pendant que le chronomètre compte, l'utilisateur appuie à nouveau sur la touche «contrôle» , le chronomètre doit s'arrêter (en gardant l'heure actuelle), jusqu'à ce que la touche «contrôle» soit enfoncée une fois de plus.

La touche «contrôle» peut être une seule touche, par exemple s, ou n'importe quelle combinaison de touches, par exemple Ctrl+Shift+X, mais elle doit être «atomique», sil Entern'est pas permis d' appuyer sur plusieurs touches en séquence, par exemple alors .

La même touche (ou combinaison) de contrôle doit être utilisée pour mettre en pause et reprendre le chronomètre.

Vous devez utiliser une clé de «contrôle» spécifique , c'est-à-dire que «toute clé» n'est pas autorisée.

Alternativement, vous pouvez utiliser un simple ou double clic de souris, au lieu d'une pression de touche pour «contrôler».

Règles

• C'est le code-golf , la réponse la plus courte en octets gagne;
• Les failles de code-golf standard s'appliquent;
• Votre programme doit (théoriquement) être capable de fonctionner pour toujours.

SmileBASIC, 86 77 71 octets

@L
N=N!=DIALOG(FORMAT$("%02D:%02D",F/60MOD 60,F MOD 60),,,N)F=F+1GOTO@L

DIALOGaffiche une zone de texte sur l'écran tactile. Nest le nombre de secondes pendant lesquelles la zone de texte restera à l'écran avant de disparaître. Si tel Nest le cas 0, il reste jusqu'à ce que l'utilisateur appuie sur le bouton de l'écran tactile.

DIALOGRenvoie 1si l'utilisateur a appuyé sur le bouton et 0s'il s'est fermé automatiquement. Ainsi, lorsque l'utilisateur appuie sur le bouton de pause, il revient 1et la durée d'affichage est réglée sur 0, mettant le chronomètre en pause. Une fois que l'utilisateur a appuyé à nouveau sur le bouton, nous avons rétabli la durée d'affichage à 1, en reprenant la minuterie. Fondamentalement, à chaque DIALOGretour 1, le temps d'affichage bascule entre 1et 0utilise !=, ce qui équivaut à un XOR logique tant que les deux entrées sont 1 ou 0.

Python 2, 167 129 octets

-36 octets principalement * en utilisant l'idée de Maltysen d'attraper en ctrl-cutilisant une exception - allez donner du crédit!
-4 octets grâce à DLosc (init net bà 0 plutôt que f())
-1 octet grâce à FlipTack (utiliser p^=1plutôt que p=1-p)
-2 octets grâce à Felipe Nardi Batista (supprimer les spécificateurs de précision)

import time
f=time.time
n=b=p=0
while 1:
 try:n=[n,f()][p];t=n-b;print'\r%02d:%02d'%(t/60%60,t%60),
 except:b=[b-n+f(),b][p];p^=1

Fonctionne de la même manière que mon original, ci-dessous, mais avec la séquence de touches de contrôle de ctrl+c.
(Testé par moi avec Python 2.7.8 sur Windows 7, 64 bits;
Testé par Brian Minton avec Python 2.7.13 sur linux, 64 bits)

* a également réduit la ifdéclaration à une recherche de liste afin d'obtenir le trycomme une ligne.

Mon original:

import time,msvcrt as m
f=time.time
n=b=p=0
while 1:
 if m.kbhit()and m.getch()==b'p':b=[b-n+f(),b][p];p^=1
 if p:n=f()
 t=n-b;print'\r%0.2d:%0.2d'%(t/60%60,t%60),

(Testé par moi avec Python 2.7.8 sur Windows 7, 64 bits - ce code, cependant, est spécifique à Windows en raison de l'utilisation de la msvcrtbibliothèque)

La touche de commande est «p».

net bsont initialisés à la même valeur au démarrage, donnant un "décalage" de 0; pest initialisé à 0, indiquant un état de pause.

Chaque fois que la touche de commande est enfoncée, la valeur de pest modifiée. Lors du passage d'un état en pause à un état actif, bune nouvelle valeur est mise à jour en conservant tout décalage actuel par rapport au ou aux états actifs précédents avec b-n.

Pendant un état actif nest mis à jour à plusieurs reprises à l'heure actuelle en appelant time.time().

La différence entre net b, test alors le nombre total de secondes (y compris une partie fractionnaire) écoulées pendant le ou les états actifs.

Les minutes écoulées sont alors t/60et chacune des minutes et des secondes est affichée mod 60 avec (t/60%60,t%60). Les zéros de tête sont ajoutés pour chacun en utilisant le formatage de chaîne de la partie entière avec '...%0.2d...'. L'impression d'un tuple (le dernier ,) où le premier élément a un retour chariot principal (le \r) entraîne l'écrasement du texte précédemment imprimé.

Python - 160 159 143 octets

Merci à @JonathanAllan de m'avoir sauvé 18 octets!

N'utilise que des bibliothèques intégrées, donc la clé de contrôle est ctrl-c, l'attrapant avec un except keyboardInterrupt.

import time
Z=0
print'00:00'
while 1:exec"try:\n while 1:\n  %s\nexcept:1\n"*2%(1,"print'\033c%02d:%02d'%divmod(Z%3600,60);Z+=1;time.sleep(1)")

utilitaires bash + Unix, 90 ou 93 octets

Version 90 octets:

trap d=\$[!d] 2;for((n=0;;)){((d|!n))&&dc<<<DP60dod*d$n\r%+n|colrm 1 4&&: $[n++];sleep 1;}

Version 93 octets:

trap d=\$[!d] 2;for((n=0;;)){((d|!n))&&dc<<<DP60dod*$n+n|colrm 1 4&&n=$[(n+1)%3600];sleep 1;}

Ctrl-C est le caractère de reprise / pause. Un espace est le délimiteur entre les minutes et les secondes.

La différence entre les deux versions est que le programme de 90 octets fonctionnera pendant 2 ^ 63 secondes (à ce moment-là, bash me donnera un débordement d'entier).

La version 93 octets fonctionnera vraiment pour toujours.

Le problème d'origine comprenait l'exigence: "Votre programme doit (théoriquement) être capable de fonctionner pour toujours."

Si l'exécution pendant 2 ^ 63 secondes est suffisante pour répondre à cette exigence, la solution à 90 octets fonctionne. Cette durée est plus de 20 fois l'âge de l'univers!

Si le programme doit pouvoir fonctionner plus longtemps que cela, je devrai opter pour la solution de 93 octets.

Je devrais probablement signaler que cette solution, ainsi que certaines au moins des autres affichées, prendront très lentement du retard sur le temps réellement écoulé. Ce glissement est dû au fait que le programme dort pendant une seconde entre chaque exécution du corps de la boucle, mais le corps de la boucle prend un tout petit peu de temps à s'exécuter. Ce sera sans conséquence dans la pratique.

QBasic, 213 211 octets

La clé de contrôle est tab. Laisser cette fonction peut provoquer des incendies d'ordinateurs portables. Tu étais prévenu.

DO
WHILE k$<>CHR$(9)
k$=INKEY$
LOCATE 1
?CHR$(48+m\10);CHR$(48+(m MOD 10));":";CHR$(48+(d MOD 60)\10);CHR$(48+(d MOD 10))
IF r THEN
n=TIMER
d=v+n-b+86400
m=d\60MOD 60
END IF
WEND
k$=""
v=v+n-b
r=1-r
b=TIMER
LOOP

Ici, il est en action, s'arrêtant à 10, 15 et 20 secondes:

Non golfé et commenté

' Outer loop runs forever
DO
  ' The WHILE-WEND loop runs until tab is pressed
  WHILE key$ <> CHR$(9)
    key$ = INKEY$
    ' Output the stopwatch value at top left of screen
    LOCATE 1
    ' Unfortunately, QBasic's PRINT USING doesn't have a format for printing
    ' with leading zeros, so we have to do it manually by printing the
    ' 10s digit and the 1s digit
    PRINT CHR$(48 + minute \ 10); CHR$(48 + (minute MOD 10));
    PRINT ":";
    PRINT CHR$(48 + second \ 10); CHR$(48 + (second MOD 10))
    ' Update the current time if the running flag is set
    IF running THEN now = TIMER
    ' Take the difference between now and the last time we started the
    ' stopwatch, plus the amount of saved time from previous runs,
    ' plus 86400 to account for the possibility of running over midnight
    ' (since TIMER is the number of seconds since midnight, and QBasic's
    ' MOD doesn't handle negative values like we would need it to)
    diff = saved + now - lastStarted + 86400
    second = diff MOD 60
    minute = diff \ 60 MOD 60
  WEND
  ' If we're outside the WHILE loop, the user pressed tab
  key$ = ""
  ' Add the previous run's time to the saved amount
  saved = saved + now - lastStarted
  ' Toggle running between 0 and 1
  running = 1 - running
  ' If we're starting, we want to put the current time in lastStarted;
  ' if we're stopping, it doesn't matter
  lastStarted = TIMER
LOOP

Notez que les valeurs de TIMERsont à virgule flottante. Cela n'affecte pas la sortie, car MODet \tronquer en entiers. Mais cela ajoute de la précision à la quantité de temps gagné: si vous mettez la minuterie en pause juste avant un tick, vous verrez au redémarrage que le nombre change en moins d'une seconde.

Lot, 132 octets

set/ar=0,m=s=100
:l
cls
@choice/t 1 /d y /m %m:~1%:%s:~1% /n
set/as+=r,m+=c=s/160,s-=c*60,m-=m/160*60,r^^=%errorlevel%-1
goto l

Appuyez sur npour (dé) interrompre la minuterie. Le scintillement de sortie peut être réduit au coût de trois (ou quatre) octets.

Pure bash, 141 octets

set -m
while ! read -t 1;do printf '\r%02i:%02i' $[s=s>3598?0:s+1,s/60] $[s%60];done&trap 'fg>/dev/null' TSTP
printf '00:00'
kill -STOP $!
read

Cela n'utilise rien d'autre que les commandes internes de Bash (pas d'outils externes). Le caractère de contrôle est Ctrl-Z, de sorte que la SIGTSTPgestion standard suspend le chronomètre.

• set -mactive le contrôle des travaux , qui est généralement désactivé dans un script.
• Un processus de sous-shell est en arrière& - plan ( ) .
  • read -t 1attend une seconde l'entrée de l'utilisateur , puis échoue.
  • La untilboucle continue tant qu'elle readéchoue.
  • printfsorties le temps correctement rembourré et -formatted
  • $[s=s>3598?0:s+1,s/60]l'expansion arithmétique calcule d' abord le temps mis à jour, vérifiant s'il faut envelopper et incrémenter autrement le compteur de secondes s, puis retourne la division au sol s/60.
  • $[s%60] donne le reste des secondes.
• Le script externe configure un trapgestionnaire pour TSTPle signal Ctrl-Zgénéré. Lorsque vous Ctrl-Zappuyez sur pendant l'exécution du script externe, il s'exécute fg>/dev/nullet remet le sous-shell au premier plan . >/dev/nullest nécessaire pour arrêter l' fgimpression de la commande subshell à chaque fois.
• Le script imprime l'initiale 00:00et envoie un STOPsignal au processus enfant$! , qui suspendra le processus.
• read attend la saisie pour toujours, gardant le script en vie.

Si Ctrl-Zest enfoncé pendant que le sous-shell est au premier plan, il suspendra l'exécution et remettra le script externe au premier plan, où il attendra en silence. Si le script externe est au premier plan, le gestionnaire d'interruption reprendra l'exécution du sous-shell, et il comptera à nouveau.

Javascript dans la console Chrome, 143 octets

f=document,m=s=g=i=0;setInterval(()=>{if(g%2){m=(i/60|0)%60;s=i++%60}f.write((m>9?m:'0'+m)+':'+(s>9?s:'0'+s));f.close();f.onclick=()=>g++},1e3)

Lorsqu'il est entré dans la console, il met le compteur à 00:00 et active ensuite la commande qui est en appuyant sur le document.

Pas beaucoup de magie en cours, notamment les (i/60)|0étages le nombre

Fait et testé dans la console Chrome

HTML + JavaScript (ES6), 191 192 187 183 174 174 octets

<b onclick='b=b?clearInterval(b):setInterval("a.innerHTML=`${(d=(((c=a.innerHTML.split`:`)[1]>58)+c[0])%60)>9?d:`0`+d}:${(e=++c[1]%60)>9?e:`0`+e}",1e3)'onload='b=0'id=a>00:00

Explication

Cliquez sur la minuterie pour démarrer ou mettre en pause le chronomètre. En tant que tel, un seul clic est la clé de contrôle . Le séparateur entre les deux valeurs est un deux-points.

Chaque fois que l'utilisateur clique sur le clic, la valeur de best vérifiée. Elle est initialisée à 0laquelle est évaluée false, de sorte qu'une chaîne de code est évaluée toutes les 1000 millisecondes. Cela définit la variable sur l'id de l'intervalle, afin qu'elle puisse être arrêtée plus tard. Si bcontient un nombre, il est évalué à true, donc l'intervalle est arrêté. Cela renvoie la valeur undefined, donc le cycle continue.

La chaîne de code change le html de l'élément avec id a(le chronomètre). D'abord, les minutes sont analysées en prenant la valeur du chronomètre précédente, en la divisant par les deux-points et en obtenant la valeur des minutes, qui est augmentée de 0 si la valeur des secondes n'est pas 59 (supérieure à 58), et 1 sinon, modulo 60 Ensuite, cette valeur est complétée. Viennent ensuite les deux points, et enfin les secondes. Le code obtient simplement l'ancienne valeur, l'augmente de 1, prend le modulo 60 et le remplit éventuellement.

C 309 179 octets

f(){m=0,s=0;A: while(getchar()^'\n'){if(s++==59){if(m++==59)m=0;s=0;}printf("\r%02d:%02d",m,s);sleep(1);system("clear");if(getchar()=='\n'){break;}}while(getchar()^'\n'){}goto A;}

Version non golfée:

void f()
{
   int m=0,s=0;

   A: while(getchar()^'\n')
      {           
       if(s++==59)
       {
         if(m++==59)
           m=0;

         s=0;
       }
       printf("\r%02d:%02d",m,s);
       sleep(1);  
       system("clear");

        if(getchar()=='\n')
        {
          break;
        }
      }

       while(getchar()^'\n')
       {}
       goto A ;
}

Utilisation: appuyez sur Enterpour mettre en pause et reprendre le chronomètre.

Explication:

• Attendez la Enterfrappe, breakla première whileboucle et attendez la prochaine Enter.
• À la Enterfrappe suivante , gotopremière whileboucle et reprendre le comptage.

Maintenant, je sais que gotoc'est une mauvaise pratique de codage en C, mais je ne pouvais pas trouver une autre façon.

Javascript, 124 octets

s=i=1,setInterval("s&&(d=document).close(d.write(`0${i/60%60|0}:`.slice(-3)+`0${i++%60}`.slice(-2))),d.onclick=_=>s=!s",1e3)

La «clé de contrôle» est un clic sur le document. Pour tester cela, collez le code dans la console ou dans un fichier html à l'intérieur de la <script>balise.

Explication:

let s = 1
let i = 1
setInterval(() => {
    //If s = true then check after the "&&" operator else false
    s && (d = document).close( //put the document variable inside the d variable, so now i don't need to use anymore the long word 'document, then i close the document
            d.write( //Write into the document the next string
                `0${i/60%60|0}:`.slice(-3) + `0${i++%60}`.slice(-2) //Here is the magic, here I update the 'i' variable and convert the 'i' value to minutes and seconds
            ) 
        ),
        d.onclick = _ => s = !s //Add onclick event to the document, if s = true then s = false, if s = false then s = true
}, 1e3) //1e3 = 1000

Testé dans Chrome

PHP, 94 91 octets

Je suppose que 32 est le code clé de la barre d'espace (ce qui n'est probablement pas le cas);
Je n'ai actuellement aucun moyen de tester ncurses. Mais le reste du code fonctionne bien.

for($s=[STDIN];;)echo date("\ri:s",$t+=$r^=stream_select($s,$n,$n,1)&&32==ncurses_getch());

commence à 00:00, mais augmente immédiatement à la fin de la pause

Si vous (comme moi) n'avez pas de ncurses, vous pouvez tester en remplaçant le deuxième dateparamètre par $t+=$r^=!rand(sleep(1),19);ou $t+=$r^=++$x%20<1+sleep(1);. ( sleeprevient toujours 0.)

panne

for($s=[STDIN];                     // set pointer for stream_select
    ;                               // infinite loop:
)
    echo date("\ri:s",                  // 5. print CR + time
        $t+=                            // 4. increment $t if watch is running
        $r^=                            // 3. then toggle pause
            stream_select($s,$n,$n,1)   // 1. wait 1 second for a keystroke
            &&32==ncurses_getch()       // 2. if keystroke, and key==space bar
    ;

C # 220 octets

using static System.Console;
using static System.DateTime;
class P
{
    static void Main()
    {
        var l = Now;
        var d = l-l;
        for( var r = 1<0;;Write($"\r{d:mm\\:ss}"))
        {
            if (KeyAvailable&&ReadKey(1<2).KeyChar == 's')
            {
                l = Now;
                r = !r;
            }
            if (r)
                d -= l - (l = Now);
        }

    }
}

Golfé

using static System.Console;using static System.DateTime;class P{static void Main(){var l=Now;var d=l-l;for(var r=1<0;;Write($"\r{d:mm\\:ss}")){(KeyAvailable&&ReadKey(1<2).KeyChar=='s'){l=Now;r=!r;}if(r)d-=l-(l=Now);}}}

Utilisation de la stouche pour démarrer / arrêter. Tout le programme fonctionne en se souvenant de TimeDelta en utilisantDateTime.Now

La plupart des C # -Magic proviennent de la fonctionnalité C # 7.0 using static.

Bash, 65 octets

trap d=\$[!d] 2;for((;;)){ printf "\r%(%M:%S)T" $[n+=d];sleep 1;}

Notez qu'il doit être écrit dans un script de fichier pour fonctionner correctement, sinon essayez:

bash -c 'trap d=\$[!d] 2;for((;;)){ printf "\r%(%M:%S)T" $[n+=d];sleep 1;}'

Version étendue pour l'expliquer:

trap d=\$[!d] 2                     # flip d for each INT (ctrl-c) signal.
for((n=0;;)){                       # repeat forever the code inside the {...}
                                    # The n=0 is not strictly needed.
    printf "\r%(%M:%S)T" "$[n+=d]"  # Print Minute:Second string calculated from 
                                    # the n value, increment by the value of d.
                                    # If IFS is not numeric (0-9), then, the
                                    # quotes around "$[n+=d]" could be removed.
    sleep 1                         # wait for 1 second.
}

Le %(...)Tformat à printf est valide en bash 5+.

C (gcc) , 121 115 octets

p,r;g(){r^=1;}main(t,b){for(b=time(signal(2,g));;r?p=t:(b+=t!=p))t=time(0)-b,printf("\r%02d:%02d  ",t/60%60,t%60);}

Essayez-le en ligne!

Définit un gestionnaire de signal pour SIGINT, qui est déclenché en appuyant sur Ctrl-C. Nous conservons un décalage horaire bet affichons le temps de l'horloge murale moins le décalage horaire. Si nous sommes en pause, incrémentez la base de temps à chaque fois que l'horloge murale coche pour figer l'heure affichée.

Merci à @ceilingcat d'avoir rasé 6 octets!

Date Zsh + Gnu, 242 octets

Avec 1 / 100e de seconde! Il nécessite un terminal interactif, mais voici quand même un lien TIO .
Appuyez sur Enterpour démarrer / arrêter le chronomètre; Ctrl-Cpour quitter.

u(){p=`gdate +%s`;q=`gdate +%N`;}
f(){read -t0.01&&{read;break};unset REPLY}
g(){while :;{u;t=$[p-a];s=$[t%60];m=$[(t%3600-s)/60]
echo "\r`printf %02d:%02d $m $s`.$q[1,2]\c";f;}}
<<<ready;read;u;a=$p
while :;{f;echo "\r\e[2A\c";u;a=$[p-t];g;}

Commentaires (un peu dépassés):

u()echo $[`gdate +%s%N`/1000]       # fn:unix timestamp extended to µs
v()gdate +%s                        # fn:unix time, in s
f(){read -t0.01 -r&&{read -r;break;} # fn:listens for "Enter"
                      ;unset REPLY;}

g(){while :;                        # fn:rolling stopwatch
    {q=`u`;t=$[`v`-a]               #    t=time diff from baseline (s)
    ;echo "\r`printf %02d:%02d      #    format output
    $[(t%3600-s)/60] $s`            #    minutes:seconds
    .${q:10:2}\c";                  #    .xx = partial seconds
    f;}}                            #    listen for "Enter"

                                    # Execution starts here!
<<<ready;read;u;a=$p                # Wait for "Enter"; get baseline $a

while :;{                           # Main program loop
         f;                         # listen for an "Enter"
           echo "\r\e[2A\c"         # go up 1 line of the console
a=$[`v`-t]                          # reset the baseline
                ;g;}                # begin the stopwatch

Commodore BASIC (C64 / TheC64 Mini, VIC-20, PET, C16 / + 4) - 147 octets tokenisés et BASIC

 0?"{clear}":geta$:ifa$<>" "thengoto
 1ti$="000000"
 2fori=.to1:?"{home}"mid$(ti$,3,2)":"mid$(ti$,5,2):geta$:b$=ti$:i=-(a$=" "):nE:pO198,.
 3geta$:ifa$<>" "then3
 4ti$=b$:goto2

{clear}dans la liste est SHIFT+CLR/HOMEqui sort comme un seul caractère PETSCII lorsque vous suivez un guillemet d'ouverture, tandis que {home}la CLR/HOMEclé sans le décalage est dans la même condition que de suivre un guillemet d'ouverture.

Utilisez la barre d'espace comme touche de contrôle.

Pour travailler avec le Commodore 128 dans BASIC 7, modifiez la liste dans les lignes suivantes:

 0?"{clear}":geta$:ifa$<>" "thengoto0
 2fori=.to1:?"{home}"mid$(ti$,3,2)":"mid$(ti$,5,2):geta$:b$=ti$:i=-(a$=" "):nE:poK198,.

Ajoute sept jetons supplémentaires au nombre (comme tous les nombres sont stockés dans BASIC sous forme de 7 octets, il en goto10est de même de 8 octets à jeton alors qu'il goton'y en a qu'un)).