Eh bien, le Brexit est arrivé . Et Sky News, étant les génies qu'ils sont, a décidé de créer un compte à rebours sur le côté d'un bus.

Votre travail consiste à faire quelque chose de similaire. Le Royaume-Uni quitte l'UE le 31 mars 2019 et vous devez créer un compte à rebours numérique qui change chaque seconde (avec un écart de 0,05 seconde autorisé).

Contribution

Votre programme ne devrait accepter aucune contribution. C'est interdit!

Sortie

Il devrait afficher le temps jusqu'au Brexit au format ddd:hh:mm:ss. Les sauts de ligne de début et de fin sont autorisés, mais l'affichage doit rester au même endroit à chaque fois. Il devrait ressembler à une diminution en place. Comme l'a souligné @AnthonyPham, cela ne signifie pas imprimer suffisamment de nouvelles lignes pour «effacer» l'écran, cela signifie que vous devez réellement effacer l'écran.

Une sortie comme celle-ci n'est pas autorisée:

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

Ce n'est pas non plus

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

car ils sont sur plusieurs lignes.

Vous n'avez pas à vous inquiéter après le Brexit. Votre programme n'a qu'à fonctionner jusqu'au 31/03/2019

Règles

• Les failles standard sont interdites
• C'est le code-golf donc le code le plus court en octets gagne.
• Les messages d'erreur (bien que je ne sache pas comment) sont interdits
• Le code devrait pouvoir être exécuté dans 2 ans (lorsque le Royaume-Uni quitte l'UE) et devrait afficher l'heure réelle et ne pas recommencer à partir de 730 (voir ci-dessous)

Règle de compte à rebours

Le compte à rebours ne doit pas être codé en dur et doit pouvoir s'exécuter à tout moment avant la fin du Brexit et toujours produire le résultat correct. Lorsqu'une nouvelle journée commence, l'heure doit suivre le format ci-dessous

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

Permettez-moi de répéter que la date de fin du Brexit est le 31/3/2019 à minuit pour plus de commodité (31: 3: 19 00:00:00 ou 31: 3: 2019 00:00:00 ou tout autre format que vous souhaitez)

NB: Je pense que j'ai tout mais je n'ai pas posté ça dans le Sandbox, sinon le timing aurait pu être décalé. N'hésitez pas à poster des suggestions d'amélioration car ce n'est pas parfait.

JavaScript, 134 129 113 octets

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

Edit: sauvé 2 octets grâce à @Shaggy. 11 octets enregistrés grâce à @ l4m2.

PowerShell, 70 63 55 53 octets

Double guillemets exclus, facile -2 grâce à @Joey

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

L'exécution de ceci avec sommeil ajoute 8 octets, mais l'entrée est surtout invisible si elle est exécutée sans eux, version (63 octets) avec sommeil:

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

for() est une boucle infinie, et dans cette boucle ..

cls pour effacer l'écran,

obtenir en 31/3/19tant DateTimequ'objet, et -la date actuelle de celui-ci, pour donner le temps restant, puis .ToString()( |% T*) avec le format correct.

cela affichera un temps négatif après le brexit.

Excel VBA, 91 84 82 octets

^{Enregistré 7 octets grâce à JoeMalpass soulignant qu'Excel considère les dates comme des nombres.
Enregistré 2 octets grâce à JoeMalpass}

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

La sortie est vers la cellule A1de la feuille Excel active.

Python 3.6, 146 octets

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 octets

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

16 octets enregistrés grâce à @Bob 6 octets enregistrés grâce à @ Søren D. Ptæus

Version formatée:

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 octets

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

Merci à @Fels pour le référencement Math, @dgrcode pour le référencementconsole

Non 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 octets

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

Assez simple. 1553990400 est l'horodatage du 31-3-2019 00:00:00 en UTC. Il boucle indéfiniment, en utilisant DateTime-> diff () -> format () pour afficher le temps restant. Après le Brexit, il commencera à compter à partir de 0.

Version commentée / plus lisible:

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

7 octets enregistrés en convertissant au format d'heure différemment

Enregistré 3 octets grâce aux suggestions de Martin Ender

Enregistré 2 octets en utilisant un retour chariot au lieu d'espaces arrière

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

Ne peut pas être exécuté sur TIO pour des raisons évidentes.

Il réécrit constamment l'affichage dans une boucle infinie de sorte que le texte clignote (au moins dans ma console), bien qu'il ne mette à jour l'heure qu'une fois par seconde.

Cette version de 70 octets n'imprime qu'une fois par seconde:

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

Explication

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

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 octets

Merci à Bob d' avoir économisé 57 octets!

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

Programme non 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 octets

Merci à Bob d' avoir enregistré encore 47 octets!

Merci à Martin Smith d' avoir économisé 4 octets!

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

Programme non 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 octets

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

Panne

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
}

Repose sur time nombre de secondes depuis le 01/01/1970, ce qui est le cas pour moi (en utilisant Clang / GCC sur macOS) et devrait être le cas pour la plupart des trucs UNIX.

Utilise les séquences d'échappement du terminal bash pour déplacer le curseur ( <esc>[1Adéplace le curseur d'une ligne vers le haut). Ce serait plus agréable de pouvoir simplement utiliser \r, maisprintf ne videra pas tant qu'il ne verra pas de nouvelle ligne, et le vider manuellement en prendra beaucoup plus.

Probablement le compte à rebours le plus intensif que j'ai jamais vu. Fonctionne dans une boucle chaude pour s'assurer qu'il est toujours aussi précis que possible. S'il est exécuté après la date limite, il produira des trucs assez étranges (négatifs partout!)

AHK , 145 octets

Ce n'est pas la réponse la plus courte mais le résultat donne une très belle sensation de malheur, je pense. À l'origine, j'ai essayé d'envoyer les touches Ctrl+ Asuivies de DELl'heure, mais quelle que soit l'heure, mais le taux de rafraîchissement était trop lent et cela détruirait l'environnement dans lequel vous vous trouviez. Au lieu de cela, j'ai opté pour l'interface graphique. Il s'est avéré qu'il fallait moins d'octets pour détruire complètement la fenêtre et la recréer que pour mettre à jour le contrôle encore et encore, donc je suis allé avec ça. C'est un bel effet.

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 octets

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

Code non golfé:

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

Je n'aurais pas compris l'astuce \ r sans l'aide des autres réponses C # ici.

Pour ceux qui recherchent une amélioration supplémentaire, vous pouvez également placer l'expression Write () dans la boucle for. Il semble que je devrais pouvoir enregistrer un octet d'une manière ou d'une autre ici, car cela me permet d'économiser le point-virgule pour cette déclaration, mais cela fonctionne au même nombre car vous ne pouvez pas avoir un corps entièrement vide:

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

Rubis (83 octets)

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

Non 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

Fondamentalement, l'une des soumissions Python, avec quelques améliorations. Nous émettons juste un "\ r" pour aller au début de la chaîne avant de re-rendre. Et pour le format de chaîne de "%03d:%02d:%02d:%02d", nous ne nous soucions vraiment pas de la largeur sur le premier spécificateur… donc nous pouvons simplement faire"%02d"*4 , et émettre un retour arrière et un espace pour effacer les deux points inutiles supplémentaires.

De plus, je trouve un court deux caractères print: $><<. $>est un raccourci global pour $defout, qui est le flux de sortie pour printet printfet par défaut STDOUT. IO#<<écrit le côté droit de celui-ci dans le flux. Comment ces deux caractères sont-ils plus courts? Eh bien, je peux maintenant omettre l'espace qui menait avant la parenthèse enveloppant la chaîne de format.

À ce stade, je pense sincèrement qu'il n'y a aucun moyen possible de raccourcir davantage ce programme dans Ruby.

Edit: j'avais tort. Au lieu de la première Time.new(2019,3,31), nous pouvons simplement utiliser le temps UNIX brut: 1553990400.

Edit 2: J'ai essayé de jouer avec la factorisation des minutes et la division de l'horodatage UNIX par cette constante, mais cela ne permet pas d'économiser d'octets. :(

Edit 3: Désactive la mise en cache h=3600 en m'a fait du mal de deux octets. Oups.

Edit 4: 3 octets enregistrés grâce à @EricDuminill. Il a utilisé des flotteurs, mais les rationnels fonctionnent sans perte de précision!

Edit 5: Array#*comme alias pour Array#join, avec la ?syntaxe Ruby pour les personnages individuels!

JavaScript + HTML, 136 + 7 = 143 octets

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 octets

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

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

Date Bash + GNU, 128 octets

2 octets rasés grâce à @muru, et 2 plus tôt grâce à @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

Non 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 octets

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

TIO ne prend apparemment pas en charge l'effacement de la sortie, mais heureusement MATL Online le fait !

À 2 octets de plus, une version un peu plus conviviale du processeur qui fait un pause(sommeil) chaque seconde:

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

Essayez ceci sur MATL Online

737515est le "31 mars 2019" représente le format d'époque par défaut de MATLAB - nombre de jours à partir du 0 janvier 0000, comprenant éventuellement une partie fractionnaire pour représenter l'heure de la journée. (J'ai essayé de raccourcir cela en le calculant d'une manière ou d'une autre, mais ses seuls facteurs sont 5 et un autre nombre à six chiffres (147503), et je n'ai pas pu trouver un moyen de le faire en moins de 6 octets.)

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

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

Cela comptera exactement jusqu'à ce que 0:00:00:00puis pause / sortie. Courez avec -r.

-2 octets si je n'aurais pas à imprimer le 0.

RPL, 83 78 octets

En supposant que votre HP48, ou similaire, est configuré avec l'heure et la date (UK) correctes, le format de date mm / jj et le format d'heure 24h:

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

J'ai été surpris de pouvoir économiser 2 octets en supprimant les espaces autour ":". 1.1 est la date valide la plus courte, ultérieurement vidée par SUB. Soyez prudent avec les émulateurs, le temps peut courir plus vite ou plus lentement (ou pas du tout) que votre horloge murale. Avec un vrai HP, vous pouvez arrêter ce programme en appuyant sur la touche ON… ou attendre que les piles soient vides.

PHP, 102 95 90 octets

7 octets enregistrés grâce à @TheLethalCoder et en ne prenant pas en compte

Enregistré encore 5 octets en concaténant

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

C'est mon premier golf, donc il me manque probablement pas mal de tours, mais ici vous êtes malgré tout.

Quant à la réponse PHP de @chocochaos qui l'emporterait autrement, je pense qu'elle est défectueuse pour les raisons que j'ai expliquées dans mes commentaires, mais comme je suis nouveau ici, je peux me tromper. Ou je suis juste un débutant :)

AWK , 78 octets

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

Essayez-le en ligne!

C'était plus longtemps avant de réaliser que je pouvais précalculer l'heure de fin. Parfois, il vaut la peine d'être un peu en retard et d'avoir des idées des autres.

Pour info, le lien TIO ne fonctionne pas très bien, car il ne s’implémente pas \rcorrectement.

F #, 142 octets

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

J'ai grandi en Irlande à environ un demi-kilomètre de la frontière. À part un panneau "Bienvenue à Fermanagh" et le changement des marquages ​​routiers, vous ne sauriez pas que vous êtes entré dans un autre pays. Utilisé pour le traverser deux fois sur le chemin de l'école.

c, gcc 114 octets

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

Rien d'omis, programme complet. Le programme se compile en gcc sur Ubuntu. Le compte à rebours n'affichera pas une longue traînée d'instructions d'impression en raison de l'appel système à effacer et s'arrête lorsque le compte à rebours atteint 0 seconde.

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