Wykryj podróż w czasie

51

Komputery są dziś wszędzie - w samochodach, pociągach, deskorolkach, a nawet reaktorach jądrowych. Możliwość uruchomienia oprogramowania w urządzeniu podróżującym w czasie to tylko kwestia czasu. Poradzisz sobie z tym? Czy potrafisz to przynajmniej wykryć?

Twoje zadanie:

  1. Napisz program, który zapętla się i sprawdza kwerendę czasu systemowego w celu wykrycia podróży w czasie.
  2. Jeśli czas przesuwa się o dzień lub dłużej między dwoma kolejnymi zapytaniami, oznacza to podróż w czasie do przodu. W takim przypadku Twój program powinien wydrukować:
    TS TS: YYYY? You mean we're in the future?
  3. Jeśli czas cofa się o dowolną kwotę między dwoma kolejnymi zapytaniami, to podróż w czasie do tyłu. W takim przypadku Twój program powinien wydrukować:
    TS TS: Back in good old YYYY.
  4. TS TSsą znacznikami czasu przed i po podróży w czasie. YYYYjest rokiem docelowym.
  5. Znaczniki czasu mogą być w dowolnym formacie, który obejmuje co najmniej 4-cyfrowy rok, miesiąc, dzień, godzinę, minutę i sekundę, oddzielone cyframi.

Ograniczenia:

  1. Musisz wspierać daty przynajmniej w XIX, XX i XXI wieku.
  2. Musisz użyć języka, który istniał przed opublikowaniem tego wyzwania.
  3. Musisz opublikować swoje odpowiedzi dopiero po opublikowaniu tego wyzwania.
  4. Musisz użyć języka, który istniał przed opublikowaniem odpowiedzi.
  5. Możesz edytować swoją odpowiedź dopiero po jej opublikowaniu.
  6. Twój program nie może drukować żadnych wyników innych niż wymagane. Od czasu do czasu „Wielki Scott!” jest dozwolone.

To jest golf golfowy. Najkrótsza odpowiedź wygrywa.
Odpowiednie odniesienia do filmów prawdopodobnie spowodują, że twoja odpowiedź będzie zbyt długa, ale może skłonić cię do pochwalenia się.

ugoren
źródło
31
Więcej programistów kłamstwa wierzy w czas, # 36 : „ Czas zawsze płynie do przodu.
Klamka
4
Czy mógłbyś być bardziej szczegółowy na temat # 5?
Mego
4
rozdzielone przez nie-cyfry? gwizd. RRRRMMDDGGmmSS to mój ulubiony format znaczników czasu.
Sparr
3
@Aequitas skąd wiesz? może zegar systemowy jest właściwie niezmienny i „ustawiając” to faktycznie podróż w czasie
Rune FS
5
Ograniczenia 2,3,4,5 są naprawdę surowe, nie wiem czy dam sobie radę.
Surt

Odpowiedzi:

4

CJam, 118 bajtów

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

Nie działa to z tłumaczem online.

Przykładowe dane wyjściowe po dwukrotnym dostosowaniu czasu komputera:

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.
Dennis
źródło
1
Dlaczego nie działa z tłumaczem online (z wyjątkiem tego, że nie pozwala ci majstrować przy czasie)?
ugoren,
1
Ponieważ jest to nieskończona pętla, a interpreter online wyświetla dane wyjściowe dopiero po zakończeniu programu.
Dennis
1
Jak więc sprawdzić, czy to działa?
ugoren
1
Korzystanie z interpretera Java .
Dennis,
9

Python 2, 210 bajtów

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

Znaczniki czasu są drukowane w YYYY-MM-DD HH:MM:SSformacie oddzielonym średnikami. Przełączono na Python 2 z 3, ponieważ jest o 2 znaki krótszy do wydrukowania. Przęsła z stdout Great Scott!do normies non-time-podróżnych, ponieważ łatwiej i taniej jest zrobić niż założyć warunkowego drukiem.

Mego
źródło
Czy oczekuje czasu jako danych wejściowych? Nie o to pyta (może to jest niejasne). Wydaje się również, że drukuje puste linie, gdy czas zachowuje się dobrze.
ugoren
Miałem na myśli pytanie systemu operacyjnego, a nie użytkownika. Wyjaśnię.
ugoren
8

JavaScript (ES6), 263 bajtów

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

Prawdopodobnie przydałoby się to trochę przepisywania, aby uczynić go bardziej wydajnym / małym.

Źródło:

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);
}());
Florrie
źródło
1
Podróż do tyłu jest definiowana jako cofanie się o dowolną kwotę, a nie o jeden dzień. Ponadto z powodu wielu now()połączeń może przegapić wydarzenie związane z podróżą.
ugoren
Próba gry w golfa: n = data, o = n.now (); setInterval ("d = nowy n, s = d +` $ {nowy n (o)} `; f = d.getFullYear (); if ( n.now () - o> 8.64e + 7) console.log (s + f + `? Masz na myśli, że jesteśmy w przyszłości?`); if (o> n.now ()) console.log (s + ` Z powrotem w starym dobrym $ {f} .`); o = n.now () ", 100);
Stefnotch
Myślę, że możesz zagrać w golfa w pierwszej części o=(n=Date).now().
Conor O'Brien
+ Stefnotch 8.64e+7ma dwa znaki dłuższe niż 86400.
Florrie,
1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Ups! Zastanawiałem się, dlaczego to nie zadziałało.
Florrie
5

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)

Obecnie nie drukuje Great Scott, ponieważ nie mogę znaleźć dobrego sposobu, aby zrobić to tylko okazjonalnie.

Morgan Thrapp
źródło
5

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?"
}
Cyfrowa trauma
źródło
3

Ruby, 194 bajty

Nie miałem jeszcze czasu, żeby naprawdę to zmniejszyć. Jestem pewien, że kryje się tam kilka optymalizacji.

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

Niegolfowany (i dużo bardziej czytelny):

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

Edycja: poprawiono, aby pytać OS o czas, a nie człowieka.

Ziemniak Ziemniaczany Kanapka
źródło
2
Kilka zaleceń: Użyj loop{}zamiast while 1...endi spróbuj użyć +do konkatenacji ciągów zamiast interpolacji.
voikya
3

Lua 5.3, 174 bajty

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

Jest to w dużej mierze niezgodne z zasadą „


Znaczniki czasu mogą być w dowolnym formacie”… które pozwoliłem sobie na użycie formatu „sekund od 1 stycznia 1970 r.” Jeśli zachowam moją tandetną interpretację drukowania znaczników czasu i zastosuję struktura MeepDarknessMeep, mogę (nieetycznie) ścisnąć to do ...

155 bajtów

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
thenumbernine
źródło
3
Timestamps may be in any format, that includes at least the 4-digit year, month, day, hour, minute and second, separated by non-digits.- to nie pozwala sekund od epoki.
Mego
4
Dobrze, że nie „wyklucza” żadnych formatów
numer
@ugoren Naprawdę ten wymóg powinien być bardziej konkretny co do twojego zamiaru
Mego
Nie jestem w pełni zaznajomiony z lua, więc mogę się mylić, ale wygląda na to, że to odciski, Back in good ol YYYYale powinny się wydrukować Back in good old YYYY. (Zwróć uwagę na d)
Pokechu22,
nie dobry połów, starałem się golić bajty gdziekolwiek mogłem :-p
thenumbernine
2

Lua 5.3, 179 178 173 171 169 168 163 bajtów

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

Uwaga dodatkowa: jeśli potrzebujesz numeru pełnego roku, odejmij sześć bajtów. Powodem jest to, że% c lua (lub Windowsa lub czyjegoś!) Nie wyświetla pełnego roku. Z tego powodu znaczniki czasu mogą wyglądać dziwnie!

Wykorzystuje to również możliwość oddzielania znaczników czasu dowolnymi znakami nie cyfrowymi!

Dziękujemy za powiadomienie o mojej starej referencji do math.abs i innych ulepszeniach @thenumbernine :)

Lua 5.3, 151 bajtów

Jest to „kopiowanie” metody @ thenumbernine do wyświetlania czasu, po prostu pokazując znacznik czasu zamiast rzeczywistej daty. To nie jest konkurencyjne, ponieważ myślę, że to trochę oszustwo, po prostu opublikuj to tutaj, aby wyświetlić moją pracę :)

::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
MeepDarknessMeep
źródło
1
Obie nasze odpowiedzi Lua opublikowaliśmy prawie dokładnie w tym samym czasie. To musi coś powiedzieć o podróżach w czasie.
thenumbernine
Ahah, dzięki @thenumbernine! W końcu udało mi się skomentować :)
MeepDarknessMeep
2

C: 363 bajtów

Zminimalizowane za pomocą tego poręcznego skryptu :

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

Oryginał:

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

Przykładowy przebieg:

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!

Mogę pozbyć się 10 bajtów, usuwając sleepchyba.

Nawiasem mówiąc, pewna poręczna poręczność dla komputerów 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!
Andrew E.
źródło
Zapraszam do upuszczenia sleep.
ugoren,
2

JavaScript (ES6) 181 174 170 bajtów

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

Uwaga: Nie testowano na maszynie czasu rzeczywistego.

Ten kod działa w Firefox, Chrome, Edge, Node.js Harmony (lub io.js w tym przypadku). Ale używam alert, więc będą musiały być zastąpione console.logprzez Node i Io Suport: (187 bajtów)

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}.`

Wyjaśniono:

// 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
MayorMonty
źródło
Udało mi się napisać jeszcze krótszy, możesz rzucić okiem na to i ewentualnie poprawić swój. Myślę też, że to świetnie!
Stefnotch
Jak duże było twoje rozwiązanie, chcę sprawdzić, czy uda mi się go pokonać? ;)
MayorMonty
Przewiń w dół lub kliknij link: codegolf.stackexchange.com/a/61544/33160 Poza tym jesteś bliski pokonania! : D
Stefnotch
2

Python, 170 165 bajtów

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

To wiele zawdzięcza odpowiedzi Morgana Thrappa. Główną sztuczką jest tutaj normalizacja timedelta, która wygodnie sprawia, że ​​timedelta.days jest ujemny, gdy porusza się nawet nieznacznie w przeszłość, a 0, gdy przenosi się o mniej niż jeden dzień w przyszłość.

Han
źródło
Po import* nie potrzebujesz datetime.prefiksu.
ugoren
@ugoren: import* pozwala pisać datetime.now()zamiast datetime.datetime.now(). W pewnym sensie ma to sens ...
han
W mylący sposób to robi.
ugoren
1

Caché ObjectScript, 199 bajtów

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

Ten problem jest rozwiązywalne w zwykły starych świnka, ale byłoby nierozsądnie długie, ponieważ brakuje ANSI świnka z $ZD[ATE]T[IME]wewnętrzną funkcję do formatowania dat na znaczniki czasu czytelnych dla człowieka.

Ten program prawdopodobnie nie wykryje podróży w czasie przed 1 stycznia 1841 r., Ani podróży w czasie po 31 grudnia 9999 r., Ponieważ są to granice właściwe $H[OROLOG]pomiaru czasu . Ten program ma także tylko precyzję drugiego poziomu; usterki cofania w czasie na poziomie poniżej drugiego poziomu prawdopodobnie nie zauważą tego.

senshin
źródło
1

TSQL, 355 bajtów

W pracy, więc żadne fantazyjne fajne języki nie trzymają się twojego serwera produkcyjnego SQL Server =)

Wersja golfowa

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

Bardziej czytelna wersja z niewielkimi zmianami.

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 nie jest taki zły pod względem znaczników czasu, ponieważ jest to typ danych pierwszej klasy.

Ze względu na golfa używamy typu z dokładnością do 3 milisekund. Sama pętla wymaga mniej niż iteracja (w zależności od serwera). Kluczem jest tutaj to, że znacznik czasu jest liczbą zmiennoprzecinkową, a liczba całkowita liczy, ile dni minęło. Nie działa dobrze od 1 stycznia 1753 r. Do 31 grudnia 9999 r.

drelich
źródło
1

VBA, 258 bajtów

Współpracował z: Excel 2007 w Windows 7

305 bajtów, jeśli wymagana jest użyteczność

OSTRZEŻENIE MOŻE MAKSYMALNIE wykorzystać procesor i awarię programu Excel / Windows, jeśli korzystasz z jedno-wątkowego komputera z jednym rdzeniem (najprawdopodobniej w 1985 roku)

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

Jeśli chcesz, aby ten kod był „Testowalny”, dodaj go Application.Wait (Now() + TimeValue("0:00:01"))późniejh=t

Wynik

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.

Poniżej znajduje się plik testowy, którego użyłem. Jestem szczerze zdziwiony, jak czasami system Windows ma niewielkie zabezpieczenia. Może nie działać zgodnie z oczekiwaniami na wszystkich komputerach

Uruchom na własne ryzyko może mieć poważne trwałe skutki uboczne !!!!
Sub DOC() t = 31346.6868055556 Date = DateSerial(Year(t), Month(t), Day(t)) Time = TimeSerial(Hour(t), Minute(t), Second(t)) q End Sub

JimmyJazzx
źródło
1

JavaScript 173 169 162 bajtów

JavaScript jest dość popularny ...

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?`))

Objaśnienie (Starsza wersja kodu):

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
Stefnotch
źródło
0

Przetwarzanie, 270 bajtów

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

Rozszerzony:

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

Przykładowe dane wyjściowe:

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
Kevin Workman
źródło
0

Rubin, 160 157 155 154 bajtów

Tutaj jest wiele rzeczy do gry w golfa

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}
Peter Lenkefi
źródło
0

Mathematica, 295 bajtów

Program co sekundę prosi system operacyjny o nowe 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,"."})]];

Wynik

Testowane przez ręczne podawanie daty / godziny.

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.

Zdecydowanie lepiej sformatować dane wyjściowe. Spełnia podane wymagania.

Zagubiony w wiedzy
źródło
dlaczego skrót LocalTime[]? Pojawia się tylko raz w poniższym kodzie.
Michael Stern
W pewnym momencie użyłem go dwa razy. Ale dobry chwyt.
Lost in Knowledge
Usuń go, a uratujesz trzy postacie.
Michael Stern
0

Groovy, 244 bajty

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}
K. Klassen
źródło
0

Java, 378 bajtów.

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());
} 
akhil7886
źródło