Bem, o Brexit aconteceu . E o Sky News, sendo os gênios que são, decidiu criar uma contagem regressiva ao lado de um ônibus.

Seu trabalho é fazer algo semelhante. O Reino Unido sai da UE em 31 de março de 2019 e você precisa criar uma contagem regressiva digital para isso que muda a cada segundo (com um desvio de 0,05 segundo permitido).

Entrada

Seu programa não deve receber absolutamente nenhuma entrada. Está proibido!

Saída

Ele deve exibir o tempo até o Brexit no formato ddd:hh:mm:ss. Novas linhas iniciais e finais são permitidas, mas a exibição deve permanecer no mesmo local a cada vez. Deve parecer que está realmente diminuindo no lugar. Como apontado por @AnthonyPham, isso não significa imprimir novas linhas suficientes para "limpar" a tela, isso significa que você deve realmente limpar a tela.

Uma saída como esta não é permitida:

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

Nem isso

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

como eles estão em mais de uma linha.

Você não precisa se preocupar com o Brexit. Seu programa só precisa funcionar até 31/03/2019

Regras

• As brechas padrão não são permitidas
• Este é o código-golfe, pelo que o código mais curto em bytes vence.
• Mensagens de erro (embora eu não consiga pensar como) são proibidas
• O código deve poder ser executado em 2 anos (quando o Reino Unido deixar a UE) e deve exibir a hora real e não iniciar novamente a partir de 730 (veja abaixo)

Regra de contagem regressiva

A contagem regressiva não deve ser codificada e deve poder ser executada a qualquer momento antes do Brexit terminar e ainda assim produzir o resultado correto. Quando um novo dia é iniciado, a hora deve seguir o formato abaixo

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

Deixe-me dizer novamente, a data em que o Brexit termina é 31/03/2019 à meia-noite por conveniência (31: 3: 19 00:00:00 ou 31: 3: 2019 00:00:00 ou qualquer outro formato que você quiser)

NB: Acho que tenho tudo, mas não o publiquei na Sandbox, caso contrário, o tempo poderia ter mudado. Sinta-se à vontade para postar sugestões de melhorias, pois não é perfeito.

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)

Editar: salvou 2 bytes graças a @Shaggy. Economizou 11 bytes graças a @ l4m2.

PowerShell, 70 63 55 53 bytes

Citações duplas excluídas, fácil -2 graças a @Joey

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

Executar isso com suspensão adiciona 8 bytes, mas a entrada é quase invisível se for executada sem eles, versão (63 bytes) com suspensão:

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

for() é um loop infinito e dentro desse loop ..

cls para limpar a tela

get 31/3/19como um DateTimeobjeto e -a data atual a partir dele, para fornecer o tempo restante e, em seguida, .ToString()( |% T*) com o formato correto.

isso exibirá um tempo negativo após o brexit.

Excel VBA, 91 84 82 bytes

^{Economizou 7 bytes graças a JoeMalpass, indicando que o Excel vê datas como números.
Economizou 2 bytes graças a JoeMalpass}

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

A saída é para célula A1na planilha ativa do Excel.

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

C #, 173 172 156 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}  ");}}

Guardou 16 bytes graças a @Bob Guardou 6 bytes graças a @ Søren D. Ptæus

Versão formatada:

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

Graças a @Fels pela referência Math, @dgrcode pela referênciaconsole

Sem golfe

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 bytes

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

Bastante direto. 1553990400 é o carimbo de data e hora de 31/03/2019 00:00:00 no UTC. Faz um loop infinito, usando DateTime-> diff () -> format () para gerar quanto tempo resta. Após o Brexit, ele começará a contar a partir de 0.

Versão comentada / mais legível:

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

Economizou 7 bytes convertendo para o formato da hora de maneira diferente

Economizou 3 bytes graças às sugestões de Martin Ender

2 bytes salvos usando um retorno de carro em vez de backspaces

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

Não pode ser executado no TIO por razões óbvias.

Ele reescreve a exibição constantemente em um loop infinito, para que o texto entre e saia (pelo menos no meu console), embora na verdade só atualize o tempo uma vez por segundo.

Esta versão de 70 bytes é impressa apenas uma vez por segundo:

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

Explicação

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

C # 6, 149 bytes

Agradecemos a Bob por salvar 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}");}}

Programa não destruído:

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

Agradecemos a Bob por salvar outros 47 bytes!

Obrigado a Martin Smith por economizar 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"));}}

Programa não destruído:

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

Demolir

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
}

Confia no timenúmero de segundos retornados desde 01/01/1970, que é o meu caso (usando Clang / GCC no macOS) e deve ser o caso da maioria das coisas do UNIX.

Usa seqüências de escape do terminal bash para mover o cursor ( <esc>[1Amove o cursor para cima 1 linha). Seria melhor poder usar simplesmente \r, mas printfnão liberará até que ela veja uma nova linha, e liberá-la manualmente leva muito mais.

Provavelmente a contagem regressiva mais intensiva da CPU que eu já vi. É executado em um loop quente para garantir que seja sempre o mais preciso possível. Se executado após o prazo, produzirá algumas coisas bem estranhas (negativos em todos os lugares!)

AHK , 145 bytes

Essa não é a resposta mais curta, mas o resultado dá uma sensação muito agradável de desgraça, eu acho. Originalmente, tentei enviar as teclas pressionadas Ctrl+ Aseguidas de DELe, em qualquer que fosse a hora, mas a taxa de atualização era muito lenta e destruiria qualquer ambiente em que você estivesse. Em vez disso, fui com a GUI. Acabou por demorar menos bytes para destruir completamente a janela e recriá-la do que para atualizar o controle repetidamente, então fui com isso. É um efeito legal.

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 bytes

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

Código não destruído:

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

Eu não teria descoberto o truque sem a ajuda das outras respostas C # aqui.

Para quem procura mais aprimoramentos, também pode colocar a expressão Write () dentro do loop for. Parece que eu deveria ser capaz de salvar um byte de alguma forma aqui, porque isso me poupa ponto e vírgula para essa declaração, mas funciona com o mesmo número porque você não pode ter um corpo totalmente vazio:

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

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

Basicamente, um dos envios do Python, com algumas melhorias. Nós apenas emitimos um "\ r" para iniciar o texto antes de renderizar novamente. E para o formato de string de "%03d:%02d:%02d:%02d", realmente não nos importamos com a largura do primeiro especificador ... então podemos fazê-lo "%02d"*4e emitir um backspace e um espaço para limpar os dois pontos extras desnecessários.

Além disso, eu encontrei um dois caracteres mais curto print: $><<. $>é um atalho global para $defout, que é o fluxo de saída para printe printfe padrões para STDOUT. IO#<<grava o lado direito dele no fluxo. Como esses dois caracteres são mais curtos? Bem, agora posso omitir o espaço que antecedeu o parêntese envolvendo a sequência de formatação.

Neste ponto, eu realmente acho que não há como reduzir ainda mais esse programa no Ruby.

Edit: Eu estava errado. Em vez do primeiro Time.new(2019,3,31), podemos usar apenas o tempo UNIX cru: 1553990400.

Edit 2: Tentei brincar de fatorar minutos e dividir o carimbo de data e hora do UNIX por essa constante, mas na verdade não acaba salvando bytes. :(

Editar 3: Acontece que o cache h=3600realmente me machucou por dois bytes. Ops.

Editar 4: salvou 3 bytes graças a @EricDuminill. Ele usou carros alegóricos, mas os racionais funcionam sem perda de precisão!

Editar 5: Array#*como um apelido para Array#join, com a ?sintaxe Ruby para caracteres individuais!

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

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

Programa não destruído:

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

Data do Bash + GNU, 128 bytes

2 bytes eliminados graças a @muru e 2 bytes anteriores graças a @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

MATL, 45 bytes

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

O TIO aparentemente não suporta a limpeza da saída, mas felizmente o MATL Online sim !

Com mais 2 bytes, uma versão um pouco mais compatível com a CPU que faz um pause(suspensão) a cada segundo:

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

Experimente no MATL Online

737515é "31 de março de 2019" representou o formato de época padrão do MATLAB - número de dias a partir de 0 de janeiro de 0000, incluindo opcionalmente uma parte fracionária para representar a hora do dia. (Tentei encurtar isso calculando-o de alguma forma, mas seus únicos fatores são 5 e outro número de seis dígitos (147503), e não consegui descobrir uma maneira de fazê-lo em menos de 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);

Isso vai contar exatamente até 0:00:00:00e depois interromper / sair. Corra com -r.

-2 bytes se não precisar imprimir o 0.

RPL, 83 78 bytes

Supondo que o HP48, ou similar, esteja configurado com data e hora corretas (Reino Unido), formato de data em mm / dd e formato de 24 horas:

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

Fiquei surpreso ao poder salvar 2 bytes removendo espaços ao redor ":". 1.1 é a data válida mais curta, posteriormente descartada SUB. Cuidado com os emuladores, pois o tempo pode correr mais rápido ou mais devagar (ou nem um pouco) do que o relógio de parede. Com um HP real, você pode interromper esse programa pressionando a tecla LIGAR… ou esperar as pilhas vazias.

PHP, 102 95 90 bytes

Economizou 7 bytes graças a @TheLethalCoder e por não fatorar

Salvo outros 5 bytes concatenando

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

Este é o meu primeiro golfe, então provavelmente estou perdendo alguns truques, mas aqui está você.

Quanto à resposta PHP do @chocochaos que, de outra forma, superaria isso, acredito que seja falha por razões que expliquei em meus comentários, mas como sou nova aqui, posso estar errada. Ou eu sou apenas um novato :)

AWK , 78 bytes

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

Experimente online!

Demorou mais para eu perceber que podia pré-calcular o tempo do fim. Às vezes vale a pena chegar um pouco tarde para o jogo e obter idéias de outras pessoas.

Para sua informação, o link do TIO não funciona muito bem, pois não é implementado \rcorretamente.

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

Eu cresci na Irlanda a cerca de meio quilômetro da fronteira. Além de um sinal de "Bem-vindo a Fermanagh" e as marcações da estrada mudando, você não saberia que havia entrado em outro país. Costumava atravessá-lo duas vezes a caminho da escola.

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

Nada omitido, programa completo. O programa é compilado no gcc no Ubuntu. A contagem regressiva não mostrará uma longa trilha de instruções de impressão devido à chamada do sistema para limpar e parar quando a contagem regressiva atingir 0 segundos.

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