Bueno, sucedió Brexit . Y Sky News, siendo los genios que son, han decidido crear una cuenta regresiva al costado de un autobús.

Tu trabajo es hacer algo similar. El Reino Unido abandona la UE el 31 de marzo de 2019 y debe crear una cuenta regresiva digital para esto que cambia cada segundo (con una desviación de 0.05 segundos permitida).

Entrada

Su programa no debe tener absolutamente ninguna entrada. Está prohibido!

Salida

Debería mostrar el tiempo hasta Brexit en el formato ddd:hh:mm:ss. Se permiten nuevas líneas iniciales y finales, pero la pantalla debe permanecer en el mismo lugar cada vez. Debería parecer que en realidad está disminuyendo en su lugar. Como señaló @AnthonyPham, esto no significa imprimir suficientes líneas nuevas para "borrar" la pantalla, esto significa que en realidad debe borrar la pantalla.

Una salida como esta no está permitida:

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

Tampoco es esto

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

ya que están en más de una línea.

No tiene que preocuparse después de Brexit. Su programa solo tiene que funcionar hasta el 31/3/2019

Reglas

• Las lagunas estándar no están permitidas
• Este es el código de golf, por lo que el código más corto en bytes gana.
• Los mensajes de error (aunque no puedo pensar cómo) no están permitidos
• El código debe poder ejecutarse dentro de 2 años (cuando el Reino Unido abandone la UE) y debe mostrar la hora real y no comenzar desde 730 nuevamente (ver más abajo)

Regla de cuenta regresiva

La cuenta regresiva no debe estar codificada y debe poder ejecutarse en cualquier momento antes de que Brexit termine y aún así producir el resultado correcto. Cuando comienza un nuevo día, la hora debe seguir el siguiente formato

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

Permítanme decirlo nuevamente, la fecha de finalización del Brexit es el 31/3/2019 a medianoche por conveniencia (31: 3: 19 00:00:00 o 31: 3: 2019 00:00:00 o cualquier otro formato que desee)

NB: Creo que tengo todo, pero no publiqué esto en el Sandbox, de lo contrario, el momento podría haber sido inactivo. Siéntase libre de publicar cualquier sugerencia de mejora porque no es perfecta.

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: Guardado 2 bytes gracias a @Shaggy. Guardado 11 bytes gracias a @ l4m2.

PowerShell, 70 63 55 53 Bytes

Excluidas comillas dobles, fácil -2 gracias a @Joey

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

Ejecutar esto con suspensión agrega 8 bytes, pero la entrada es mayormente invisible si se ejecuta sin ellos, versión (63 bytes) con suspensión:

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

for() es un bucle infinito, y dentro de ese bucle ...

cls para limpiar la pantalla,

obtener 31/3/19como un DateTimeobjeto, y -la fecha actual a partir de él, para dar el tiempo restante, luego .ToString()( |% T*) con el formato correcto.

Esto mostrará un tiempo negativo después del brexit.

Excel VBA, 91 84 82 bytes

^{Guardado 7 bytes gracias a JoeMalpass que señala que Excel ve las fechas como números.
Guardado 2 bytes gracias a JoeMalpass}

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

La salida es a la celda A1en la hoja de Excel activa.

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

Guardado 16 bytes gracias a @Bob Guardado 6 bytes gracias a @ Søren D. Ptæus

Versión formateada:

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

Gracias a @Fels por hacer referencia Math, @dgrcode por hacer referenciaconsole

Sin golf

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 sencillo. 1553990400 es la marca de tiempo para 31-3-2019 00:00:00 en UTC. Se repite infinitamente, usando DateTime-> diff () -> format () para mostrar cuánto tiempo queda. Después de que Brexit haya sucedido, comenzará a contar desde 0.

Versión comentada / más legible:

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

Guardado 7 bytes al convertir a formato de hora de manera diferente

Guardado 3 bytes gracias a las sugerencias de Martin Ender

Se guardaron 2 bytes utilizando un retorno de carro en lugar de espacios de retroceso

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

No se puede ejecutar en TIO por razones obvias.

Reescribe la pantalla constantemente en un bucle infinito para que el texto parpadee (al menos en mi consola), aunque en realidad solo actualiza el tiempo una vez por segundo.

Esta versión de 70 bytes solo se imprime una vez por segundo:

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

Explicación

{                           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

¡Gracias 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 sin golf:

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

¡Gracias a Bob por guardar otros 47 bytes!

¡Gracias a Martin Smith por guardar 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 sin golf:

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

Descompostura

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
}

Se basa en timedevolver el número de segundos desde el 01/01/1970, que es el caso para mí (usando Clang / GCC en macOS) y debería ser el caso para la mayoría de las cosas de UNIX.

Usos secuencias de escape de terminal bash para mover el cursor ( <esc>[1Amueve el cursor hacia arriba 1 línea). Sería mejor poder usarlo simplemente \r, pero printfno se enjuagará hasta que vea una nueva línea, y enjuagarlo manualmente requiere mucho más.

Probablemente la cuenta regresiva más intensiva de CPU que he visto. Se ejecuta en un bucle dinámico para asegurarse de que siempre sea lo más preciso posible. Si se ejecuta después de la fecha límite, producirá algunas cosas bastante extrañas (¡negativos en todas partes!)

AHK , 145 bytes

Esta no es la respuesta más corta, pero el resultado da una muy buena sensación de fatalidad, creo. Originalmente traté de enviar las pulsaciones de teclas Ctrl+ Aseguido de DELy luego, sea cual sea el momento, pero la frecuencia de actualización era demasiado lenta y destruiría cualquier entorno en el que estuvieras. En su lugar, fui con la GUI. Resultó tomar menos bytes para destruir completamente la ventana y recrearla de lo que hizo para actualizar el control una y otra vez, así que seguí con eso. Es un lindo efecto.

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 sin golf:

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

No habría descubierto el truco sin la ayuda de las otras respuestas de C # aquí.

Para cualquiera que busque una mejora adicional, también puede poner la expresión Write () dentro del ciclo for. Parece que debería poder guardar un byte de alguna manera aquí, porque eso me ahorra el punto y coma para esa declaración, pero funciona al mismo número porque no puedes tener un cuerpo completamente vacío:

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

Rubí (83 bytes)

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

Sin golf

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

Básicamente una de las presentaciones de Python, con algunas mejoras. Simplemente emitimos un "\ r" para ir al principio de la cadena antes de volver a renderizar. Y para el formato de cadena de "%03d:%02d:%02d:%02d", realmente no nos importa el ancho en el primer especificador ... así que podemos hacerlo "%02d"*4, y emitir un retroceso y un espacio para borrar los dos puntos innecesarios adicionales.

Además, he encontrado un número de dos caracteres más corta print: $><<. $>es una taquigrafía global para $defout, que es la secuencia de salida para printy, printfy por defectoSTDOUT . IO#<<escribe el lado derecho de la misma en la secuencia. ¿Cómo son esos dos caracteres más cortos? Bueno, ahora puedo omitir el espacio que conducía antes del paréntesis envolviendo la cadena de formato.

En este punto, realmente creo que no hay forma posible de acortar más este programa en Ruby.

Editar: estaba equivocado. En lugar de la primeraTime.new(2019,3,31) , podemos simplemente usar el tiempo UNIX prima: 1553990400.

Edición 2: He intentado jugar con la factorización de minutos y dividir la marca de tiempo de UNIX por esa constante, pero en realidad no termina guardando ningún byte. :(

Edición 3: Resulta el almacenamiento en caché h=3600 en realmente me hirió por dos bytes. Whoops

Edición 4: Guardado 3 bytes gracias a @EricDuminill. ¡Utilizó flotadores, pero los racionales funcionan sin pérdida de precisión!

Edición 5: Array#*como un alias para Array#join, con la ?sintaxis de Ruby para caracteres individuales.

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 sin golf:

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 + fecha GNU, 128 bytes

2 bytes recortados gracias a @muru y 2 antes gracias 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

Sin golf

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

Aparentemente, TIO no admite borrar la salida, pero afortunadamente, MATL Online sí .

Con 2 bytes más, una versión un poco más amigable con la CPU que hace un pause(reposo) cada segundo:

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

Prueba esto en MATL Online

737515el "31 de marzo de 2019" representa el formato de época predeterminado de MATLAB: número de días desde el 0 de enero de 0000, que incluye opcionalmente una parte fraccionaria para representar la hora del día. (Intenté acortar esto al calcularlo de alguna manera, pero sus únicos factores son 5 y otro número de seis dígitos (147503), y no pude encontrar una manera de hacerlo en 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);

Esto contará exactamente hasta 0:00:00:00y luego romper / salir. Corre con -r.

-2 bytes si no tuviera que imprimir el 0.

RPL 83 78 bytes

Asumiendo que su HP48, o similar, está configurada con la hora y fecha correctas (Reino Unido), formato de fecha mm / dd y formato de 24 horas:

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

Me sorprendió poder ahorrar 2 bytes eliminando espacios alrededor ":". 1.1 es la fecha de validez más corta, luego volcada SUB. Tenga cuidado con los emuladores, el tiempo puede correr más rápido o más lento (o nada) que su reloj de pared. Con un HP real, puede detener este programa presionando la tecla ON ... o esperar a que se agoten las baterías.

PHP, 102 95 90 bytes

Guardado 7 bytes gracias a @TheLethalCoder y al no factorizar

Se guardaron otros 5 bytes concatenando

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

Este es mi primer golf, por lo que probablemente me faltan algunos trucos, pero aquí estás de todos modos.

En cuanto a la respuesta PHP de @chocochaos que de otro modo superaría esto, creo que es defectuoso por las razones que he explicado en mis comentarios, pero como soy nuevo aquí, podría estar equivocado. O solo soy un novato :)

AWK , 78 bytes

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

Pruébalo en línea!

Pasó más tiempo antes de darme cuenta de que podía calcular previamente el tiempo final. A veces vale la pena llegar un poco tarde al juego y obtener ideas de otros.

Para su información, el enlace TIO no funciona muy bien, ya que no se implementa \rcorrectamente.

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

Crecí en Irlanda a medio kilómetro de la frontera. Aparte de un cartel de "Bienvenido a Fermanagh" y el cambio de las marcas viales, no sabría que ha entrado en otro país. Solía ​​cruzarlo dos veces camino a la escuela.

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. El programa se compila en gcc en Ubuntu. La cuenta regresiva no mostrará una larga pista de declaraciones de impresión debido a la llamada del sistema para borrar y se detiene cuando la cuenta regresiva llega a 0 segundos.

Sin golf

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