Bene, la Brexit è successa . E Sky News, essendo i geni che sono, hanno deciso di creare un conto alla rovescia sul lato di un autobus.

Il tuo compito è fare qualcosa di simile. Il Regno Unito lascia l'UE il 31 marzo 2019 e devi creare un conto alla rovescia digitale per questo che cambia ogni secondo (con una deviazione di 0,05 secondi consentita).

Ingresso

Il tuo programma non dovrebbe ricevere assolutamente alcun input. È vietato!

Produzione

Dovrebbe essere emesso il tempo fino a Brexit nel formato ddd:hh:mm:ss. Sono consentite nuove righe iniziali e finali, ma il display dovrebbe rimanere sempre nello stesso posto. Dovrebbe sembrare che stia effettivamente diminuendo sul posto. Come sottolineato da @AnthonyPham, ciò non significa stampare abbastanza righe per "cancellare" lo schermo, ciò significa che è necessario cancellare lo schermo.

Un output come questo non è consentito:

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

Neanche questo

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

poiché sono su più di una riga.

Non devi preoccuparti dopo la Brexit. Il tuo programma deve funzionare solo fino al 31/03/2019

Regole

• Le scappatoie standard non sono ammesse
• Questo è code-golf, quindi vince il codice più breve in byte .
• I messaggi di errore (anche se non riesco a pensare come) non sono consentiti
• Il codice dovrebbe essere in grado di essere eseguito tra 2 anni (quando il Regno Unito lascia l'UE) e dovrebbe visualizzare l'ora effettiva e non ricominciare da 730 (vedi sotto)

Conto alla rovescia

Il conto alla rovescia non dovrebbe essere hardcoded e dovrebbe poter essere eseguito in qualsiasi momento prima che Brexit finisca e produca comunque il risultato corretto. Quando inizia un nuovo giorno, l'ora dovrebbe seguire il formato seguente

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

Lasciami dire ancora, la data in cui Brexit termina è il 31/03/2019 a mezzanotte per comodità (31: 3: 19 00:00:00 o 31: 3: 2019 00:00:00 o qualsiasi altro formato che desideri)

NB: Penso di avere tutto ma non l'ho pubblicato nella Sandbox, altrimenti i tempi avrebbero potuto essere scaduti. Sentiti libero di pubblicare qualsiasi suggerimento per miglioramenti perché non è perfetto.

JavaScript, 134 129 113 byte

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

Modifica: salvato 2 byte grazie a @Shaggy. Risparmiato 11 byte grazie a @ l4m2.

PowerShell, 70 63 55 53 byte

Virgolette doppie escluse, facile -2 grazie a @Joey

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

L'esecuzione con sleep aggiunge 8 byte, ma l'input è per lo più invisibile se viene eseguito senza di essi, versione (63 byte) con sleep:

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

for() è un ciclo infinito, e all'interno di quel ciclo ..

cls per cancellare lo schermo,

ottenere 31/3/19come DateTimeoggetto e -la data corrente da esso, per dare il tempo rimanente, quindi .ToString()( |% T*) quello con il formato corretto.

questo visualizzerà tempo negativo dopo brexit.

Excel VBA, 91 84 82 byte

^{Salvato 7 byte grazie a JoeMalpass sottolineando che Excel vede le date come numeri.
Salvato 2 byte grazie a JoeMalpass}

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

L'output è nella cella A1nel foglio Excel attivo.

Python 3.6, 146 byte

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 byte

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

Salvato 16 byte grazie a @Bob Salvato 6 byte grazie a @ Søren D. Ptæus

Versione formattata:

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 byte

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

Grazie a @Fels per i riferimenti Math, @dgrcode per i riferimenticonsole

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

});

PHP, 84 byte

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

Abbastanza semplice. 1553990400 è il timestamp per il 31-3-2019 00:00:00 in UTC. Fa un ciclo infinito, usando DateTime-> diff () -> format () per produrre quanto tempo è rimasto. Dopo che è avvenuta la Brexit, inizierà a contare da 0.

Versione commentata / più leggibile:

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

Salvato 7 byte convertendo in formato orario in modo diverso

Salvato 3 byte grazie ai suggerimenti di Martin Ender

Salvato 2 byte utilizzando un ritorno a capo invece di backspaces

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

Non può essere eseguito su TIO per ovvi motivi.

Riscrive costantemente il display in un ciclo infinito, quindi il tipo di testo lampeggia dentro e fuori (almeno nella mia console), anche se in realtà aggiorna il tempo solo una volta al secondo.

Questa versione da 70 byte stampa solo una volta al secondo:

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

Spiegazione

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

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 byte

Grazie a Bob per aver salvato 57 byte!

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

Programma non golfato:

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 byte

Grazie a Bob per aver salvato altri 47 byte!

Grazie a Martin Smith per aver salvato 4 byte!

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

Programma non golfato:

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 byte

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

Abbattersi

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
}

Si basa sul timeritorno del numero di secondi dall'01 / 01/1970, che è il caso per me (usando Clang / GCC su macOS) e dovrebbe essere il caso per la maggior parte delle cose UNIX.

Utilizza le sequenze di escape del terminale bash per spostare il cursore ( <esc>[1Asposta il cursore in alto di 1 riga). Sarebbe più bello poter semplicemente usare \r, ma printfnon scaricherà fino a quando non vedrà una nuova riga e scaricarlo manualmente richiederà molto di più.

Probabilmente il conto alla rovescia più intenso della CPU che abbia mai visto. Funziona in un ciclo caldo per assicurarsi che sia sempre il più preciso possibile. Se eseguito dopo la scadenza, produrrà alcune cose piuttosto strane (negativi ovunque!)

AHK , 145 byte

Questa non è la risposta più breve ma il risultato dà una bella sensazione di sventura, credo. Inizialmente ho provato a inviare i tasti Ctrl+ Aseguiti da DELe poi qualunque fosse il tempo, ma la frequenza di aggiornamento era troppo lenta e avrebbe distrutto qualsiasi ambiente in cui ti trovavi. Invece, sono andato con la GUI. Si è scoperto che impiegava meno byte per distruggere completamente la finestra e ricrearla di quanto non facesse per aggiornare il controllo più e più volte, quindi sono andato con quello. È un bell'effetto.

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 byte

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

Codice non golfato:

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

Non avrei capito il trucco senza l'aiuto delle altre risposte C # qui.

Per chiunque cerchi ulteriori miglioramenti, puoi anche inserire l'espressione Write () all'interno del ciclo for. Sembra che dovrei essere in grado di salvare un byte in qualche modo qui, perché ciò mi fa risparmiare i punti e virgola per quella dichiarazione, ma funziona allo stesso numero perché non puoi avere un corpo completamente vuoto:

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

Rubino (83 byte)

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

Fondamentalmente uno degli invii di Python, con alcuni miglioramenti. Emettiamo semplicemente un "\ r" per iniziare la stringa prima del nuovo rendering. E per il formato stringa di "%03d:%02d:%02d:%02d", in realtà non ci interessa la larghezza del primo identificatore ... quindi possiamo semplicemente fare "%02d"*4, ed emettere un backspace e uno spazio per cancellare i due punti non necessari extra.

Inoltre, ho trovato una due caratteri più breve print: $><<. $>è una scorciatoia globale per $defout, che è il flusso di output di printe per printfimpostazione predefinita STDOUT. IO#<<scrive il lato destro di esso nel flusso. In che modo i due personaggi sono più brevi? Bene, ora posso omettere lo spazio che ha preceduto la parentesi che avvolge la stringa di formato.

A questo punto penso sinceramente che non ci sia modo di accorciare ulteriormente questo programma in Ruby.

Modifica: ho sbagliato. Al posto della prima Time.new(2019,3,31), possiamo semplicemente usare il tempo UNIX prima: 1553990400.

Modifica 2: ho provato a giocare con i minuti di factoring e a dividere il timestamp UNIX per quella costante, ma in realtà non finisce per salvare alcun byte. :(

Modifica 3: Si scopre che la cache h=3600mi fa davvero male di due byte. Ops.

Modifica 4: 3 byte salvati grazie a @EricDuminill. Ha usato i galleggianti, ma i razionali funzionano senza perdita di precisione!

Modifica 5: Array#*come alias per Array#join, con la ?sintassi Ruby per i singoli personaggi!

JavaScript + HTML, 136 + 7 = 143 byte

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 byte

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

Programma non golfato:

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 + data GNU, 128 byte

2 byte eliminati grazie a @muru e 2 in precedenza grazie 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 byte

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

Apparentemente TIO non supporta la cancellazione dell'output, ma per fortuna MATL Online lo fa !

A 2 byte in più, una versione un po 'più favorevole per la CPU che esegue un pause(sospensione) ogni secondo:

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

Prova questo su MATL online

737515è "31 marzo 2019" rappresentato il formato di epoca predefinito di MATLAB - numero di giorni a partire dallo 0 gennaio 0000, facoltativamente includendo una parte frazionaria per rappresentare l'ora del giorno. (Ho cercato di accorciarlo calcolandolo in qualche modo, ma i suoi unici fattori sono 5 e un altro numero di sei cifre (147503), e non sono riuscito a trovare un modo per farlo in meno di 6 byte.)

`    % 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 byte

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

Questo conterà esattamente fino a quando 0:00:00:00quindi si romperà / uscirà . Corri con -r.

-2 byte se non dovessi stampare lo 0.

RPL, 83 78 byte

Supponendo che l'HP48 o simile sia configurato con l'ora e la data (Regno Unito) corrette, il formato data mm / gg e il formato ora 24 ore:

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

Sono stato sorpreso di poter salvare 2 byte rimuovendo gli spazi intorno ":". 1.1 è la data di validità più breve, successivamente scaricata da SUB. Fai attenzione agli emulatori, il tempo potrebbe essere più veloce o più lento (o per niente) dell'orologio a muro. Con un vero HP, è possibile interrompere questo programma premendo il tasto ON ... o attendere batterie scariche.

PHP, 102 95 90 byte

Risparmio di 7 byte grazie a @TheLethalCoder e senza factoring

Salvati altri 5 byte concatenando

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

Questo è il mio primo golf, quindi probabilmente mi mancano alcuni trucchi, ma eccoti qui.

Per quanto riguarda la risposta PHP di @chocochaos che altrimenti avrebbe la meglio, credo che sia difettosa per le ragioni che ho spiegato nei miei commenti, ma dato che sono nuovo qui potrei sbagliarmi. O sono solo un novizio :)

AWK , 78 byte

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

Provalo online!

Passò più tempo prima che mi rendessi conto che potevo calcolare in anticipo l'orario di fine. A volte paga essere un po 'in ritardo al gioco e ottenere idee dagli altri.

Cordiali saluti, il collegamento TIO non funziona molto bene, dal momento che non si implementa \rcorrettamente.

F #, 142 byte

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

Sono cresciuto in Irlanda a circa mezzo chilometro dal confine. A parte un cartello "Benvenuti a Fermanagh" e le indicazioni stradali che cambiano non sapresti che saresti entrato in un altro paese. Usato per attraversarlo due volte sulla strada per la scuola.

c, gcc 114 byte

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

Niente omesso, programma completo. Il programma si compila in gcc su Ubuntu. Il conto alla rovescia non mostrerà una lunga scia di istruzioni di stampa a causa della chiamata di sistema per cancellare e si interrompe quando il conto alla rovescia raggiunge 0 secondi.

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