Exibir um relógio digital

(Vejo que há muitos desafios no relógio, tentei ler todos, tenho certeza de que isso é único)

Escrever algum código que atualiza continuamente um relógio digital exibida no formato de h:m:sonde h, me spode ocupar 1 ou 2 caracteres cada. As restrições em termos simples, como @BlueEyedBeast, colocam, basicamente, que substitua o tempo mostrado.

• Novas linhas não são permitidas
• Espaços à direita são permitidos
• Outros caracteres finais não são permitidos
• Não se deve perder segundos (57 -> 59 não é permitido)
• Números começando com "0" são permitidos, desde que não ocupem mais de 2 caracteres
• O código não deve aceitar nenhuma entrada
• Se o seu idioma não puder obter o horário atual sem entrada, você poderá usá-lo para inserir até 8 bytes de uma maneira permitida de maneira padrão.
• A saída deve ser para stdout
• Este é um codegolf, então a resposta mais curta vence!

Exemplo

Estou trabalhando em um idioma chamado *> <> (estrela do mar) porque programas como esse não são possíveis em> <> (apenas aguarde o arquivo de E / S). Aqui está um programa de relógio digital em funcionamento (não destruído). Este programa está escrito em *> <> :

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

^{Nota: Tudo é idêntico a> <>, exceto, s = segundo, m = minuto, h = hora, S = suspensão (100ms * x)}

Isso gera:

14:44:31

Atualizando a cada 100ms até terminar.

Exemplos não permitidos

O seguinte não é permitido:

1:

14:44:3114:44:32

2:

14:44:31 14:44:32

3:

14:44:31
14:44:32

O tempo deve permanecer na primeira linha em que foi produzido, sem caracteres à direita visíveis. A limpeza do terminal, porém, seria permitida, pois isso ainda não teria caracteres à direita.

Pyke, 6 bytes

Ctr\ J

Experimente aqui!

Eu acho que isso é válido. Substitua o caractere de espaço por retorno de carro para saída válida (não funciona online)

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

Testado no Chrome.

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

<a id=a>

-1 byte (@ETHProductions): use o formato de hora em francês em vez de .toTimeString().slice(0,8)

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

Isso funcionará no FireFox.

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

<a id=a>

-3 bytes (@ETHProductions): use o formato de hora em francês em vez de .toTimeString().slice(0,8)

Python 2, 50 bytes

(Python 2.1+ para ctimesem argumento)

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

time.ctime()produz uma string formatada, a partir da qual o hh: mm: ss pode ser fatiado usando [11:19](ele permanece no mesmo local, independentemente da data e hora).

printinserir o retorno de carro '\r'antes do texto e tornar o texto o primeiro item de uma tupla ,suprime efetivamente o final implícito '\n'e substitui a saída gravada anteriormente.

while 1 laços para sempre.

Mathematica, 48 41 37 28 bytes

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

A saída será a TimeObject, atualizando continuamente.

Se parece com isso:

Versões alternativas

48 bytes:

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

53 bytes:

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

Vejo que o requisito de uma entrada de interface do usuário sem sinal para interromper o programa foi removido. Então agora podemos fazer:

Bash + coreutils, 28

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

yes gera continuamente a string "now", uma vez por linha, em um pipe.

date -f-lê interpreta cada "agora" como a hora atual e depois sai no formato necessário. A seqüência de formato inclui a sequência de escape ANSI para limpar a tela. date faz saída de uma nova linha após a data - Eu não tenho certeza se isso desqualifica, uma vez que o ecrã é limpo a cada vez de qualquer maneira.

Se desqualificar, podemos usar tr:

Bash + coreutils, 31

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

Respostas anteriores:

Festança + X, 32

xclock -d -update 1 -strftime %T

Infelizmente, isso só pode ser atualizado a cada segundo. Se isso desqualificar, podemos fazer isso:

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$

Limpa constantemente a tela e imprime a hora do sistema no formato 22:03:41.

Clojure, 150 136 141 bytes

V3: 141 bytes :(

+5 bytes para corrigir um erro. Como os horários não são preenchidos com zero, o relógio pode "encolher" e expandir quando o tempo muda. Estava "manchando" quando encolheu porque o último dígito não estava mais sendo limpo. Corrigido adicionando alguns espaços no final para garantir que tudo esteja sendo substituído.

#(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 mudando para usando SimpleDateFormatpara formatar a data. Ainda 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)))

Percebi que provavelmente estou usando a pior maneira possível para conseguir a data. Definitivamente espaço para melhorias aqui.

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 bytes

O watch não faz parte do coreutils , mas está disponível imediatamente em praticamente todas as distribuições Linux.

Golfe

watch -tn1 date +%T

Experimente online!

WinDbg, 73 bytes

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

Atualiza continuamente uma linha com a hora atual até o usuário pressionar Ctrl + Break.

Como 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

Saída de amostra (bem, você entendeu):

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");

o date função imprime tudo literalmente que não reconhece.

\r é o retorno de carro, define o cursor para a primeira coluna.

Corra com -r.

MATL , 11 bytes

`XxZ'13XODT

Loop infinito que limpa a tela e imprime a hora no formato especificado.

Você pode experimentá-lo no MATL Online! . Este compilador é experimental; se não funcionar, atualize a página e pressione "Executar" novamente.

C #, 82 bytes

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

Método anônimo que constantemente sobrescreve 8 caracteres com nova saída. Pode ser reduzido em 1 byte se for modificado para aceitar um parâmetro fictício ( 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 substituindo a mesma linha em um loop infinito

SmileBASIC 3.3.2, 38 bytes

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

UTF-16 é uma merda :(

De qualquer forma, isso imprime repetidamente a hora local em HH: MM: SS com um espaço depois, sem nova linha depois. Porém, ele não atualiza a cada segundo, apenas imprime repetidamente para sempre.

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 eu não gosto de usar cls no Powershell. Na publicação do briantist @ /codegolf//a/102450/63383

Pascal, 61 bytes

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

O pascal livre possui rotinas de tempo agradável na unidade SysUtils. Ungolfed:

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

Bytes C 65 (anteriores 64)

Garantido para trabalhar na máquina Linux. :)

@Marco Thanks!

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

Vim, 26 bytes

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

Isso cria uma macro recursiva (por exemplo, um loop eterno) que exclui todo o texto da linha atual e o substitui pela hora atual.

Pitão - 28 bytes

Meio demorado, porque pyth não tem tempo de atividade.

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

Groovy, 45 caracteres

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

Gelatina , 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

Experimente online!

O retorno de carro não funciona on-line e eu não consigo fazer o intérprete funcionar, portanto é meio que não testado, mas funciona conforme o esperado quando eu uso caracteres imprimíveis no lugar do 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.toTimeStringé suportado na implementação de referência pelo Java DateFormat.getTimeInstance(), que depende da localidade, para que você possa configurar a localidade padrão do sistema para uma que use 24 horas.

PowerShell, 30 28 24 20 bytes

A região do meu computador foi alterada para a Alemanha com base em Alterei comentário do raznagul para economizar 4 bytes. :)

for(){date -F T;cls}

Versão anterior que funciona em todas as localidades.

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

tcl, 69 bytes

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

Experimente aqui!

Lote, 36 bytes

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

Onde ␈representa o caractere ASCII BS (código 8).

Raquete, 71 bytes

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

Onde o ↵é realmente um CR (hex 0d). Dump hexadecimal do programa para mais esclarecimentos (byte de aviso na posição 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

Usa SRFI / 19 incluído na distribuição de raquete. (current-date)obtém a data e hora local atual. O date->stringformato ~3é o formato ISO-8601 hora-minuto-segundo. (let l () ... (l))em um loop infinito idiomático. (require srfi/19)carrega o 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

(No TI-BASIC, muitos caracteres são tokens de 2 bytes e dois pontos no início de uma linha são 0 bytes extras)

: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")}

Tem um espaço à direita (devido ao catseparador padrão ser um espaço).
Devido à taxa de atualização da GUI do R, sua execução na GUI ocasionalmente pulará alguns segundos, mas se você o salvar em um arquivo e executá-lo na linha de comando, ele será exibido corretamente a cada segundo.
Funcionará para sempre até o usuário interromper.