好吧，英国退欧发生了。天才新闻（Sky News）是他们的天才，他们决定在公交车旁创建倒计时。

您的工作是做类似的事情。英国于2019年3月31日离开欧盟，您必须为此创建一个数字倒计时，该倒计时每秒更改一次（允许0.05秒偏差）。

输入项

您的程序绝对不应输入。它被禁止！

输出量

它应以格式输出英国脱欧之前的时间ddd:hh:mm:ss。允许使用换行符开头和结尾，但每次显示都应留在同一位置。看起来好像它实际上已经到位了。正如@AnthonyPham所指出的，这并不意味着要打印足够的换行符来“清除”屏幕，这意味着您实际上必须清除屏幕。

不允许这样的输出：

100:20:10:05
100:20:10:04

这也不是

100:20:10:05
*A thousand newlines*
100:20:10:04

因为他们不在一条线上。

英国退欧后，您不必担心。您的程序最多只能运行31/3/2019

规则

• 不允许出现标准漏洞
• 这是代码高尔夫球，因此以字节为单位的最短代码获胜。
• 错误消息（尽管我不认为如何）是不允许的
• 该代码应能够在2年内运行（英国退出欧盟时），并且应该显示实际时间，而不是再次从730开始（请参见下文）

倒数规则

倒计时不应硬编码，并且应该能够在英国退欧结束之前的任何时间运行，并且仍会产生正确的结果。新的一天开始时，小时应遵循以下格式

712:00:00:01
712:00:00:00
711:23:59:59

我再说一遍，为方便起见，英国退欧的结束日期是午夜31/3/2019（31：3：19 00:00:00或31：3：2019 00:00:00或您想要的任何其他格式）

NB：我想我拥有所有东西，但是我没有在沙盒中发布，否则可能已经不合时宜了。随意发布任何改进建议，因为它并不完美。

JavaScript中，134个 129 113字节

setInterval("d=-new Date;document.body.innerHTML=`<pre>${d/864e5+17986|0}:`+new Date(d).toJSON().slice(11,19)",1)

编辑：由于@Shaggy，节省了2个字节。@ l4m2节省了11个字节。

PowerShell，70 63 55 53字节

排除双引号，使用@Joey轻松实现-2

for(){cls;(date 31Mar19)-(date)|% T* ddd\:hh\:mm\:ss}

使用sleep运行此命令会增加8个字节，但是如果不使用输入运行（带有睡眠的版本（63字节）），则输入几乎是不可见的：

for(){cls;(date 31/3/19)-(date)|% T* ddd\:hh\:mm\:ss;sleep 1}

for() 是一个无限循环，并且在该循环内。

cls 清除屏幕，

将其31/3/19作为DateTime对象，并从中获取-当前日期，以给出剩余时间，然后.ToString()（|% T*）以正确的格式给出时间。

脱欧后这将显示负时间。

Excel VBA，91 84 82字节

^{由于JoeMalpass指出Excel将日期视为数字，因此节省了7个字节。
由于JoeMalpass，节省了2个字节}

Sub b()
Do
t=CDec(43555-Now)
Cells(1,1)=Int(t) &Format(t,":hh:mm:ss")
Loop
End Sub

输出到A1活动Excel工作表中的单元格。

Python 3.6，146个字节

from datetime import*
x=datetime
while 1:d=x(2019,3,31)-x.now();s=d.seconds;a=s%3600;print(end=f"\r{d.days:03}:{s//3600:02}:{a//60:02}:{s%60:02}")

C＃，173 172 156 150 127字节

using System;class P{static void Main(){for(;;)Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:d\\:hh\\:mm\\:ss}  ");}}

@Bob节省了16个 字节@ SørenD.Ptæus 节省了6个字节

格式化版本：

using System;

class P
{
    static void Main()
    {
        for (;;)
            Console.Write($"\r{new DateTime(2019, 3, 31) - DateTime.Now:d\\:hh\\:mm\\:ss}  ");
    }
}

的JavaScript ES5，320 319 316 305 295 284字节

setInterval(function(){a=Math,b=a.floor,c=console,d=Date,e="00",f=new d(2019,2,31),g=a.abs(f-new d)/1e3,h=b(g/86400);g-=86400*h;var i=b(g/3600)%24;g-=3600*i;var j=b(g/60)%60;g-=60*j,c.clear(),c.log((e+h).slice(-3)+":"+(e+i).slice(-2)+":"+(e+j).slice(-2)+":"+(e+a.ceil(g)).slice(-2))})

感谢@Fels进行引用Math，@dgrcode进行引用console

未打高尔夫球

setInterval(function() {

  var math = Math, floor = math.floor, c = console, d = Date;

  var leadings = "00";

  // set our brexit date
  var brexit = new d(2019, 2, 31);

  // get total seconds between brexit and now
  var diff = math.abs(brexit - new d()) / 1000;

  // calculate (and subtract) whole days
  var days = floor(diff / 86400);
  diff -= days * 86400;

  // calculate (and subtract) whole hours
  var hours = floor(diff / 3600) % 24;
  diff -= hours * 3600;

  // calculate (and subtract) whole minutes
  var minutes = floor(diff / 60) % 60;
  diff -= minutes * 60;

  // what's left is seconds

  // clear the console (because OP said it must print in the same place)
  c.clear();

  // log the countdown, add the leadings and slice to get the correct leadings 0's
  c.log((leadings + days).slice(-3) + ":" + (leadings + hours).slice(-2) + ":" + (leadings + minutes).slice(-2) + ":" + (leadings + math.ceil(diff)).slice(-2));

});

PHP，84字节

for(;$c=DateTime;)echo(new$c('@1553990400'))->diff(new$c)->format("\r%a:%H:%I:%S ");

非常坦率的。1553990400是UTC的31-3-2019 00:00:00的时间戳。使用DateTime-> diff（）-> format（）输出剩余时间，它可以无限循环。英国退欧发生后，它将从0开始计数。

已评论/更具可读性的版本：

// Infinite loop, assign DateTime (as a string) to $class
for (; $class = DateTime;) {
    echo (new $class('@1553990400')) // Create a new DateTime object for the brexit date/time.
            ->diff(new $class) // Caulculate the difference to the current date/time.
            ->format("\r%a:%H:%I:%S "); // Format it according to the specification, starting with a \r character to move to the start of the line and overwrite the previous output.
}

CJam，69 62 59 57字节

通过不同地转换为时间格式节省了7个字节

感谢Martin Ender的建议，节省了3个字节

通过使用回车符而不是退格键节省了2个字节

{15539904e5esm1e3/{60md\}2*24md\]W%{sYTe[}%':*CTe[oDco1}g

由于明显的原因，不能在TIO上运行。

尽管它实际上仅每秒更新一次时间，但它会无限循环不断地重写显示内容，因此文本种类会闪烁进出（至少在我的控制台中）。

此70字节版本仅每秒打印一次：

{15539904e5es:Xm1e3/{60md\}2*24md\]W%{sYTe[}%':*CTe[oDco{esXm1e3<}g1}g

说明

{                           e# Begin a while loop
  15539904e5                e#  The timestamp on which Brexit will occur
  es                        e#  The current timestamp
  m                         e#  Subtract
  1e3/                      e#  Integer divide by 1000, converting to seconds from ms
  {                         e#  Run this block twice
   60md                     e#   Divmod by 60
   \                        e#   Swap top elements
  }2*                       e#  (end of block) 
                            e#    This block divmods the timestamp by 60, resulting in 
                            e#    the remaining minutes and seconds. Then the minutes get 
                            e#    divmod-ed by 60, to get hours and minutes remaining
  24md\                     e#  Divmod hours remaining by 24 and swap top elements, to get
                            e#    the hours left and days left.
  ]                         e#  Wrap the entire stack in an array
  W%                        e#  Reverse it since it's currently in the wrong order
  {                         e#  Apply this block to each element of the array
   s                        e#   Cast to string (array of digit characters)
   YTe[                     e#   Pad to length 2 by adding 0s to the left
  }%                        e#  (end of map block)
  ':*                       e#  Join with colons
  CTe[                      e#  Pad to length 12 by adding 0s to the left, dealing with the
                            e#    special case of the day being 3 digits. 
  o                         e#  Pop and print the resulting string, which is the time
  Dco                       e#  Print a carriage return, moving the cursor back to the start
  1                         e#  Push 1
}g                          e# Pop 1, if it's true, repeat (infinite loop)

Python 3.5（118字节）

import datetime as d,os
d=d.datetime
while 1:os.system("cls");e=str(d(2019,3,31)-d.today());print(e[:3]+':'+e[-15:-7])

C＃6，149个字节

感谢Bob节省了57个字节！

using System;class P{static void Main(){DateTime a,x=new DateTime(2019,3,31);while((a=DateTime.Now)<x)Console.Write($"\r{x-a:ddd\\:hh\\:mm\\:ss}");}}

非高尔夫节目：

using System;

class P
{
    static void Main()
    {
        DateTime a,
                x = new DateTime(2019, 3, 31);
        while ( (a = DateTime.Now) < x)
            Console.Write($"\r{x-a:ddd\\:hh\\:mm\\:ss}");
    }
}

C＃，210 206 159字节

谢谢 Bob节省了47个字节！

谢谢 Martin Smith节省了4个字节！

using System;class P{static void Main(){DateTime a,x=new DateTime(2019,3,31);while((a=DateTime.Now)<x)Console.Write("\r"+(x-a).ToString(@"ddd\:hh\:mm\:ss"));}}

非高尔夫节目：

using System;

class P
{
    static void Main()
    {
        DateTime a,
                x = new DateTime(2019, 3, 31);
        while ( (a = DateTime.Now) < x)
            Console.Write("\r" + (x - a).ToString(@"ddd\:hh\:mm\:ss"));
    }
}

C，104字节

main(x){for(;x=1553990400-time(0);)printf("\n%03d:%02d:%02d:%02d\e[1A",x/86400,x/3600%24,x/60%60,x%60);}

分解

main(x){
    for(;x=1553990400-time(0);)             // Seconds remaining
        printf("\n%03d:%02d:%02d:%02d\e[1A",// Move cursor and print:
            x/86400,                        // Days
            x/3600%24,                      // Hours
            x/60%60,                        // Minutes
            x%60);                          // Seconds
    puts("Now we can stop talking about it forever."); // Wishful thinking
}

依靠 time自1970年1月1日以来返回的秒数，这对我来说就是这种情况（在macOS上使用Clang / GCC），大多数UNIX情况应该如此。

使用bash终端转义序列来移动光标（<esc>[1A将光标向上移动1行）。能够简单地使用会更好\r，但是printf直到看到换行符时才刷新，并且手动刷新需要更多时间。

可能是我见过的最耗CPU的倒数计时。在热循环中运行以确保其始终尽可能准确。如果在截止日期之后运行，它将产生一些非常奇怪的东西（到处都是负数！）

AHK，145字节

我认为这不是最短的答案，但是结果给人以厄运的感觉。我本来想送按键Ctrl+ A之后DEL，然后无论时间，但是刷新速度太慢，它会破坏你在任何环境。相反，那么，我与GUI去了。事实证明，与一遍又一遍地更新控件相比，完全销毁窗口并重新创建窗口所需的字节数更少，因此我同意了。这是一个很好的效果。

Loop{
s=20190331000000
s-=A_Now,S
d:=t:=20000101000000
t+=s,S
d-=t,D
d*=-1
FormatTime f,%t%,:HH:mm:ss
GUI,Destroy
GUI,Add,Text,,%d%%f%
GUI,Show
}

C＃，128个 127字节

using System;class P{static void Main(){for(;;)Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}");}}

取消程式码：

using System;
class P
{
    static void Main()
    {
        for(;;)
            Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}"); 
    }
}

如果没有其他C＃答案的帮助，我不会想出\ r技巧。

对于任何需要进一步改进的人，您还可以将Write（）表达式放入for循环中。似乎我应该可以在这里保存一个字节，因为这样可以为我节省该语句的分号，但由于您不能有一个完全空的主体，因此可以使用相同的数字：

using System;class P{static void Main(){for(;;Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}"));}}

Ruby（83字节）

loop{h=431664-Time.now.to_r/3600;$><<['%02d']*4*?:%[h/24,h%24,h%1*60,h*3600%60]+?\r}

不打高尔夫球

loop do
  seconds = 1553990400 - Time.now.to_r

  print (["%02d"] * 4).join(':') % [
    seconds / 24 / 60 / 60     ,
    seconds      / 60 / 60 % 24,
    seconds           / 60 % 60,
    seconds                % 60,
  ] + "\r"
end

基本上是Python提交之一，但有所改进。在重新渲染之前，我们只是发出一个“ \ r”以字符串的开头。对于的字符串格式"%03d:%02d:%02d:%02d"，我们真的不在乎第一个说明符的宽度……所以我们可以这样做"%02d"*4，并发出退格键和空格以清除多余的冒号。

另外，我发现一个两个字符的短print：$><<。$>是一个速记全球对$defout，这对于输出流print和printf，缺省值为STDOUT。IO#<<将其右侧写入流中。那两个字符怎么短？好了，我现在可以省略在括号内加上格式字符串的前导空格。

在这一点上，我真的认为没有办法在Ruby中进一步缩短此程序。

编辑：我错了。代替第一时间Time.new(2019,3,31)，我们可以使用原始UNIX时间：1553990400。

编辑2：我尝试过处理分钟，然后将UNIX时间戳除以该常数，但是实际上并没有节省任何字节。:(

编辑3：结果缓存 h=3600实际上使我受了两个字节的伤害。哎呀

编辑4：感谢@EricDuminill，节省了3个字节。他使用了浮点数，但是在不损失精度的情况下进行了理性操作！

编辑5：Array#*作为的别名Array#join，?对每个字符使用Ruby -syntax！

JavaScript + HTML，136 + 7 = 143字节

setInterval("d=1553990400-new Date/1e3|0;w.innerText=[60,60,24,999].map(z=>(q='00'+d%z,d=d/z|0,q.slice(z<61?-2:-3))).reverse().join`:`")

<a id=w

C＃，142个字节

using System;class P{static void Main(){a:Console.Write($"\r{(new DateTime(2019,3,31)-DateTime.Now).ToString("d\\:h\\:mm\\:ss  ")}");goto a;}}

非高尔夫节目：

using System;
class P
{
    static void Main()
    {
        a: Console.Write($"\r{(new DateTime(2019, 3, 31) - DateTime.Now).ToString(@"d\:h\:mm\:ss  ")}"); goto a;
    }
}

Bash + GNU日期，128个字节

感谢@muru减少了2个字节，而感谢@This Guy减少了2个字节。

C=:%02d;while sleep 1;do D=$[B=3600,A=24*B,1553990400-`date +%s`];printf "%03d$C$C$C\r" $[D/A] $[D%A/B] $[D%A%B/60] $[D%60];done

不打高尔夫球

DAY=86400
HOUR=3600
while sleep 1 ; do
 DIFF=$[1553990400-`date +%s`]
 printf "%03d:%02d:%02d:%02d\r" \
         $[DIFF/DAY] \
         $[DIFF%DAY/HOUR] \
         $[DIFF%DAY%HOUR/60] \
         $[DIFF%60]
done

MATL, 45 bytes

737515`tZ'-tkwy-':HH:MM:SS'XOw'%03d'YDwYcDXxT

TIO apparently doesn't support clearing the output, but thankfully MATL Online does!

At 2 bytes more, a bit more CPU-friendly version that does a pause (sleep) every second:

737515`tZ'-tkwy-':HH:MM:SS'XOw'%03d'YDwYcDT&XxT

Try this on MATL Online

737515 is "31st of March 2019" represented MATLAB's default epoch format - number of days from January 0, 0000, optionally including a fractional part to represent the time of day. (I tried to shorten this by calculating it somehow, but its only factors are 5 and another six digit number (147503), and I couldn't figure out a way to do it in less than 6 bytes.)

`    % start do-while loop
tZ`- % duplicate Brexit date, get current date (& time), subtract
tk   % duplicate the difference, get the floor of it (this gives number of days left)
w    % switch stack to bring unfloored difference to top
y    % duplicate the floored value on top of that
-    % subtract to get fractional part representing time
':HH:MM:SS'XO % get a datestr (date string) formatted this way
w    % switch to bring number of days back on top
'%03d'YD      % format that to take 3 places, with 0 padding if needed
wYc  % switch to bring time string back on top, concatenate date and time
D    % display the concatenated result!
T&Xx % clear screen after a 1 second pause (the pause is optional, without it the call is `Xx`)
T    % push True on stack to continue loop

PHP, 64 bytes

while($d=1553990401-time())echo--$d/86400|0,date(":H:i:s\r",$d);

This will count exactly until 0:00:00:00 and then break/exit. Run with -r.

-2 bytes if I wouldn´t have to print the 0.

RPL, 83 78 bytes

Assuming your HP48, or similar, is setup with correct (UK) time and date, mm/dd date format, and 24h time format:

WHILE 1REPEAT DATE 3.302019DDAYS":"1.1 24TIME HMS- TSTR 15 23SUB + + 1DISP END

I was surprised to be able to save 2 bytes by removing spaces around ":". 1.1 is the shortest valid date, later dumped by SUB. Be careful with emulators, the time may run faster or slower (or not at all) than your wall clock. With a real HP, you can stop this program by pressing the ON key … or wait for empty batteries.

PHP, 102 95 90 bytes

Saved 7 bytes thanks to @TheLethalCoder & by not factoring

Saved another 5 bytes by concatenating

<? $b=1553990400-time();echo floor($b/$d=86400).date(':H:i:s', $b%$d);header('Refresh:1');

This is my first golf, so I'm probably missing quite a few tricks, but here you are regardless.

As for @chocochaos' PHP answer that would otherwise trump this, I believe it is flawed for reasons I have explained in my comments, but as I'm new here I might be wrong. Or I'm just a newbie :)

AWK, 78 bytes

BEGIN{for(;v=1552953600-systime();printf"\r%d:%s",v/86400,strftime("%T",v)){}}

Try it online!

Was longer before I realized I could precalculate the end time. Sometimes it pays to be a bit late to the game and get ideas from others.

FYI, the TIO link doesn't work very well, since it doesn't implement \r properly.

F#, 142 bytes

open System
let f=
 let t=DateTime(2019,3,31)
 while DateTime.Now<=t do Console.Clear();t-DateTime.Now|>printf"%O";Threading.Thread.Sleep 1000

I grew up in Ireland about half a kilometre from the border. Apart from a "Welcome to Fermanagh" sign and the road markings changing you wouldn't know you'd entered another country. Used to cross it twice on the way to school.

c, gcc 114 bytes

main(s){system("clear");if(s=1553900399-time(0)){printf("%d:%d:%d:%d\n",s/86400,s/3600%24,s/60%60,s%60);main(s);}}

Nothing omitted, full program. The program compiles in gcc on Ubuntu. The countdown will not show a long trail of print statements because of the system call to clear and halts when the countdown reaches 0 seconds.

UnGolfed

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>


//Brexit countdown timer
int main(){
  int sec = 1553900400 - time(0);//seconds remaining until Brexit
  if(sec){
    sleep(1);
    system("clear");
    printf("Brexit Countdown\n");
    printf("days Hours Mins Secs\n");
    printf("%d:  %d:    %d:  %d\n",
            sec/86400, sec/3600%24,
            sec/60%60, sec%60);
    main();
  }
}