Mostrar un reloj digital

(Veo que hay muchos desafíos de reloj, he intentado leerlos todos, estoy bastante seguro de que esto es único)

Escribir un código que actualiza continuamente un reloj digital mostrado en el formato h:m:sen que h, my spuede ocupar 1 o 2 caracteres cada una. Las restricciones en términos simples como @BlueEyedBeast lo expresaron, básicamente quiero que reemplace el tiempo que se muestra.

• No se permiten líneas nuevas.
• Se permiten espacios finales
• No se permiten otros caracteres finales
• No se deben perder segundos (57 -> 59 no está permitido)
• Los números que comienzan con "0" están permitidos, siempre que no ocupen más de 2 caracteres.
• El código no debe aceptar ninguna entrada.
• Si su idioma no puede obtener la hora actual sin entrada, puede usarla para ingresar hasta 8 bytes de una manera permitida de manera estándar
• La salida debe ser stdout
• ¡Esto es codegolf, por lo que gana la respuesta más corta!

Ejemplo

Estoy trabajando en un idioma llamado *> <> (estrella de mar) porque programas como este no son posibles en> <> (solo espera el archivo de E / S). Aquí hay un programa de reloj digital que funciona (sin golf). Este programa está escrito en *> <> :

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

^{Nota: Todo es idéntico a> <> en esto excepto, s = segundo, m = minuto, h = hora, S = dormir (100ms * x)}

Esto produce:

14:44:31

Actualización cada 100 ms hasta que finalice.

Ejemplos no permitidos

Lo siguiente no está permitido:

1:

14:44:3114:44:32

2:

14:44:31 14:44:32

3:

14:44:31
14:44:32

El tiempo debe permanecer en la primera línea que se emitió sin caracteres finales visibles. Sin embargo, se permitiría borrar la terminal, ya que todavía no tendría caracteres finales.

Pyke, 6 bytes

Ctr\ J

Pruébalo aquí!

Creo que esto es valido. Reemplace el carácter de espacio con retorno de carro para salida válida (no funciona en línea)

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

Probado en cromo.

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

<a id=a>

-1 byte (@ETHProductions): utilice el formato de hora francés en lugar de .toTimeString().slice(0,8)

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

Esto funcionará en Firefox.

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

<a id=a>

-3 bytes (@ETHProductions): utilice el formato de hora francés en lugar de .toTimeString().slice(0,8)

Python 2, 50 bytes

(Python 2.1+ para ctimesin argumento)

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

time.ctime()produce una cadena formateada, a partir de la cual hh: mm: ss se puede dividir usando [11:19](permanece en la misma ubicación, independientemente de la fecha y la hora).

printAl devolver el carro '\r'antes del texto y hacer que el texto sea el primer elemento de una tupla, ,suprime efectivamente el final implícito '\n'y sobrescribe la salida escrita anteriormente.

while 1 bucles para siempre.

Mathematica, 48 41 37 28 bytes

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

La salida será una TimeObject, refrescante continuamente.

Se ve como esto:

Versiones alternativas

48 bytes:

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

53 bytes:

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

Veo que se ha eliminado el requisito de una entrada de IU sin señal para detener el programa. Entonces ahora podemos hacer:

Bash + coreutils, 28

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

yes emite continuamente la cadena "ahora", una vez por línea, en una tubería.

date -f-lee interpreta cada "ahora" como la hora actual, luego emite en el formato requerido. La cadena de formato incluye la secuencia de escape ANSI para borrar la pantalla. date hace emitir una nueva línea después de la fecha - No estoy seguro de si esto descalifica, ya que la pantalla se borra cada vez que de todos modos.

Si descalifica, podemos usar tren su lugar:

Bash + coreutils, 31

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

Respuestas anteriores:

Golpe + X, 32

xclock -d -update 1 -strftime %T

Lamentablemente, esto solo puede actualizarse cada segundo. Si eso descalifica, entonces podemos hacer esto en su lugar:

Bash + coreutils, 43

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

QBIC , 6 bytes

{_C?_d

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

Borra constantemente la pantalla e imprime la hora del sistema en el formato 22:03:41.

Clojure, 150 136 141 bytes

V3: 141 bytes :(

+5 bytes para corregir un error. Dado que los tiempos no están rellenados con ceros, el reloj puede "encogerse" y expandirse cuando cambia la hora. Estaba "manchado" cuando se redujo porque ya no se borraba el último dígito. Se solucionó agregando algunos espacios al final para garantizar que todo se sobrescribiera.

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

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

-14 bytes cambiando a usar SimpleDateFormatpara formatear la fecha. Sigue siendo enorme.

V1: 150 bytes

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

Me di cuenta de que probablemente estoy usando la peor forma posible para obtener la fecha. Definitivamente hay margen de mejora aquí.

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

Bash + reloj, 19 bytes

watch no es parte de coreutils , pero está disponible en casi todas las distribuciones de Linux.

Golfed

watch -tn1 date +%T

Pruébalo en línea!

WinDbg, 73 bytes

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

Actualiza continuamente una línea con la hora actual hasta que el usuario presiona Ctrl + Break.

Cómo funciona:

.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

Salida de muestra (bueno, ya tienes la idea):

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 bytes

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

La datefunción imprime todo literalmente que no reconoce.

\r es el retorno de carro, establece el cursor en la primera columna.

Corre con -r.

MATL , 11 bytes

`XxZ'13XODT

Bucle infinito que borra la pantalla e imprime la hora en el formato especificado.

¡Puedes probarlo en MATL Online! . Este compilador es experimental; si no funciona, actualice la página y presione "Ejecutar" nuevamente.

C #, 82 bytes

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

Método anónimo que sobrescribe constantemente 8 caracteres con nueva salida. Se puede acortar 1 byte si se modifica para aceptar un parámetro ficticio ( z=>...).

Programa 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 bytes

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

Funciona sobrescribiendo la misma línea dentro de un bucle sin fin

SmileBASIC 3.3.2, 38 bytes

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

UTF-16 apesta :(

De todos modos, esto imprime repetidamente la hora local en HH: MM: SS con un espacio después, sin nueva línea después. Sin embargo, no se actualiza cada segundo, solo se imprime repetidamente para siempre.

C, 134 116 89 80 76 75 73 bytes

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 bytes

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

Porque no me gusta usar cls en Powershell. De la publicación de briantist @ /codegolf//a/102450/63383

Pascal, 61 bytes

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

Pascal gratis tiene buenas rutinas de tiempo en la unidad SysUtils. Sin golf:

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

C 65 (anterior 64) bytes

Garantizado para trabajar en máquinas Linux. :)

@Marco ¡Gracias!

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

Vim, 26 bytes

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

Esto crea una macro recursiva (por ejemplo, un bucle eterno) que elimina todo el texto en la línea actual y lo reemplaza con la hora actual.

Pyth - 28 bytes

Un poco largo, porque pyth no tiene strftime.

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

Groovy, 45 personajes

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

Jalea , 8 bytes

13Ọ7ŒTȮß

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

Pruébalo en línea!

El retorno de carro no funciona en línea, y no puedo hacer que el intérprete funcione, por lo que no se ha probado, pero funciona como se esperaba cuando uso caracteres imprimibles en lugar del CR.

ForceLang, 123 bytes

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á respaldado en la implementación de referencia por Java DateFormat.getTimeInstance(), que depende de la configuración regional, por lo que puede establecer la configuración regional predeterminada del sistema en una que utilice 24 horas.

PowerShell, 30 28 24 20 bytes

Cambié la región de mi computadora a Alemania en base al comentario de raznagul para ahorrar 4 bytes. :)

for(){date -F T;cls}

Versión anterior que funciona en todas las configuraciones regionales.

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

tcl, 69 bytes

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

Pruébalo aquí!

Lote, 36 bytes

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

Donde ␈representa el carácter ASCII BS (código 8).

Raqueta, 71 bytes

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

Donde el ↵es en realidad un CR (hex 0d). Volcado hexadecimal del programa para mayor aclaración (byte de aviso en la posición 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

Utiliza SRFI / 19 incluido con la distribución Racket. (current-date)Obtiene la fecha y hora local actual. El date->stringformato ~3es el formato ISO-8601 hora-minuto-segundo. (let l () ... (l))en un bucle infinito idiomático. (require srfi/19)carga el srfi/19módulo

C, 156 bytes

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

(En TI-BASIC, muchos caracteres son tokens de 2 bytes, y los dos puntos al comienzo de una línea tienen 0 bytes adicionales)

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

R, 41 bytes

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

Tiene un espacio final (debido a que catel separador predeterminado es un espacio).
Debido a la frecuencia de actualización de la R GUI, ejecutar esto en la GUI ocasionalmente omitirá algunos segundos, pero si lo guarda en un archivo y lo ejecuta en la línea de comando, se mostrará correctamente cada segundo.
Se ejecutará para siempre hasta que el usuario interrumpa.