[Question]
  [
Well, Brexit [happened](http://www.bbc.co.uk/news/uk-politics-39431428). And Sky News, being the geniuses they are, have decided to create a countdown on the side of a bus.
[![enter image description here](https://i.stack.imgur.com/MCAE7.png)](https://i.stack.imgur.com/MCAE7.png)
Your job is to do something similar. The UK leaves the the EU on 31st of March 2019 and you have to create a digital countdown for this that changes every second (with a 0.05 second deviation allowed).
## Input
Your program should take absolutely no input. It is banned!
## Output
It should output the time until Brexit in the format `ddd:hh:mm:ss`. Leading and trailing newlines are allowed but the display should stay in the same place each time. It should look as though it is actually decreasing in place. As pointed out by @AnthonyPham this doesn't mean printing enough newlines to "clear" the screen, this means that you must actually clear the screen.
An output like this isn't allowed:
```
100:20:10:05
100:20:10:04
```
Neither is this
```
100:20:10:05
*A thousand newlines*
100:20:10:04
```
as they're on more than one line.
You don't have to worry about after Brexit. Your program only has to work up to 31/3/2019
## Rules
* [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are disallowed
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code in *bytes* wins.
* Error messages (although I can't think how) are disallowed
* The code should be able to be run in 2 years time (when the UK leaves the EU) and should display the actual time and not start from 730 again (see below)
## Countdown rule
The countdown should not be hard-coded and should be able to run at any time before Brexit finishes and still produce the correct result. When a new day is begun the hour should follow the below format
```
712:00:00:01
712:00:00:00
711:23:59:59
```
Let me say again, the date Brexit finishes is 31/3/2019 at midnight for convenience (31:3:19 00:00:00 or 31:3:2019 00:00:00 or any other format you want)
*NB: I think I have everything but I didn't post this in the Sandbox, otherwise the timing could have been off. Feel free to post any suggestions for improvements because it isn't perfect.*
  
[Answer]
## JavaScript, ~~134~~ ~~129~~ 113 bytes
```
setInterval("d=-new Date;document.body.innerHTML=`<pre>${d/864e5+17986|0}:`+new Date(d).toJSON().slice(11,19)",1)
```
Edit: Saved 2 bytes thanks to @Shaggy. Saved 11 bytes thanks to @l4m2.
[Answer]
# PowerShell, ~~70~~ ~~63~~ ~~55~~ 53 Bytes
Excluded double quotes, easy -2 thanks to [@Joey](https://codegolf.stackexchange.com/users/15/joey)
```
for(){cls;(date 31Mar19)-(date)|% T* ddd\:hh\:mm\:ss}
```
Running this with sleep adds 8 bytes, but the input is mostly invisible if it is run without them, version (63 bytes) with sleep:
```
for(){cls;(date 31/3/19)-(date)|% T* ddd\:hh\:mm\:ss;sleep 1}
```
`for()` is an infinite loop, and within that loop..
`cls` to clear the screen,
get `31/3/19` as a `DateTime` object, and `-` the current date from it, to give the time remaining, then `.ToString()` (`|% T*`) that with the correct format.
this will display negative time after brexit.
[Answer]
# Python 3.6, 146 bytes
```
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}")
```
[Answer]
# Excel VBA, ~~91~~ ~~84~~ 82 bytes
Saved 7 bytes thanks to JoeMalpass pointing out that Excel sees dates as numbers.  
Saved 2 bytes thanks to JoeMalpass
```
Sub b()
Do
t=CDec(43555-Now)
Cells(1,1)=Int(t) &Format(t,":hh:mm:ss")
Loop
End Sub
```
Output is to cell `A1` in the active Excel sheet.
[Answer]
## C#, ~~173~~ ~~172~~ ~~156~~ ~~150~~ 127 bytes
```
using System;class P{static void Main(){for(;;)Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:d\\:hh\\:mm\\:ss}  ");}}
```
*Saved 16 bytes thanks to @Bob*
*Saved 6 bytes thanks to @Søren D. Ptæus*
Formatted version:
```
using System;
class P
{
    static void Main()
    {
        for (;;)
            Console.Write($"\r{new DateTime(2019, 3, 31) - DateTime.Now:d\\:hh\\:mm\\:ss}  ");
    }
}
```
[Answer]
# [AHK](https://autohotkey.com/), 145 Bytes
This is not the shortest answer but the result gives a very nice feeling of doom, I think. I originally tried to send the keystrokes `Ctrl`+`A` followed by `DEL` and then whatever the time was but the refresh rate was too slow and it would destroy whatever environment you were in. Instead, then, I went with the GUI. It turned out to take less bytes to completely destroy the window and recreate it than it did to update the control over and over so I went with that. It's a nice effect.
```
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
}
```
[![I'm gonna sing the doom song!](https://i.stack.imgur.com/PBg3d.gif)](https://i.stack.imgur.com/PBg3d.gif)
[Answer]
# JavaScript ES5, ~~320~~ ~~319~~ ~~316~~ ~~305~~ ~~295~~ 284 bytes
```
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))})
```
Thanks to @Fels for referencing `Math`, @dgrcode for referencing `console`
## Un-golfed
```
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));
});
```
[Answer]
# PHP, 84 bytes
```
for(;$c=DateTime;)echo(new$c('@1553990400'))->diff(new$c)->format("\r%a:%H:%I:%S ");
```
Fairly straightforward. 1553990400 is the timestamp for 31-3-2019 00:00:00 in UTC. It loops infinitely, using DateTime->diff()->format() to output how much time is left. After Brexit has happened, it will start counting up from 0.
Commented / more readable version:
```
// 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.
}
```
[Answer]
# CJam, ~~69~~ ~~62~~ ~~59~~ 57 bytes
*Saved 7 bytes by converting to time format differently*
*Saved 3 bytes thanks to Martin Ender's suggestions*
*Saved 2 bytes by using a carriage return instead of backspaces*
```
{15539904e5esm1e3/{60md\}2*24md\]W%{sYTe[}%':*CTe[oDco1}g
```
Can't be run on TIO for obvious reasons.
It rewrites the display constantly in an infinite loop so the text kind of flashes in and out (at least in my console), although it only actually updates the time once per second.
This 70-byte version only prints once per second:
```
{15539904e5es:Xm1e3/{60md\}2*24md\]W%{sYTe[}%':*CTe[oDco{esXm1e3<}g1}g
```
**Explanation**
```
{                           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)
```
[Answer]
# Python 3.5 (118 Bytes)
```
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])
```
[Answer]
# C#6, 149 bytes
*Thanks to [Bob](https://codegolf.stackexchange.com/users/4163/bob) for saving 57 bytes!*
```
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}");}}
```
Ungolfed program:
```
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 bytes
*Thanks to [Bob](https://codegolf.stackexchange.com/users/4163/bob) for saving another 47 bytes!*
*Thanks to [Martin Smith](https://codegolf.stackexchange.com/users/47524/martin-smith) for saving 4 bytes!*
```
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"));}}
```
Ungolfed program:
```
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"));
    }
}
```
[Answer]
# C, 104 bytes
```
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);}
```
### Breakdown
```
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
}
```
Relies on `time` returning number of seconds since 01/01/1970, which is the case for me (using Clang/GCC on macOS) and should be the case for most UNIX stuff.
Uses ~~bash~~ terminal escape sequences to move the cursor around (`<esc>[1A` moves the cursor up 1 line). It would be nicer to be able to simply use `\r`, but `printf` won't flush until it sees a newline, and flushing it manually takes a lot more.
Probably the most CPU intensive countdown I've ever seen. Runs in a hot loop to make sure it's always as accurate as can be. If run after the deadline, it will produce some pretty weird stuff (negatives everywhere!)
[Answer]
# C#, 128 127 Bytes
```
using System;class P{static void Main(){for(;;)Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}");}}
```
Ungolfed code:
```
using System;
class P
{
    static void Main()
    {
        for(;;)
            Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}"); 
    }
}
```
I would not have figured out the \r trick without help from the other C# answers here.
For anyone looking for further improvement, you can also put the Write() expression inside the for loop. Seems like I should be able to save a byte somehow here, because that saves me the semi-colon for that statement, but it works out to the same number because you can't have a fully empty body:
```
using System;class P{static void Main(){for(;;Console.Write($"\r{new DateTime(2019,3,31)-DateTime.Now:ddd\\:hh\\:mm\\:ss}"));}}
```
[Answer]
## Ruby (83 bytes)
```
loop{h=431664-Time.now.to_r/3600;$><<['%02d']*4*?:%[h/24,h%24,h%1*60,h*3600%60]+?\r}
```
## Ungolfed
```
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
```
Basically one of the Python submissions, with some improvements. We just emit an "\r" to go beginning of the string before re-rendering. And for the string format of `"%03d:%02d:%02d:%02d"`, we really don't care about the width on the first specifier… so we can just do `"%02d"*4`, and emit a backspace and a space to clear the extra unnecessary colon.
Also, I found a two-character shorter `print`: `$><<`. `$>` is a shorthand global for `$defout`, which is the output stream for `print` and `printf` and defaults to `STDOUT`. `IO#<<` writes the right hand side of it to the stream. How is that two characters shorter? Well, I can now omit the space that led before the parenthesis wrapping the format string.
At this point I genuinely think there is no possible way to shorten this program further in Ruby.
Edit: I was wrong. Instead of the first `Time.new(2019,3,31)`, we can just use the raw UNIX time: `1553990400`.
Edit 2: I've tried playing around with factoring out minutes, and dividing the UNIX timestamp by that constant, but it doesn't actually wind up saving any bytes. :(
Edit 3: Turns out caching `h=3600` actually hurt me by two bytes. Whoops.
Edit 4: Saved 3 bytes thanks to @EricDuminill. He used floats, but rationals work without loss of precision!
Edit 5: `Array#*` as an alias for `Array#join`, with the Ruby `?`-syntax for individual characters!
[Answer]
## JavaScript+HTML, 136+7=143 bytes
```
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
```
[Answer]
# C#, 142 bytes
```
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;}}
```
Ungolfed program:
```
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;
    }
}
```
[Answer]
# Bash + GNU date, 128 bytes
*2 bytes shaved off thanks to @muru, and 2 off earlier thanks to @This Guy.*
```
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
```
### Ungolfed
```
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
```
[Answer]
# [Phooey](https://github.com/ConorOBrien-Foxx/Phooey), 101 bytes
```
-1(>"`\e`[H"~t/1000;1554004800@%60>&/60@%60>&/60@%24>&/24@@/100{$i}&/10{$i}&$i<(_1":"@/10{$i}&$i<)"
"#1)
```
`\e` represents the `ESC` nonprintable, hex `0x1B`. Requires your average Linux terminal (and I believe it may work on Windows with a recent command prompt). Phooey does not support C-style escapes, the bytes must be verbatim or you must use `$cN`.
```
-1            # set sentinel cell
(             # do {..} while (*cell) (infinite loop)
  >           #   move past our sentinel
  "`\e`[H"     #   print "clear" ANSI escape code
  ~t          #   get current Unix time in milliseconds
  /1000       #   convert to seconds
  ;1554004800 #   31 Mar 2019 in Unix time - *cell
  @           #   Push a copy
  %60         #   Store seconds in the first cell
  >&          #   Move to the next cell
  /60         #   Convert to minutes
  @           #   Push a copy
  %60         #   Store minutes in the second cell
  >&/60@%24>  #   ya get the point
  &/24        #   get the number of days
  @@          #   begin ugly zero pad code
  /100{$i}    #   if intdiv(days, 100) == 0, print 0
  &/10{$i}    #   repeat for tens place
  &$i         #   print value
  <           #   go to hours place 
  (_1         #   do {..} while not -1 (our sentinel)
    ":"       #     print ":"
    @/10{$i}  #     zero pad
    &$i       #     print digit
    <         #     go to prev cell
  )           #   loop till sentinel
  "`\n`"       #   print new line to flush stdout
  #1          #   wait one second otherwise your terminal will flip out
)             # loop forever 
```
It does fail miserably for dates after Brexit thanks to signed division lul:
```
-689:0-8:-44:-37
```
But for dates before Brexit, it is correct.
For a version which sets to zero after Brexit, (at the cost of a memory leak and 9 bytes), here you go:
```
-1(>"`\e`[H"~t/1000;1554004800**@@&2^{@}&**@%60>&/60@%60>&/60@%24>&/24@@/100{$i}&/10{$i}&$i<(_1":"@/10{$i}&$i<)"
"#1)
```
Specifically, this code uses some fancy math to check for negative.
```
@@&2^{@}&
```
(Or `*@` to patch the memory leak which pops, multiplies by zero, then pushes)
It uses the `pow` operator.
Specifically, `^` does this:
```
    *cell = (int64_t)pow(*cell, op);
```
So, in equivalent C, this code would be:
```
int64_t positive_or_zero(int64_t val)
{
    int64_t pwr = (int64_t)pow(2, val);
    if (pwr == 0) {
        val = pwr;
    }
    return val;
}
```
`pow` is a function which accepts and returns `double`, however, we downcast this.
People who are familiar with how double conversion works will know that infinity converts to `0x8000000000000000`, and fractions between 0 and 1 will be zero.
Additionally, \${2}^{x}\$ will always be a number greater than 1 if \$x >= 0\$, and a positive fraction less than 1 if \$x < 0\$.
Therefore, if `^` returns 0, we know that \$x\$ is negative. Then, we just push it to the stack.
[Answer]
# 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](https://matl.io/?code=737515%60tZ%27-tkwy-%27%3AHH%3AMM%3ASS%27XOw%27%2503d%27YDwYcDT%26XxT&inputs=&version=20.9.1)!
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](https://matl.io/?code=737515%60tZ%27-tkwy-%27%3AHH%3AMM%3ASS%27XOw%27%2503d%27YDwYcDT%26XxT&inputs=&version=20.9.1)
`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
```
[Answer]
# 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.
[Answer]
# 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.
[Answer]
# [SlimSharp](https://github.com/jcoehoorn/SlimSharp), 56 bytes
```
for(;;)P($"{TP("2019-3-31")-T.Now:ddd\\:hh\\:mm\\:ss}");
```
[Answer]
# 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 :)
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 78 bytes
```
BEGIN{for(;v=1552953600-systime();printf"\r%d:%s",v/86400,strftime("%T",v)){}}
```
[Try it online!](https://tio.run/nexus/awk#@@/k6u7pV52WX6RhXWZraGpqZGlqbGZgoFtcWVySmZuqoWldUJSZV5KmFFOkmmKlWqykU6ZvYWZiYKBTXFKUBlaipBoCFNXUrK6t/f8fAA "AWK – TIO Nexus")
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.
[Answer]
# 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.
[Answer]
# 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();
  }
}
```
]