Oggi i computer sono ovunque: in auto, treni, skateboard e persino reattori nucleari. La possibilità che il tuo software funzioni in un dispositivo che viaggia nel tempo è solo una questione di tempo. Puoi affrontarlo? Puoi almeno rilevarlo?

Il tuo compito:

1. Scrivi un programma che esegue il loop e continua a interrogare l'ora del sistema, al fine di rilevare i viaggi nel tempo.
2. Se il tempo si sposta in avanti di un giorno o più tra due query consecutive, è il viaggio nel tempo in avanti. In questo caso, il tuo programma dovrebbe stampare:
   TS TS: YYYY? You mean we're in the future?
3. Se il tempo si sposta indietro, di qualsiasi importo, tra due interrogazioni consecutive, è un viaggio nel tempo all'indietro. In questo caso, il tuo programma dovrebbe stampare:
   TS TS: Back in good old YYYY.
4. TS TSsono i timestamp prima e dopo il viaggio nel tempo. YYYYè l'anno di destinazione.
5. I timestamp possono essere in qualsiasi formato, incluso almeno l'anno, il mese, il giorno, l'ora, i minuti e i secondi a 4 cifre, separati da cifre non cifre.

limitazioni:

1. Devi supportare le date nel XIX, XX e XXI secolo, almeno.
2. È necessario utilizzare una lingua esistente prima della pubblicazione di questa sfida.
3. Devi pubblicare le tue risposte solo dopo aver pubblicato questa sfida.
4. Devi usare una lingua esistente prima che la tua risposta fosse pubblicata.
5. Puoi modificare la tua risposta solo dopo averla pubblicata.
6. Il programma non deve stampare alcun output diverso da quello richiesto. Un occasionale "Grande Scott!" È permesso.

Questo è code-golf. Vince la risposta più breve.
I riferimenti ai film pertinenti probabilmente renderanno la tua risposta troppo lunga, ma potrebbero ottenere voti positivi.

CJam, 118 byte

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

Questo non funziona con l'interprete online.

Esempio di output dopo aver regolato due volte l'ora del mio computer:

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 byte

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

I timestamp sono stampati in YYYY-MM-DD HH:MM:SSformato, separati da punti e virgola. Passato a Python 2 da 3 poiché è più breve di 2 caratteri da stampare. Spam stdout con Great Scott!per normies non-viaggiatori nel tempo, dal momento che è più facile ed economico per farlo se non istituito una stampa condizionale.

JavaScript (ES6), 263 byte

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

Questo potrebbe probabilmente fare con qualche riscrittura per renderlo più efficiente / piccolo.

Fonte:

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)

Attualmente non stampa Great Scott perché non riesco a trovare un buon modo di renderlo solo occasionale.

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?"
}

Rubino, 194 byte

Non ho ancora avuto il tempo di ridurlo davvero a misura. Sono sicuro che ci sono alcune ottimizzazioni nascoste lì dentro.

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 (e molto più leggibile):

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

Modifica: corretto per chiedere tempo al sistema operativo, piuttosto che un essere umano.

Lua 5.3, 174 byte

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

Questo sta giocando pesantemente fuori dalla regola "I timestamp possono essere in qualsiasi formato" ... che mi sono preso la libertà di usare il formato di "secondi dal 1 ° gennaio 1970"


Se mantengo la mia interpretazione scadente dei timestamp di stampa, e adotto il struttura di MeepDarknessMeep, posso (eticamente) comprimerlo fino a ...

155 byte

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 byte

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

Nota a margine: se si elimina la necessità di un numero di anno intero, sottrarre sei byte. Il motivo è che% c di lua (o di windows o di qualcuno!) Non produce l'intero anno. Per questo motivo, i timestamp possono sembrare strani!

Questo sfrutta anche il fatto che i timestamp possono essere separati da qualsiasi carattere non cifra!

Grazie per avermi informato del mio vecchio riferimento a math.abs e di altri miglioramenti @thenumbernine :)

Lua 5.3, 151 byte

Si tratta di 'copiare' dal metodo @ thenumbernine di visualizzare l'ora mostrando semplicemente il timestamp invece della data effettiva. Questo non è competitivo dal momento che penso che sia un po 'imbroglione, pubblicandolo qui per mostrare il mio lavoro :)

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

Minimizzato usando questo utile script :

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

Originale:

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

Esempio di esecuzione:

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!

Potrei liberarmi di 10 byte rimuovendo il sleepsuppongo.

A proposito, una manciata di tempo per 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 Byte

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

Nota: non è stato testato con una macchina in tempo reale.

Questo codice funziona su Firefox, Chrome, Edge, Node.js Harmony (o io.js del resto ). Ma, lo uso alert, quindi dovrà essere sostituito da console.logper Node e Io Suport: (187 byte)

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

Ha spiegato:

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

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

Questo deve molto alla risposta di Morgan Thrapp. Il trucco principale qui è la normalizzazione di timedelta, che rende convenientemente timedelta.days negativo quando si sposta anche leggermente verso il passato e 0 quando si sposta di meno di un giorno verso il futuro.

Cache ObjectScript, 199 byte

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

Questo problema è risolvibile nei vecchi vecchi MUMPS, ma sarebbe irragionevolmente lungo, poiché ANSI MUMPS non ha la $ZD[ATE]T[IME]funzione intrinseca per la formattazione delle date in timestamp leggibili dall'uomo.

Questo programma probabilmente non rilevare viaggio nel tempo a prima del 1 Gennaio 1841, né il tempo-viaggio a dopo il 31 dicembre 9999, dal momento che questi sono i limiti della $H[OROLOG]intrinseca cronometraggio . Questo programma ha anche solo una precisione di secondo livello; glitch temporali all'indietro di secondo livello probabilmente sfuggiranno alla sua attenzione.

TSQL, 355 byte

Al lavoro, quindi niente fantasiose lingue con il tuo server di produzione SQL Server =)

Versione golfizzata

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

Versione più leggibile con modifiche minori.

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 non è poi così male rispetto ai timestamp poiché è un tipo di dati di prima classe.

Per amor del golf stiamo usando un tipo con precisione di 3 millisecondi. Il ciclo stesso richiede meno di quello per iterare (a seconda del server). La chiave qui è internamente che il timestamp è un float e il tipo intero conta il numero di giorni trascorsi. Funzionerà male nel periodo 1 gennaio 1753, fino al 31 dicembre 9999.

VBA, 258 byte

Eseguito con: Excel 2007 in Windows 7

305 byte se è richiesta l'usabilità

ATTENZIONE: MAGGIO massimo della CPU e dell'arresto anomalo di Excel / Windows se si utilizza un computer single core a thread singolo (probabilmente presente nel 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

Se vuoi che questo codice sia "Testabile", aggiungi Application.Wait (Now() + TimeValue("0:00:01"))dopoh=t

Produzione

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.

Di seguito è riportato il file di test che ho usato. Sono sinceramente stupito da quanto poca sicurezza abbia a volte Windows. Potrebbe non funzionare come previsto su tutti i computer

Correre a proprio rischio potrebbe avere effetti collaterali duraturi !!!!
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 byte

Javascript è piuttosto popolare ...

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

Spiegazione (versione precedente del codice):

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

Elaborazione, 270 byte

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

Allargato:

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

Uscita campione:

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

Rubino, 160 157 155 154 byte

Molte cose da golf qui

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 byte

Il programma richiede al sistema operativo ogni secondo per nuovi 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,"."})]];

Produzione

Testato inserendo manualmente data / ora.

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.

Sicuramente avrebbe potuto formattare meglio l'output. Soddisfa i requisiti indicati.

Groovy, 244 byte

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

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