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ę.

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.

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.

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

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.

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

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

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

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!

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

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ść.

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.

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.

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

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

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

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}

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.

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}

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