显示数字时钟

（我看到时钟挑战很多，我已经尝试阅读所有挑战，我敢肯定这是独一无二的）

写一些代码，不断更新的格式显示一个数字时钟h:m:s，其中h，m和s可以占据每1个或2个字符。简单的限制如@BlueEyedBeast所说的，我基本上希望它代替显示的时间。

• 不允许换行
• 允许尾随空格
• 不允许其他尾随字符
• 不应错过任何秒数（不允许57-> 59）
• 允许以“ 0”开头的数字，只要它们不超过2个字符
• 该代码不得接受任何输入
• 如果您的语言在没有输入的情况下无法获取当前时间，则可以使用标准允许的方式，最多输入8个字节
• 输出必须是stdout
• 这是codegolf，所以最短的答案就是成功！

例

我正在使用一种名为*> <>（海星）的语言，因为在> <>中（例如，等待文件I / O）无法使用此类程序。这是其中一个正在工作的数字时钟程序（已取消存储）。该程序用*> <>编写：

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

^{注意：除了s =秒，m =分钟，h =小时，S =睡眠（100ms * x）之外，其他所有内容均与> <>相同。}

输出：

14:44:31

每100ms更新一次，直到终止。

不允许的例子

不允许以下内容：

1：

14:44:3114:44:32

2：

14:44:31 14:44:32

3：

14:44:31
14:44:32

时间必须保留在输出的第一行上，并且没有可见的尾随字符。但是，清除终端将被允许，因为它仍然没有任何尾随字符。

Pyke，6个字节

Ctr\ J

在这里尝试！

我认为这是有效的。用回车符代替空格字符以获取有效输出（不能在线使用）

HTML + JS（ES6），8 + 60 = 68字节

在Chrome中测试。

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

<a id=a>

-1字节（@ETHProductions）：使用法语时间格式，而不是 .toTimeString().slice(0,8)

HTML + JS（ES6），8 + 62 = 70字节

这将在FireFox中起作用。

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

<a id=a>

-3个字节（@ETHProductions）：使用法语时间格式，而不是 .toTimeString().slice(0,8)

Python 2，50个字节

（ctime不带参数的Python 2.1+ ）

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

time.ctime()产生一个格式化的字符串，可以从中使用hh：mm：ss对其进行切片[11:19]（无论日期和时间，它都位于相同的位置）。

print'\r'在文本之前设置回车符，并使文本成为元组的第一项，可以,有效地抑制隐式尾随'\n'并覆盖先前写入的输出。

while 1 永远循环。

Mathematica，48 41 37 28字节

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

输出将是TimeObject，连续刷新。

看起来像这样：

替代版本

48个字节：

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

53个字节：

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

我看到不再需要非信号UI输入来停止程序了。所以现在我们可以做：

Bash + coreutils，28岁

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

yes 每行一次将字符串“ now”连续输出到管道中。

date -f-reads将每个“现在”解释为当前时间，然后以所需格式输出。格式字符串包括ANSI转义序列以清除屏幕。 date 确实在日期之后输出换行符-我不确定这是否不合格，因为无论如何每次都会清除屏幕。

如果它不符合条件，那么我们可以tr改用：

Bash + coreutils，31岁

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

以前的答案：

重击+ X，32

xclock -d -update 1 -strftime %T

不幸的是，这只能每秒更新一次。如果那不符合资格，那么我们可以改为：

Bash + coreutils，43岁

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

QBIC，6个字节

{_C?_d

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

不断清除屏幕并以格式打印系统时间22:03:41。

Clojure, 150 136 141 bytes

V3: 141 bytes :(

+5 bytes to fix a bug. Since the times aren't zero padded, the clock can "shrink" and expand when the time changes. It was "smearing" when it shrunk because the last digit was no longer being cleared. Fixed it by adding some spaces at the end to ensure everything is being overwritten.

#(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 by switching to using SimpleDateFormat to format the date. Still huge.

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

I realized I'm probably using the worst way possible to get the date. Definitely room for improvement here.

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

watch is not a part of coreutils, but is available out of the box on virtually every Linux distro.

Golfed

watch -tn1 date +%T

Try it online !

WinDbg, 73 bytes

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

It continually updates a line with the current time until the user presses Ctrl+Break.

How it works:

.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

Sample output (well, you get the 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");

The date function prints everything literally that it doesn´t recognize.

\r is the carriage return, sets the cursor to the first column.

Run with -r.

MATL, 11 bytes

`XxZ'13XODT

Infinite loop that clears the screen and prints the time in the specified format.

You can try it at MATL Online!. This compiler is experimental; if it doesn't work refresh the page and press "Run" again.

C#, 82 bytes

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

Anonymous method which constantly overwrites 8 characters with new output. Can be made 1 byte shorter if modifying to accept a dummy parameter (z=>...).

Full program:

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

Works by overwriting the same line within an endless loop

SmileBASIC 3.3.2, 38 bytes

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

UTF-16 sucks :(

Anyway, this repeatedly prints the local time in HH:MM:SS with a space after it, no newline afterward. It doesn't update every second though, it just repeatedly prints forever.

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

Because I dislike using cls in Powershell. From briantist's post @/codegolf//a/102450/63383

Pascal, 61 bytes

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

Free pascal has nice time routines in SysUtils unit. Ungolfed:

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

C 65 (prev 64) bytes

Guaranteed to work on Linux machine. :)

@Marco Thanks!

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

Vim, 26 bytes

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

This creates a recursive macro (e.g. an eternal loop) that deletes all the text on the current line and replaces it with the current time.

Pyth - 28 bytes

Kinda longish, because pyth has no strftime.

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

Groovy, 45 characters

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

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

Try it online!

The carriage return doesn't work online, and I can't get the interpreter to work, so its kinda untested, but it works as expected when I use printable characters in place of the 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 is backed in the reference implementation by Java's DateFormat.getTimeInstance(), which is locale-dependent, so you can set your default system locale to one that uses 24-hour time.

PowerShell, 30 28 24 20 bytes

Changed my computer's region to Germany based on raznagul's comment to save 4 bytes. :)

for(){date -F T;cls}

Previous version that works in all locales.

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

tcl, 69 bytes

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

Try it here!

Batch, 36 bytes

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

Where ␈ represents the ASCII BS character (code 8).

Racket, 71 bytes

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

Where the ↵ is actually a CR (hex 0d). Hex dump of the program for further clarification (notice byte at 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

Uses SRFI/19 included with the Racket distribution. (current-date) gets the current local date & time. The date->string format ~3 is ISO-8601 hour-minute-second format. (let l () ... (l)) in an idiomatic infinite loop. (require srfi/19) loads the srfi/19 module.

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

(In TI-BASIC, many characters are 2 byte tokens, and colons at the beginning of a line are 0 extra bytes)

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

Has one trailing space (because of cat default separator being a space).
Because of the refresh rate of the R GUI, running this in the GUI will occasionally skip some seconds, but if you save it to a file and run it on the command line it will display correctly every single seconds.
Will run forever until user interrupt.