Les ordinateurs sont partout de nos jours - dans les voitures, les trains, les planches à roulettes, même les réacteurs nucléaires. La possibilité que votre logiciel fonctionne sur un périphérique de voyage dans le temps n’est qu’une question de temps. Pouvez-vous vous en occuper? Pouvez-vous au moins le détecter?

Ta tâche:

1. Ecrivez un programme qui effectue une boucle et continue à interroger l'heure du système, afin de détecter les voyages dans le temps.
2. Si le temps avance d'un jour ou plus entre deux requêtes consécutives, c'est un voyage dans le temps. Dans ce cas, votre programme doit imprimer:
   TS TS: YYYY? You mean we're in the future?
3. Si le temps recule, de quelque montant que ce soit, entre deux requêtes consécutives, il s'agit d'un voyage dans le temps en arrière. Dans ce cas, votre programme doit imprimer:
   TS TS: Back in good old YYYY.
4. TS TSsont les horodatages avant et après le voyage dans le temps. YYYYest l'année de destination.
5. Les horodatages peuvent être de n'importe quel format, comprenant au moins l'année, le mois, le jour, l'heure, les minutes et les secondes à 4 chiffres, séparés par des chiffres non digitaux.

Limites:

1. Vous devez au moins soutenir les dates des 19e, 20e et 21e siècles.
2. Vous devez utiliser une langue qui existait avant que ce défi ne soit publié.
3. Vous devez poster vos réponses uniquement après la publication de ce défi.
4. Vous devez utiliser une langue qui existait avant que votre réponse ne soit publiée.
5. Vous ne pouvez modifier votre réponse qu'après l'avoir postée.
6. Votre programme ne doit imprimer aucune sortie autre que la sortie requise. Un occasionnel "Great Scott!" est autorisée.

C'est du code-golf. La réponse la plus courte gagne.
Les références de film pertinentes rendront probablement votre réponse trop longue, mais vous obtiendrez peut-être des votes positifs.

CJam, 118 octets

et:Tes{es_@-[TS*Set:TS*':S]\_864e5<{[1$et0="? You mean we're in the future?"N]o}|0<{[_"Back in good old "et0='.N]o}&}g

Cela ne fonctionne pas avec l'interprète en ligne.

Exemple de sortie après avoir ajusté le temps de mon ordinateur deux fois:

2015 10 21 11 2 45 1 3 -10800000 2015 10 23 11 2 45 0 5 -10800000: 2015? You mean we're in the future?
2015 10 23 11 2 53 448 5 -10800000 2015 10 21 11 2 52 0 3 -10800000: Back in good old 2015.

Python 2, 210 octets

from datetime import*
o=0
while 1:n=datetime.now();o=o or n;print"%s;%s: %s? You mean we're in the future?"%(o,n,n.year)if(n-o).days>=1else"%s;%s: Back in good old %s."%(n,o,n.year)if(n<o)else"Great Scott!";o=n

Les horodatages sont imprimés au YYYY-MM-DD HH:MM:SSformat séparé par des points-virgules. Basculé de 3 à Python 2 car il est 2 caractères plus courts à imprimer. Spams stdout avec Great Scott!pour non-temps voyageurs normaux , car il est plus facile et moins coûteux de le faire que de mettre en place une impression conditionnelle.

JavaScript (ES6), 263 octets

n=Date;o=n.now();(function g(){k=new n;j=new n(o);s=`${k} ${o} `;if(n.now()-o>86400)console.log(`${s}${k.getFullYear()}? You mean we're in the future?`);if(o-n.now()>84600){console.log(`${s}Back in good old ${k.getFullYear()}.`);}o=n.now();setTimeout(g,100);}());

Cela pourrait probablement être fait avec une réécriture pour le rendre plus efficace / plus petit.

La source:

n=Date;
o=n.now();

(function go() {
   k=new n;
   j=new n(o);
   s=`${k} ${o} `;
   if (n.now() - o > 86400) {
      console.log(`${s}${k.getFullYear()}? You mean we're in the future?`);
   }
   if (o - n.now() > 84600) {
      console.log(`${s}Back in good old ${k.getFullYear()}.`);
   }
   o=n.now()
   setTimeout(go,100);
}());

Python 3, 195

from datetime import*
n=datetime.now
p=n()
while 1:
 c=n();f=(p,c,p.year);s=(0,("%s %s: %s? You mean we're in the future?"%f,"%s %s: Back in good old %s."%f)[p.day>c.day])[p>c];p=c
 if s:print(s)

Actuellement, n’imprime pas Great Scott parce que je ne trouve pas un bon moyen de le rendre occasionnel.

Bash + coreutils, 177

d()(date -d@"$@")
for((b=`date +%s`;a=`date +%s`;b=a)){
t=`d $a`\ `d $b`
((a<b))&&d $b "+$t: Back in good old %Y."
((a>b+86400))&&d $b "+$t: %Y? You mean we're in the future?"
}

Ruby, 194 octets

Je n'ai pas encore eu le temps de le réduire vraiment. Je suis sûr que quelques optimisations se cachent là-dedans.

require 'time';t=nil;while 1;n=Time.now;if t;s="#{t} #{n}: ";y=n.year;puts t>n ? "#{s}Back in good old #{y}" : (n>t+86400 ? "#{s}#{y}? You mean we're in the future?": "Great Scott!");end;t=n;end

Ungolfed (et beaucoup plus lisible):

require 'time'
t=nil
while 1
  n=Time.now
  if t                                             # on second or later pass
    s="#{t} #{n}: "                                # prepare the timestamp
    y=n.year
    puts t>n ?                                     # if we go back
      "#{s}Back in good old #{y}" :                # timestamp + phrase
      (n>t+86400 ?                                 # else, more than one day forward
        "#{s}#{y}? You mean we're in the future?": # timestamp + future
        "Great Scott!")                            # Great Scott!
  end
  t=n                                              # set a new jump point
end

Edit: corrigé pour demander du temps à l'OS, plutôt qu'un humain.

Lua 5.3, 174 octets

T=os.time P=print l=T()::a::t=T()b=l.." "..t..": "y=os.date('%Y',t)_=t<l and
P(b.."Back in good old "..y)or t>l+86399 and
P(b..y.."? You mean we're in the future?")l=t goto a

Cela joue beaucoup au large de la règle « Horodatage peut être dans un format » ... que je pris la liberté d'utiliser le format de « secondes depuis le 1er janvier 1970 »


Si je garde mon interprétation de mauvaise qualité de l' impression horodatages, et d' adopter la structure de MeepDarknessMeep, je peux (de manière non éthique) réduire cette ...

155 octets

T=os.time::G::l=t or T()t=T()_=(t>l+86399or t<l)and
print(l.." "..t..": "..os.date(t<l
and"Back in good old %Y"or"%Y? You mean we're in the future?"))goto G

Lua 5.3, 179 178 173 171 169 169 168 163 octets

q="%Y %c: "c=os.date::a::d=f f=os.time()_=d and(f-d>86399or f<d)and print(c(q,d)..c(q..(f<d and"Back in good old %Y."or"%Y? You mean we're in the future?")))goto a

Note latérale: Si vous supprimez la nécessité d'un numéro d'année complète, soustrayez-en six. La raison en est que lua (ou les fenêtres ou quelqu'un!)% C ne produit pas l'année complète. Pour cette raison, les horodatages peuvent paraître bizarres!

Cela tire également parti du fait que les horodatages peuvent être séparés par des caractères autres que des chiffres!

Merci de m'avoir informé de mes anciennes références math.abs et autres améliorations @thenumbernine :)

Lua 5.3, 151 octets

Il s'agit d'une copie de la méthode d'affichage de l'heure de @thumbernine en affichant simplement l'horodatage au lieu de la date réelle. Ce n'est pas compétitif car je pense que c'est un peu de tricherie, il suffit de l'afficher ici pour afficher mon travail :)

::a::d=f f=os.time()_=d and(f-d>86399or f<d)and print(d.." "..f..os.date(f<d and": Back in good old %Y."or": %Y? You mean we're in the future?"))goto a

C: 363 octets

Minified en utilisant ce script pratique :

#include<stdio.h>
#include<time.h>
void p(time_t*t){char b[64];strftime(b,64,"%FT%T",localtime(t));printf("%s ",b);}int main(void){time_t a,b,d=60*60*24;int y;time(&a);while(1){time(&b);y=localtime(&b)->tm_year+1900;if(b<a){p(&a);p(&b);printf("Back in good old %d\n",y);}else if(b>a+d){p(&a);p(&b);printf("%d? You mean we're in the future?\n",y);}a=b;sleep(1);}}

Original:

#include <stdio.h>
#include <time.h>

void p(time_t * t) {
  char b[64];
  strftime(b, 64, "%FT%T", localtime(t));
  printf("%s ", b);
}

int main(void) {
  time_t a, b, d = 60*60*24;
  int y;

  time(&a);
  while(1) {
    time(&b);
    y = localtime(&b)->tm_year+1900;
    if (b < a) {
      p(&a); p(&b); printf("Back in good old %d\n", y);

    } else if (b > a + d) {
      p(&a); p(&b); printf("%d? You mean we're in the future?\n", y);
    }
    a = b;
    sleep(1);
  }
}

Exemple d'exécution:

2015-10-23T23:30:03 1985-06-14T16:27:00 Back in good old 1985   
1985-06-14T16:27:07 1999-02-09T14:15:00 1999? You mean we're in the future?
1999-02-09T14:15:09 2015-02-09T14:15:00 2015? You mean we're in the future?
2015-02-09T14:15:36 2015-10-21T07:28:00 2015? You mean we're in the future?
2015-10-21T07:29:06 1985-10-26T09:00:00 Back in good old 1985
1985-10-26T09:00:28 2055-11-12T06:38:00 2055? You mean we're in the future?
2055-11-12T06:38:12 1919-10-07T00:09:57 Back in good old 1919
1919-10-07T00:09:57 2055-11-12T06:38:14 2055? You mean we're in the future?  # tried to go to 1955 - fail.
2055-11-12T06:39:09 2015-10-23T23:32:03 Back in good old 2015  # auto-time back to 2015 because my laptop didn't like the jump to 2055!

Je pourrais me débarrasser de 10 octets en supprimant le sleepje suppose.

Soit dit en passant, une maniabilité qui prend du temps pour Mac / Linux

sudo date 1026090085  # Sat 26 Oct 1985 09:00:00
sudo date 1021072815  # Wed 21 Oct 2015 07:28:00
sudo date 1112063855  # Intended to be 1955 but is 2055. Don't use!

JavaScript (ES6) 181 174 170 Octets

for(a=Date;c=b||a.now(),b=d();e=new a(b).getFullYear(),f=`${a(c)} ${a(b):`})b>c+864e5?(g=alert)`${f} ${e}? You mean we're in the future?`:c>b&&g`${f} Back in good old `+e

Remarque: N'a pas été testé avec une machine en temps réel.

Ce code fonctionne dans Firefox, Chrome, Edge, Node.js Harmony (ou io.js d'ailleurs). Mais, j'utilise alert, donc cela devra être remplacé par console.logpour Node et Io Suport: (187 Bytes)

for(a=Date,b=0;c=b||(d=a.now)(),b=d();e=new a(b).getFullYear(),f=`${a(c)} ${a(b):`})b>c+864e5?(g=console.log)`${f} ${e}? You mean we're in the future?`:c>b&&g`${f} Back in good old ${e}.`

A expliqué:

// Using for like a while loop, defining relevant variables:
  for (a = Date, b = 0;
// Defing b and c: c becomes b, b becomes now. Also defining a shorthand for Date.now:                                
  c = b || a.now(),
  b = d();
// Defining Variables Relevant to this loop: e is the year according to b, f is the "TS TS:" string:                        
  e = new a(b).getFullYear(),
  f = `${a(c)} ${a(b):`
  )
// If b is greater than c plus a day (in milliseconds):
  b > c + 864e5 ?
  // Alert Time Forwand String: 
    (g = alert)
    `${f} ${e}? You mean we're in the future?`:
// else if c is greater than b:
  c > b &&
  // Alert Time Back String: 
    g `${f} Back in good old `+e

Python, 170 à 165 octets

from datetime import*
n=datetime.now
c=n()
while 1:
 p=c;c=n()
 if(c-p).days:print p,"%s:"%c,["%s? You mean we're in the future?","Back in good old %s."][c<p]%c.year

Cela doit beaucoup à la réponse de Morgan Thrapp. L’astuce principale ici est la normalisation timedelta, qui rend timedelta.days négatif lorsqu’on se déplace même légèrement vers le passé et à 0 lorsqu’il se déplace moins d’un jour à l’avenir.

Caché ObjectScript, 199 octets

l s k=86400 f  s e=+$H,t=$P($H,",",2) s:'d d=e,s=t s z=$ZDT(h)_" "_$ZDT($H)_": ",y=h\365+1841 w:e>d !,z,y,"? You mean we're in the future?" w:(k*t+e)<(k*s+d) !,z,"Back in good old ",y s h=$H,d=e,s=t

Ce problème peut être résolu dans MUMPS, mais il serait excessivement long, car ANSI MUMPS ne dispose pas de la $ZD[ATE]T[IME]fonction intrinsèque permettant de formater les dates en horodatages lisibles par l'homme.

Ce programme détectera probablement pas le temps Voyage à avant le 1 janvier 1841, ni le temps Voyage à après le 31 décembre 9999, étant donné que ce sont les limites de la $H[OROLOG]intrinsèque Chronométrage . Ce programme n’a également qu’une précision de second niveau; Des problèmes de temps dans l’arrière, inférieurs à une seconde, échapperont probablement à son attention.

TSQL, 355 octets

Au travail, évitez donc de vous en tenir à votre serveur de production SQL Server =)

Version golfée

declare @a datetime=getdate(),@b datetime,@d float,@ char(99),@y char(4)while 0=0begin select @b=getdate(),@d=cast(@b as float)-cast(@a as float),@y=' '+DATEPART(y,@b),@=cast(@a as char(20))+' '+cast(@a as char(20))+': 'if @d>=1set @=@+@y+'? You mean we''re in the future?'if @d<0set @=@+'Back in good old '+@y+'.'print @ set @a=@b end

Version plus lisible avec des modifications mineures.

declare @t0 datetime = getdate(), @t1 datetime, @d float, @m varchar(99), @y char(4)

while 0=0
begin

    set @t1 = getdate()
    set @d = cast(@t1 as float) - cast(@t0 as float)
    set @y = ' ' + DATEPART(yy, @t1)
    set @m = cast(@t0 as varchar(30)) + ' ' + cast(@t0 as varchar(30)) + ': '

    if @d >= 1 set @m = @m + @y + '? You mean we''re in the future?'
    if @d < 0 set @m = @m +  'Back in good old ' + @y + '.'

    print @m

    set @t0 = @t1
end

SQL n'est pas si mauvais en ce qui concerne les horodatages puisqu'il s'agit d'un type de données de première classe.

Pour le golf, nous utilisons un type avec une précision de 3 millisecondes. La boucle elle-même prend moins que cela pour itérer (selon votre serveur). La clé ici est que l’horodatage est un float et que le type entier compte le nombre de jours écoulés. Il ne fonctionnera pas bien du 1er janvier 1753 au 31 décembre, date limite 9999.

VBA, 258 octets

A accompagné: Excel 2007 sous Windows 7

305 octets si l'utilisabilité est requise

AVERTISSEMENT Ceci PEUT maximiser votre CPU et votre crash Excel / Windows si vous êtes sur un seul ordinateur à un seul thread (probablement trouvé en 1985)

Sub q()
h=CDbl(Now())
While 1
t=CDbl(Now())
If t>h+1 Then Debug.Print (CDate(t) & " " & CDate(h) & ":" & Year(t) & "? You mean we're in the future?")
If t<h Then Debug.Print (CDate(t) & " " & CDate(h) & ": Back in good old " & Year(t) & ".")
h=t
Wend
End Sub

Si vous voulez que ce code soit "testable", ajoutez Application.Wait (Now() + TimeValue("0:00:01"))aprèsh=t

Sortie

10/22/2015 3:04:45 PM 10/22/2015 3:04:43 PM:2015?You mean we're in the future?
10/22/2015 3:06:48 PM 10/22/2015 3:06:46 PM: Back in good old 2015.

Ci-dessous le fichier de test que j'ai utilisé. Honnêtement, je suis étonné du peu de sécurité que Windows a parfois. Peut ne pas fonctionner comme prévu sur tous les ordinateurs

Courir à ses risques et périls pourrait avoir des effets secondaires majeurs et durables !!!!
Sub DOC() t = 31346.6868055556 Date = DateSerial(Year(t), Month(t), Day(t)) Time = TimeSerial(Hour(t), Minute(t), Second(t)) q End Sub

Javascript 173 169 162 octets

Javascript est très populaire ...

for(e=Date,n=e.now;o=n(a=alert);)d=new e,f=d.getFullYear(n(o>n(s=d+` ${e(o)}:`)&&a(s+`Back in good old ${f}.`))-o>864e5&&a(s+f+`? You mean we're in the future?`))

Explication (ancienne version du code):

for(e=Date,n=e.now,a=alert,o=n();;o=n()) //Set up the variables and update o, the previous time

d=new e,s=d+` ${e(o)} `,f=d.getFullYear(), //d is the date, s is a string with the 2 timestamps, f is the year
n()-o>8.64e7&&a(s+f+`? You mean we're in the future?`), //Future check
o>n()&&a(s+`Back in good old ${f}.`) //Past check

Traitement, 270 octets

int p;long x=System.currentTimeMillis();void draw(){int q=millis(),y=year();if(q<p){t(p);print("Back in good old "+y+".");}if(q>p+86400000){t(p);print(y+"? You mean we're in the future?");}p=q;}void t(int m){print(new java.util.Date(x+m)+" "+new java.util.Date()+": ");}

Étendu:

int p;
long x=System.currentTimeMillis();
void draw() {
  int q=millis(), y=year();
  if (q<p) {
    t(p);
    print("Back in good old "+y+".");
  }
  if (q>p+86400000) {
    t(p);
    print(y+"? You mean we're in the future?");
  }
  p=q;
}
void t(int m) {
  print(new java.util.Date(x+m)+" "+new java.util.Date()+": ");
}

Exemple de sortie:

Wed Oct 21 13:21:59 EDT 2015 Mon Oct 19 13:21:59 EDT 2015: Back in good old 2015.
Mon Oct 19 13:22:08 EDT 2015 Wed Oct 21 13:22:08 EDT 2015: 2015? You mean we're in the future

Ruby, 160 157 155 154 octets

Beaucoup de choses à jouer au golf ici

a=Time.new;loop{b,s,y=Time.new,"#{a} #{b}: ",b.year;$><<(a>b ? s+"Back in good old #{y}.\n":b>a+86400 ? s+"#{y}? You mean we're in the future?\n":"");a=b}

Mathematica, 295 octets

Le programme demande à l'OS toutes les secondes pour un nouveau TS.

f:=LocalTime[]
p=Print;
y:=DateString[#,"Year"]&
s:=ToString[#]<>" "&
d:=QuantityMagnitude@DateDifference[a,b]
j=StringJoin;
While[True,
  a=b;
  b=f;
  Pause@1;
  Which[d>=0,
   p@(j@@{s@a,s@b,": ",y@b, 
       "? You mean we are in the future?"}),
   d<0,
   p@(j@@{s@a,s@b," Back in good old ",y@b,"."})]];

Sortie

Testé en introduisant manuellement la date et l'heure.

DateObject[{2015, 10, 23}, TimeObject[{18, 36, 17.9618}], TimeZone -> \
-4.] DateObject[{2015, 10, 25}, TimeObject[{18, 42, 0.264913}], \
TimeZone -> -4.] : 2015? You mean we are in the future?

DateObject[{2015, 10, 23}, TimeObject[{18, 43, 0.141572}], TimeZone -> -4.] DateObject[{2015, 10, 23}, TimeObject[{18, 42, 3.30681}], TimeZone -> -4.]  Back in good old 2015.

Pourrait certainement avoir mieux formater la sortie. Il répond aux exigences énoncées.

Groovy, 244 octets

def s=9999,d={new Date()},y={it.year+1900},f={t,n->"$t $n: ${y(n)}? You mean we're in the future?"},p={t,n->"$t $n: Back in good old ${y(n)}."},t=d()
while(!sleep(s)){n=d()
c=n.time-t.time
println c<0?p(t,n):c>s*2?f(t,n):'Great Scott!'
t=n}

Java, 378 octets.

function detect()
{
int diffInDays = (int)( (newerDate.getTime() - olderDate.getTime()) 
                 / (1000 * 60 * 60 * 24) );
if(diffInDays>0) 
System.out.println(olderDate+" "+newerDate+": "+newerDate.getYear()+"? You mean we're in the future?");
else if(diffInDays<0) 
System.out.println(olderDate+" "+newerDate+": "+"Back in good old "+newerDate.getYear());
}