Computer sind heutzutage überall - in Autos, Zügen, Skateboards, sogar in Atomreaktoren. Die Möglichkeit, dass Ihre Software auf einem Zeitreisegerät ausgeführt wird, ist nur eine Frage der Zeit. Kannst du damit umgehen? Kannst du es wenigstens entdecken?

Deine Aufgabe:

1. Schreiben Sie ein Programm, das sich wiederholt und die Systemzeit abfragt, um Zeitreisen zu erkennen.
2. Wenn die Zeit zwischen zwei aufeinanderfolgenden Abfragen um einen Tag oder mehr nach vorne verschoben wird, ist dies die Zeitreise nach vorne. In diesem Fall sollte Ihr Programm Folgendes ausgeben:
   TS TS: YYYY? You mean we're in the future?
3. Wenn die Zeit zwischen zwei aufeinanderfolgenden Abfragen um einen bestimmten Betrag zurückgeht, ist dies eine Zeitreise in die Vergangenheit. In diesem Fall sollte Ihr Programm Folgendes ausgeben:
   TS TS: Back in good old YYYY.
4. TS TSsind die Zeitstempel vor und nach der Zeitreise. YYYYist das Zieljahr.
5. Zeitstempel können in einem beliebigen Format vorliegen, das mindestens vierstellige Jahres-, Monats-, Tages-, Stunden-, Minuten- und Sekundenangaben enthält, die durch keine Ziffern voneinander getrennt sind.

Einschränkungen:

1. Sie müssen Daten aus dem 19., 20. und 21. Jahrhundert unterstützen.
2. Sie müssen eine Sprache verwenden, die vor dem Posten dieser Herausforderung vorhanden war.
3. Sie müssen Ihre Antworten erst veröffentlichen, nachdem diese Aufforderung veröffentlicht wurde.
4. Sie müssen eine Sprache verwenden, die vor dem Posten Ihrer Antwort vorhanden war.
5. Sie können Ihre Antwort erst bearbeiten, nachdem Sie sie veröffentlicht haben.
6. Ihr Programm darf nur die gewünschte Ausgabe ausgeben. Ein gelegentlicher "Great Scott!" ist erlaubt.

Das ist Code-Golf. Die kürzeste Antwort gewinnt.
Relevante Filmreferenzen werden Ihre Antwort wahrscheinlich zu lang machen, aber Ihnen möglicherweise positive Stimmen einbringen.

CJam, 118 Bytes

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

Dies funktioniert nicht mit dem Online-Dolmetscher.

Beispielausgabe nach zweimaliger Einstellung der Computerzeit:

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 Bytes

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

Zeitstempel werden im YYYY-MM-DD HH:MM:SSFormat gedruckt und durch Semikolons getrennt. Wurde von 3 auf Python 2 umgestellt, da der Ausdruck 2 Zeichen kürzer ist. Spam-Mails sind Great Scott!für Nicht-Zeitreisende normal , da dies einfacher und billiger ist als das Einrichten eines bedingten Ausdrucks.

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

Dies könnte wahrscheinlich mit einigem Umschreiben zu tun haben, um es effizienter / kleiner zu machen.

Quelle:

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)

Derzeit druckt Great Scott nicht, weil ich keine gute Möglichkeit finde, es nur gelegentlich zu machen.

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 Bytes

Ich hatte noch nicht die Zeit, das wirklich auf die richtige Größe zu bringen. Ich bin mir sicher, dass sich dort ein paar Optimierungen verstecken.

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 (und viel besser lesbar):

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

Bearbeiten: Korrigiert, um das Betriebssystem nach Zeit zu fragen, anstatt nach einem Menschen.

Lua 5,3, 174 Bytes

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

Dies spielt stark von der Regel "Zeitstempel können in jedem Format sein" ab ... Ich


habe mir erlaubt , das Format "Sekunden seit dem 1. Januar 1970" zu verwenden, wenn ich meine schlechte Interpretation des Druckens von Zeitstempeln behalte und die Zeitstempel übernehme Struktur von MeepDarknessMeep, ich kann dies (unethisch) quetschen, um ...

155 Bytes

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 Bytes

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

Randnotiz: Wenn Sie die Notwendigkeit für eine ganze Jahreszahl herausnehmen, dann subtrahieren Sie sechs Bytes. Der Grund ist, dass% c von lua (oder Windows oder jemandem!) Nicht das ganze Jahr ausgibt. Aus diesem Grund können die Zeitstempel seltsam aussehen!

Dies nutzt auch den Vorteil, dass Zeitstempel durch nicht-stellige Zeichen getrennt werden können!

Vielen Dank, dass Sie mich über meine alte math.abs-Referenz und andere Verbesserungen unter @thenumbernine informiert haben :)

Lua 5,3, 151 Bytes

Dies ist das "Kopieren" der @ thenumbernine-Methode zum Anzeigen der Zeit, indem nur der Zeitstempel anstelle des tatsächlichen Datums angezeigt wird. Dies ist nicht wettbewerbsfähig, da ich denke, dass es ein bisschen Schummeln ist. Posten Sie es einfach hier, um meine Arbeit anzuzeigen :)

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

Mit diesem praktischen Skript minimiert :

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

Beispiellauf:

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!

Ich könnte 10 Bytes loswerden, indem sleepich das entferne, schätze ich.

Übrigens ein wenig Zeitsprung für 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 Bytes

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

Hinweis: Wurde nicht mit einer Echtzeitmaschine getestet.

Dieser Code läuft in Firefox, Chrome, Edge, Node.js Harmony (oder io.js für diese Angelegenheit). Aber ich benutze alert, so dass console.logfür Node und Io Suport ersetzt werden muss: (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}.`

Erklärt:

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

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

Dies ist Morgan Thrapps Antwort zu verdanken. Der Haupttrick hierbei ist die Zeitdelta-Normalisierung, die zeitdelta.days praktisch negativ macht, wenn sie sich nur geringfügig in die Vergangenheit bewegt, und 0, wenn sie sich weniger als einen Tag in die Zukunft bewegt.

Caché 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

Dieses Problem ist in einfachen alten MUMPS lösbar, wäre aber unangemessen langwierig, da ANSI MUMPS die eigentliche $ZD[ATE]T[IME]Funktion zum Formatieren von Datumsangaben in für Menschen lesbare Zeitstempel fehlt .

Dieses Programm erkennt wahrscheinlich weder Zeitreisen vor dem 1. Januar 1841 noch Zeitreisen nach dem 31. Dezember 9999, da dies die Grenzen der eigentlichen $H[OROLOG]Zeitmessung sind . Dieses Programm hat auch nur eine Genauigkeit der zweiten Ebene; Zeitstörungen im Sub-Second-Level nach hinten werden wahrscheinlich nicht bemerkt.

TSQL, 355 Bytes

Bei der Arbeit bleiben also keine ausgefallenen coolen Sprachen bei deinem SQL Server-Produktionsserver =)

Golf Version

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

Mehr lesbare Version mit kleinen Änderungen.

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 ist in Bezug auf Zeitstempel nicht so schlecht, da es sich um einen erstklassigen Datentyp handelt.

Für den Golfsport verwenden wir einen Typ mit einer Genauigkeit von 3 Millisekunden. Die Schleife selbst benötigt weniger Zeit zum Durchlaufen (abhängig von Ihrem Server). Der Schlüssel hier ist intern, dass der Zeitstempel ein Gleitkomma ist und der Integer-Typ zählt, wie viele Tage vergangen sind. Es funktioniert vom 1. Januar 1753 bis zum 31. Dezember 9999 problemlos.

VBA, 258 Bytes

Lief mit: Excel 2007 in Windows 7

305 Bytes, wenn Benutzerfreundlichkeit erforderlich ist

WARNUNG Dies KANN Ihre CPU und Excel / Windows zum Absturz bringen, wenn Sie sich auf einem Single-Threaded-Single-Core-Computer befinden (höchstwahrscheinlich 1985 gefunden).

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

Wenn Sie möchten, dass dieser Code "testbar" ist, fügen Sie Application.Wait (Now() + TimeValue("0:00:01"))nachh=t

Ausgabe

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.

Unten ist die Testdatei, die ich verwendet habe. Ich bin ehrlich erstaunt darüber, wie wenig Sicherheit Windows manchmal bietet. Läuft möglicherweise nicht auf allen Computern wie erwartet

Laufen auf eigenes Risiko könnte schwerwiegende dauerhafte Nebenwirkungen haben !!!!
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 Bytes

Javascript ist ziemlich beliebt ...

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

Erklärung (ältere Version des Codes):

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

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

Erweitert:

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

Beispielausgabe:

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 Bytes

Hier gibt es viel zu golfen

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 Bytes

Das Programm fragt das Betriebssystem jede Sekunde nach neuen 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,"."})]];

Ausgabe

Geprüft durch manuelle Eingabe von Datum / Uhrzeit.

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.

Hätte definitiv die Ausgabe besser formatieren können. Es erfüllt die angegebenen Anforderungen.

Groovy, 244 Bytes

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

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