Afficher une horloge numérique

(Je vois qu'il y a beaucoup de défis d'horloge, j'ai essayé de tous les lire, je suis sûr que c'est unique)

Ecrire un code qui met à jour en permanence une horloge numérique affichée dans le format h:m:soù h, met speut occuper 1 ou 2 caractères chacun. Les restrictions en termes simples comme le dit @BlueEyedBeast, je veux essentiellement qu'il remplace l'heure indiquée.

• Les retours à la ligne ne sont pas autorisés
• Les espaces de fin sont autorisés
• Les autres caractères de fin ne sont pas autorisés
• Aucune seconde ne doit être manquée (57 -> 59 n'est pas autorisé)
• Les nombres commençant par "0" sont autorisés, tant qu'ils n'occupent pas plus de 2 caractères
• Le code ne doit accepter aucune entrée
• Si votre langue ne peut pas obtenir l'heure actuelle sans entrée, vous pouvez utiliser pour l'entrée jusqu'à 8 octets de manière standard autorisée
• La sortie doit être vers stdout
• Il s'agit de codegolf, donc la réponse la plus courte l'emporte!

Exemple

Je travaille sur un langage nommé *> <> (étoile de mer) parce que des programmes comme celui-ci ne sont pas possibles dans> <> (attendez simplement le fichier i / o). Voici un programme d'horloge numérique qui fonctionne (non golfé). Ce programme est écrit en *> <> :

s":"m":"hnonon"   "ooo88888888888ooooooooooo1S

^{Remarque: Tout est identique à> <> dans ce cas, sauf, s = seconde, m = minute, h = heure, S = sommeil (100 ms * x)}

Cela produit:

14:44:31

Mise à jour toutes les 100 ms jusqu'à la fin.

Exemples non autorisés

Les éléments suivants ne sont pas autorisés:

1:

14:44:3114:44:32

2:

14:44:31 14:44:32

3:

14:44:31
14:44:32

Le temps doit rester sur la première ligne de sortie sans caractères de fin visibles. Cependant, effacer le terminal serait autorisé car il n'aurait toujours pas de caractères de fin.

Pyke, 6 octets

Ctr\ J

Essayez-le ici!

Je pense que c'est valable. Remplacez le caractère espace par un retour chariot pour une sortie valide (ne fonctionne pas en ligne)

HTML + JS (ES6), 8 + 60 = 68 octets

Testé dans Chrome.

setInterval`a.innerHTML=new Date().toLocaleTimeString('fr')`

<a id=a>

-1 octet (@ETHProductions): utilisez le format d'heure français au lieu de .toTimeString().slice(0,8)

HTML + JS (ES6), 8 + 62 = 70 octets

Cela fonctionnera dans FireFox.

setInterval('a.innerHTML=new Date().toLocaleTimeString`fr`',0)

<a id=a>

-3 octets (@ETHProductions): utilisez le format d'heure français au lieu de .toTimeString().slice(0,8)

Python 2, 50 octets

(Python 2.1+ pour ctimesans argument)

import time
while 1:print'\r'+time.ctime()[11:19],

time.ctime()renvoie une chaîne formatée, à partir de laquelle le hh: mm: ss peut être découpé en utilisant [11:19](il reste au même emplacement quelles que soient la date et l'heure).

printle retour chariot '\r'avant le texte et faire du texte le premier élément d'un tuple ,supprime efficacement la fin implicite '\n'et écrase la sortie précédemment écrite.

while 1 boucles pour toujours.

Mathematica, 48 41 37 28 octets

Do[s=Now[[2]],∞]~Monitor~s

La sortie sera un TimeObject, rafraîchissant en continu.

Ressemble à ça:

Versions alternatives

48 octets:

Dynamic@Refresh[TimeObject[],UpdateInterval->.1]

53 octets:

Dynamic@Refresh[DateString@"Time",UpdateInterval->.1]

Je constate que l'exigence d'une entrée d'interface utilisateur sans signal pour arrêter le programme a été supprimée. Alors maintenant, nous pouvons faire:

Bash + coreutils, 28

yes now|date -f- +$'\e[2J'%T

yes émet en continu la chaîne "maintenant", une fois par ligne, dans un tuyau.

date -f-reads interprète chaque "maintenant" comme l'heure actuelle, puis sort au format requis. La chaîne de format comprend la séquence d'échappement ANSI pour effacer l'écran. date fait sortir un saut de ligne après la date - je ne sais pas si ce disqualifie, puisque l'écran est effacé à chaque fois que de toute façon.

S'il est disqualifié, nous pouvons utiliser à la trplace:

Bash + coreutils, 31

yes now|date -f- +%T|tr \\n \\r

Réponses précédentes:

Bash + X, 32

xclock -d -update 1 -strftime %T

Malheureusement, cela ne peut être mis à jour qu'à chaque seconde. Si cela disqualifie, alors nous pouvons le faire à la place:

Bash + coreutils, 43

until read -t0
do printf `date +%T`\\r
done

QBIC , 6 octets

{_C?_d

{      Starts a DO-loop
 _C    CLS
   ?   PRINT
    _d TIME$

Efface constamment l'écran et imprime l'heure système au format 22:03:41.

Clojure, 150 136 141 octets

V3: 141 octets :(

+5 octets pour corriger un bug. Étant donné que les heures ne sont pas remplies de zéro, l'horloge peut "rétrécir" et s'étendre lorsque l'heure change. Il "maculait" quand il rétrécissait parce que le dernier chiffre n'était plus effacé. Corrigé en ajoutant des espaces à la fin pour s'assurer que tout était écrasé.

#(while true(flush)(print(str(apply str(repeat 9"\b"))(.format(java.text.SimpleDateFormat."H:m:s")(java.util.Date.))"   "))(Thread/sleep 99))

V2: 136 octets

#(while true(flush)(print(str(apply str(repeat 9"\b"))(.format(java.text.SimpleDateFormat."H:m:s")(java.util.Date.))))(Thread/sleep 99))

-14 octets en passant à l'aide de SimpleDateFormatpour formater la date. Toujours énorme.

V1: 150 octets

#(while true(let[d(java.util.Date.)](flush)(print(str(apply str(repeat 9 "\b"))(.getHours d)":"(.getMinutes d)":"(.getSeconds d)))(Thread/sleep 100)))

J'ai réalisé que j'utilisais probablement le pire moyen possible pour obtenir la date. Certainement matière à amélioration ici.

Non golfé:

(defn -main []
  (while true
    (let [d (java.util.Date.)]
      (flush)
      (print
        (str
          (apply str (repeat 9 "\b"))
          (.getHours d)":"(.getMinutes d)":"(.getSeconds d)))
      (Thread/sleep 100))))

Montre Bash +, 19 octets

watch ne fait pas partie de coreutils , mais est disponible immédiatement sur pratiquement toutes les distributions Linux.

Golfé

watch -tn1 date +%T

Essayez-le en ligne!

WinDbg, 73 octets

.do{r$t0=0;.foreach(p {.echotime}){r$t0=@$t0+1;j8==@$t0'.printf"p \r"'}}1

Il met continuellement à jour une ligne avec l'heure actuelle jusqu'à ce que l'utilisateur appuie sur Ctrl + Break.

Comment ça fonctionne:

.do                          * Start do-while loop
{
    r$t0 = 0;                * Set $t0 = 0
    .foreach(p {.echotime})  * Foreach space-delimited word in a sentence like "Debugger (not 
    {                        * debuggee) time: Mon Dec  5 14:08:10.138 2016 (UTC - 8:00)"
        r$t0 = @$t0+1;       * Increment $t0
        j 8==@$t0            * If $t0 is 8 (ie- p is the current time)
        '
            .printf"p \r"    * Print p (current time) and \r so the next print overwrites
        '
    }
} 1                          * Do-while condition: 1, loop forever

Exemple de sortie (enfin, vous avez l'idée):

0:000> .do{r$t0=0;.foreach(p {.echotime}){r$t0=@$t0+1;j8==@$t0'.printf"p \r"'}}1
14:10:12.329

PHP, 28 octets

for(;;)echo date("\rH:i:s");

La datefonction imprime tout ce qu’elle ne reconnaît pas.

\r est le retour chariot, positionne le curseur sur la première colonne.

Courez avec -r.

MATL , 11 octets

`XxZ'13XODT

Boucle infinie qui efface l'écran et imprime l'heure au format spécifié.

Vous pouvez l'essayer sur MATL Online! . Ce compilateur est expérimental; si cela ne fonctionne pas, actualisez la page et appuyez à nouveau sur "Exécuter".

C #, 82 octets

()=>{for(;;)Console.Write(new string('\b',8)+DateTime.Now.ToString("HH:mm:ss"));};

Méthode anonyme qui écrase constamment 8 caractères avec une nouvelle sortie. Peut être raccourci d'un octet en cas de modification pour accepter un paramètre fictif ( z=>...).

Programme complet:

using System;

public class Program
{
    public static void Main()
    {
        Action a =
        () =>
        {
            for (;;)
                Console.Write(new string('\b', 8) + DateTime.Now.ToString("HH:mm:ss"));
        };

        a();
    }
}

C #, 65 octets

()=>{for(;;)Console.Write("\r"+DateTime.Now.ToLongTimeString());};

Fonctionne en écrasant la même ligne dans une boucle sans fin

SmileBASIC 3.3.2, 38 octets

@L?TIME$;" ";
GOTO@L

L'UTF-16 craint :(

Quoi qu'il en soit, cela imprime à plusieurs reprises l'heure locale en HH: MM: SS avec un espace après, pas de nouvelle ligne par la suite. Cependant, il ne se met pas à jour à chaque seconde, il s'imprime à plusieurs reprises pour toujours.

C, 134 116 89 80 76 75 73 octets

main(n){for(;time(&n);)printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

---- Old versions:
main(n){for(;;)n=time(0),printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

n;main(){for(;;)n=time(0),printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

---- 

n;main(){for(;;)n=time(0),printf("\r%02d:%02d:%02d",n/3600%24,n/60%60,n%60);}

----

Saved 9 more bytes thanks to @nmjcman101 again:
n;main(){for(;;)n=time(0),printf("\r%02d:%02d:%02d",(n/3600)%24,(n/60)%60,n%60);}

----

Saved 27 bytes thanks to @nmjcman101
n,b[9];main(){for(;;){n=time(0);strftime(b,9,"%H:%M:%S",localtime(&n));printf("\r%s",b);}}

----

I figured out I don't need to put `#include<stdio.h>` into the file :)
#include<time.h>
main(){for(;;){time_t n=time(0);char b[9];strftime(b,9,"%H:%M:%S",localtime(&n));printf("\r%s",b);}}

----

#include<time.h>
#include<stdio.h>
main(){for(;;){time_t n=time(0);char b[9];strftime(b,9,"%H:%M:%S",localtime(&n));printf("\r%s",b);}}

Powershell, 39 octets

for(){write-host -n(date -F h:m:s`0`r)}

Parce que je n'aime pas utiliser cls dans Powershell. De la publication du briantist @ /codegolf//a/102450/63383

Pascal, 61 octets

uses sysutils;begin while 1=1do write(#13,timetostr(now))end.

Pascal gratuit a de belles routines de temps dans l'unité SysUtils. Non golfé:

uses
  sysutils;
begin
  while 1=1 do
    write(#13, timetostr(now));
end.

C 65 (64 précédents) octets

Garanti pour fonctionner sur une machine Linux. :)

@Marco Merci!

f(){while(1){system("date +%T");usleep(100000);system("clear");}}

Vim, 26 octets

qqS<C-r>=strftime("%T")<CR><esc>@qq@q

Cela crée une macro récursive (par exemple une boucle éternelle) qui supprime tout le texte sur la ligne actuelle et le remplace par l'heure actuelle.

Pyth - 28 octets

Un peu long, car pyth n'a pas de strftime.

#p+"\r"j\:m.[`02`dP>4.d2.d.1

Groovy, 45 caractères

for(;;)print(new Date().format("\rHH:mm:ss"))

Gelée , 8 octets

13Ọ7ŒTȮß

13Ọ        chr(13), carriage return
   7ŒT     time string, which extends the previous character
      Ȯ    print
       ß   call the whole link again

Essayez-le en ligne!

Le retour chariot ne fonctionne pas en ligne, et je ne peux pas faire fonctionner l'interpréteur, donc il n'a pas été testé, mais il fonctionne comme prévu lorsque j'utilise des caractères imprimables à la place du CR.

ForceLang, 123 octets

def s set
s d datetime
s z string.char 8
s z z.repeat 16
label 1
io.write z
io.write d.toTimeString d.now()
d.wait 9
goto 1

datetime.toTimeStringest soutenu dans l'implémentation de référence par Java DateFormat.getTimeInstance(), qui dépend des paramètres régionaux, de sorte que vous pouvez définir les paramètres régionaux par défaut de votre système sur ceux qui utilisent 24 heures.

PowerShell, 30 28 24 20 octets

Changé la région de mon ordinateur en Allemagne sur la base du commentaire de raznagul pour économiser 4 octets. :)

for(){date -F T;cls}

Version précédente qui fonctionne dans tous les environnements locaux.

for(){date -F h:m:s;cls}

tcl, 69 octets

while 1 {puts -nonewline \r[clock format [clock seconds] -format %T]}

Essayez-le ici!

Lot, 36 octets

@set/p.=␈␈␈␈␈␈␈␈%time:~0,8%<nul
@%0

Où ␈représente le caractère ASCII BS (code 8).

Raquette, 71 octets

(require srfi/19)(let l()(display(date->string(current-date)"↵~3"))(l))

Où le ↵est en fait un CR (hex 0d). Vidage hexadécimal du programme pour plus de précision (octet de notification à la position hex 4d):

00000000  28 72 65 71 75 69 72 65  20 73 72 66 69 2f 31 39  |(require srfi/19|
00000010  29 28 6c 65 74 20 6c 28  29 28 64 69 73 70 6c 61  |)(let l()(displa|
00000020  79 28 64 61 74 65 2d 3e  73 74 72 69 6e 67 28 63  |y(date->string(c|
00000030  75 72 72 65 6e 74 2d 64  61 74 65 29 22 0d 7e 33  |urrent-date)".~3|
00000040  22 29 29 28 6c 29 29                              |"))(l))|
00000047

Utilise SRFI / 19 inclus avec la distribution Racket. (current-date)obtient la date et l'heure locales actuelles. Le date->stringformat ~3est le format ISO-8601 heure-minute-seconde. (let l () ... (l))dans une boucle infinie idiomatique. (require srfi/19)charge le srfi/19module.

C, 156 octets

#include<stdio.h>
#include<time.h>
int main(){time_t a;struct tm *b;char c[9];for(;;){time(&a);b=localtime(&a);strftime(c,9,"%H:%M:%S",b);printf("%s\r",c);}}

TI-Basic, 40 octets

(Dans TI-BASIC, de nombreux caractères sont des jetons de 2 octets et les deux-points au début d'une ligne sont de 0 octet supplémentaire)

:ClrHome
:Output(1,6,":
:setTmFmt(24
:While 1
:Output(1,1,getTmSrr(0
:getTime
:Output(1,7,Ans(3
:End

R, 41 octets

repeat{cat(format(Sys.time(),"%T"),"\r")}

A un espace de fin (car catle séparateur par défaut est un espace).
En raison du taux de rafraîchissement de l'interface graphique R, son exécution dans l'interface graphique sautera parfois quelques secondes, mais si vous l'enregistrez dans un fichier et l'exécutez sur la ligne de commande, il s'affichera correctement toutes les secondes.
S'exécutera indéfiniment jusqu'à interruption de l'utilisateur.