Visualizza un orologio digitale

(Vedo che ci sono molte sfide dell'orologio, ho provato a leggerle tutte, sono abbastanza sicuro che sia unico)

Scrivere del codice che aggiorna continuamente un orologio digitale visualizzato nel formato h:m:sin cui h, me spuò occupare 1 o 2 caratteri ciascuno. Le restrizioni in termini semplici, come afferma @BlueEyedBeast, in pratica voglio che sostituisca il tempo mostrato.

• Newline non sono ammessi
• Sono consentiti spazi finali
• Altri caratteri finali non sono ammessi
• Nessun secondo da perdere (57 -> 59 non è consentito)
• I numeri che iniziano con "0" sono consentiti, purché non occupino più di 2 caratteri
• Il codice non deve accettare alcun input
• Se la tua lingua non è in grado di ottenere l'ora corrente senza input, è possibile utilizzare per input fino a 8 byte in modo standard consentito
• L'output deve essere su stdout
• Questo è codegolf, quindi vince la risposta più breve!

Esempio

Sto lavorando su una lingua chiamata *> <> (stella marina) perché programmi come questo non sono possibili in> <> (attendi solo l'I / O dei file). Ecco un programma di orologio digitale funzionante (non salvato). Questo programma è scritto in *> <> :

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

^{Nota: tutto è identico a> <> in questo tranne, s = secondo, m = minuto, h = ora, S = sonno (100 ms * x)}

Questo produce:

14:44:31

Aggiornamento ogni 100 ms fino al termine.

Esempi non consentiti

Non sono ammessi:

1:

14:44:3114:44:32

2:

14:44:31 14:44:32

3:

14:44:31
14:44:32

Il tempo deve rimanere sulla prima riga in cui è stato emesso senza caratteri finali visibili. Cancellare il terminale, tuttavia, sarebbe consentito in quanto non avrebbe ancora caratteri finali.

Pyke, 6 byte

Ctr\ J

Provalo qui!

Penso che questo sia valido Sostituisci il carattere spazio con il ritorno a capo per un output valido (non funziona in linea)

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

Testato in Chrome.

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

<a id=a>

-1 byte (@ETHProductions): utilizzare il formato ora francese anziché .toTimeString().slice(0,8)

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

Questo funzionerà in FireFox.

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

<a id=a>

-3 byte (@ETHProductions): utilizzare il formato ora francese anziché .toTimeString().slice(0,8)

Python 2, 50 byte

(Python 2.1+ per ctimesenza argomenti)

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

time.ctime()produce una stringa formattata, dalla quale può essere suddiviso hh: mm: ss [11:19](rimane nella stessa posizione qualunque sia la data e l'ora).

printing il ritorno a '\r'capo prima del testo e rendendo il testo il primo elemento di una tupla ,sopprime efficacemente il trailing implicito '\n'e sovrascrive l'output precedentemente scritto.

while 1 loop per sempre.

Mathematica, 48 41 37 28 byte

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

L'output sarà a TimeObject, aggiornando continuamente.

Somiglia a questo:

Versioni alternative

48 byte:

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

53 byte:

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

Vedo che è stato rimosso il requisito per un input UI senza segnale per arrestare il programma. Quindi ora possiamo fare:

Bash + coreutils, 28

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

yes emette continuamente la stringa "now", una volta per riga, in una pipe.

date -f-read interpreta ogni "ora" come l'ora corrente, quindi emette nel formato richiesto. La stringa di formato include la sequenza di escape ANSI per cancellare lo schermo. date fa uscita una nuova riga dopo la data - io non sono sicuro se questo squalifica, dal momento che lo schermo si oscura ogni volta in ogni caso.

Se viene squalificato, possiamo trinvece utilizzare :

Bash + coreutils, 31

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

Risposte precedenti:

Bash + X, 32

xclock -d -update 1 -strftime %T

Purtroppo questo può essere aggiornato solo ogni secondo. Se questo squalifica, allora possiamo farlo invece:

Bash + coreutils, 43

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

QBIC , 6 byte

{_C?_d

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

Cancella costantemente lo schermo e stampa l'ora del sistema nel formato 22:03:41.

Clojure, 150 136 141 byte

V3: 141 byte :(

+5 byte per correggere un bug. Poiché i tempi non sono a zero, l'orologio può "restringersi" ed espandersi quando il tempo cambia. Stava "sbavando" quando si restrinse perché l'ultima cifra non veniva più cancellata. Risolto il problema aggiungendo alcuni spazi alla fine per garantire che tutto venisse sovrascritto.

#(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 byte

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

-14 byte passando a usando SimpleDateFormatper formattare la data. Ancora enorme.

V1: 150 byte

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

Mi sono reso conto che probabilmente sto usando il modo peggiore possibile per ottenere la data. Sicuramente margini di miglioramento qui.

Ungolfed:

(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))))

Bash + watch, 19 byte

watch non fa parte di coreutils , ma è disponibile immediatamente su ogni distribuzione Linux.

golfed

watch -tn1 date +%T

Provalo online!

WinDbg, 73 byte

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

Aggiorna continuamente una riga con l'ora corrente fino a quando l'utente preme Ctrl + Break.

Come funziona:

.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

Esempio di output (beh, hai capito):

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 byte

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

La datefunzione stampa tutto alla lettera che non riconosce.

\r è il ritorno a capo, imposta il cursore sulla prima colonna.

Corri con -r.

MATL , 11 byte

`XxZ'13XODT

Ciclo infinito che cancella lo schermo e stampa l'ora nel formato specificato.

Puoi provarlo su MATL Online! . Questo compilatore è sperimentale; se non funziona aggiorna la pagina e premi di nuovo "Esegui".

C #, 82 byte

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

Metodo anonimo che sovrascrive costantemente 8 caratteri con un nuovo output. Può essere ridotto di 1 byte se si modifica per accettare un parametro fittizio (z=>... ).

Programma completo:

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 byte

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

Funziona sovrascrivendo la stessa linea all'interno di un ciclo infinito

SmileBASIC 3.3.2, 38 byte

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

UTF-16 fa schifo :(

Ad ogni modo, questo stampa ripetutamente l'ora locale in HH: MM: SS con uno spazio dopo di essa, senza righe di ritorno in seguito. Non si aggiorna ogni secondo, ma stampa ripetutamente per sempre.

C, 134 116 89 80 76 75 73 byte

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 byte

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

Perché non mi piace usare cls in Powershell. Dal post di Briantist @ /codegolf//a/102450/63383

Pascal, 61 byte

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

Free Pascal ha delle belle routine temporali nell'unità SysUtils. Ungolfed:

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

C 65 (prev 64) byte

Garantito per funzionare su macchine Linux. :)

@Marco Grazie!

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

Vim, 26 byte

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

Questo crea una macro ricorsiva (ad esempio un ciclo eterno) che cancella tutto il testo sulla riga corrente e lo sostituisce con l'ora corrente.

Pyth - 28 byte

Un po 'longevo, perché Pyth non ha tempo di ristoro.

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

Groovy, 45 caratteri

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

Gelatina , 8 byte

13Ọ7ŒTȮß

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

Provalo online!

Il ritorno a capo non funziona online e non riesco a far funzionare l'interprete, quindi è un po 'non testato, ma funziona come previsto quando uso caratteri stampabili al posto del CR.

ForceLang, 123 byte

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.toTimeStringè supportato nell'implementazione di riferimento da Java DateFormat.getTimeInstance(), che dipende dalle impostazioni locali, quindi è possibile impostare le impostazioni internazionali di sistema predefinite su uno che utilizza 24 ore.

PowerShell, 30 28 24 20 byte

Modificato la regione del mio computer in Germania sulla base del commento di raznagul per salvare 4 byte. :)

for(){date -F T;cls}

Versione precedente che funziona in tutte le versioni locali.

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

tcl, 69 byte

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

Provalo qui!

Lotto, 36 byte

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

Dove ␈rappresenta il carattere ASCII BS (codice 8).

Racchetta, 71 byte

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

Dove ↵è effettivamente un CR (esadecimale 0d). Dump esadecimale del programma per ulteriori chiarimenti (avviso byte nella posizione esadecimale 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

Utilizza SRFI / 19 incluso con la distribuzione Racket. (current-date)ottiene la data e l'ora locali correnti. Il date->stringformato ~3è formato ISO-8601 ora-minuto-secondo. (let l () ... (l))in un ciclo infinito idiomatico. (require srfi/19)carica il srfi/19modulo.

C, 156 byte

#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 byte

(In TI-BASIC, molti caratteri sono token a 2 byte e i due punti all'inizio di una riga sono 0 byte extra)

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

R, 41 byte

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

Ha uno spazio finale (poiché catil separatore predefinito è uno spazio).
A causa della frequenza di aggiornamento della GUI R, l'esecuzione di questa nella GUI occasionalmente salterà alcuni secondi, ma se lo si salva in un file e lo si esegue sulla riga di comando, verrà visualizzato correttamente ogni singolo secondo.
Funzionerà per sempre fino a quando l'utente non lo interromperà.