Detectar viaje en el tiempo

51

Las computadoras están en todas partes hoy en día: en automóviles, trenes, patinetas, incluso en reactores nucleares. La posibilidad de que su software se ejecute en un dispositivo de viaje en el tiempo es solo cuestión de tiempo. ¿Puedes lidiar con eso? ¿Al menos puedes detectarlo?

Tu tarea:

  1. Escriba un programa que repita y siga consultando la hora del sistema para detectar el viaje en el tiempo.
  2. Si el tiempo avanza un día o más entre dos consultas consecutivas, es un viaje en el tiempo hacia adelante. En este caso, su programa debería imprimir:
    TS TS: YYYY? You mean we're in the future?
  3. Si el tiempo retrocede, por cualquier cantidad, entre dos consultas consecutivas, es un viaje en el tiempo hacia atrás. En este caso, su programa debería imprimir:
    TS TS: Back in good old YYYY.
  4. TS TSson las marcas de tiempo antes y después del viaje en el tiempo. YYYYEs el año de destino.
  5. Las marcas de tiempo pueden estar en cualquier formato, que incluya al menos el año, mes, día, hora, minuto y segundo de 4 dígitos, separados por no dígitos.

Limitaciones:

  1. Debe admitir fechas en los siglos XIX, XX y XXI, al menos.
  2. Debe usar un idioma que existía antes de que se publicara este desafío.
  3. Debe publicar sus respuestas solo después de publicar este desafío.
  4. Debe usar un idioma que existía antes de que se publicara su respuesta.
  5. Puede editar su respuesta solo después de haberla publicado.
  6. Su programa no debe imprimir ninguna salida que no sea la salida requerida. Un ocasional "Gran Scott!" esta permitido.

Este es el código de golf. La respuesta más corta gana.
Las referencias de películas relevantes probablemente harán que su respuesta sea demasiado larga, pero podrían darle votos positivos.

Ugoren
fuente
31
Más programadores de falsedades creen sobre el tiempo, # 36 : "El tiempo siempre avanza "
Pomo de la puerta
44
¿Podría ser un poco más específico sobre el n. ° 5?
Mego
44
separados por no digitos? abucheo. AAAAMMDDHHmmSS es mi formato de marca de tiempo favorito.
Sparr
3
@Aequitas, ¿cómo lo sabes? tal vez el reloj del sistema es realmente inmutable y está "configurando" en realidad viajando en el tiempo
Rune FS
55
Las limitaciones 2,3,4,5 son realmente duras, no sé si puedo manejar eso.
Surt

Respuestas:

4

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

Esto no funciona con el intérprete en línea.

Salida de muestra después de ajustar el tiempo de mi computadora dos veces:

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
fuente
1
¿Por qué no funciona con el intérprete en línea (excepto que no te permite jugar con el tiempo)?
Ugoren
1
Debido a que este es un bucle infinito, y el intérprete en línea muestra la salida solo después de que el programa ha terminado.
Dennis
1
Entonces, ¿cómo se prueba que funciona?
ugoren
1
Usando el intérprete de Java .
Dennis
9

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

Las marcas de tiempo se imprimen en YYYY-MM-DD HH:MM:SSformato, separadas por punto y coma. Cambió a Python 2 desde 3 ya que es 2 caracteres más cortos para imprimir. Los correos no deseadosGreat Scott! para las normas que no son viajeros en el tiempo, ya que es más fácil y más barato que configurar una impresión condicional.

Mego
fuente
¿Espera el tiempo como entrada? Esto no es lo que se pregunta (tal vez sea vago). Además, parece imprimir líneas en blanco cuando el tiempo se comporta bien.
Ugoren
Me refería a preguntarle al sistema operativo, no al usuario. Lo aclararé.
Ugoren
8

JavaScript (ES6), 263 bytes

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

Esto probablemente podría ser reescrito para hacerlo más eficiente / pequeño.

Fuente:

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
fuente
1
El viaje hacia atrás se define como retroceder por cualquier cantidad, no un día. Además, debido a las múltiples now()llamadas, puede perder un evento de viaje.
Ugoren
Un intento de jugar golf: n = Date, o = n.now (); setInterval ("d = new n, s = d +` $ {new n (o)} `; f = d.getFullYear (); if ( n.now () - o> 8.64e + 7) console.log (s + f + `? ¿Quiere decir que estamos en el futuro?`); if (o> n.now ()) console.log (s + ` De vuelta en los viejos tiempos $ {f} .`); o = n.now () ", 100);
Stefnotch
Creo que puedes jugar golf la primera parte o=(n=Date).now().
Conor O'Brien
+ Stefnotch 8.64e+7es dos caracteres más largo que 86400.
Florrie
1
@ CᴏɴᴏʀO'Bʀɪᴇɴ ¡Vaya! Me preguntaba por qué no funcionó.
Florrie
5

Pitón 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)

Actualmente no imprime Great Scott porque no puedo encontrar una buena manera de hacerlo ocasionalmente.

Morgan Thrapp
fuente
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?"
}
Trauma digital
fuente
3

Ruby, 194 bytes

Todavía no he tenido tiempo de reducir esto realmente a medida. Estoy seguro de que hay algunas optimizaciones escondidas allí.

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

Sin golf (y mucho más legible):

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

Editar: corregido para pedirle tiempo al sistema operativo, en lugar de a un humano.

PatataOmeletteSandwich
fuente
2
Algunas recomendaciones: use en loop{}lugar de while 1...ende intente usar +para la concatenación de cadenas en lugar de la interpolación.
voikya
3

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

Esto está jugando en gran medida fuera de la regla "Las


marcas de tiempo pueden estar en cualquier formato" ... que me tomé la libertad de usar el formato de "segundos desde el 1 de enero de 1970" Si mantengo mi mala interpretación de la impresión de marcas de tiempo y adopto el estructura de MeepDarknessMeep, puedo (poco éticamente) exprimir esto para ...

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
thenumbernine
fuente
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.- eso no permite segundos desde la época.
Mego
44
Lo bueno es que no "excluyó" ningún formato
thenumbernine
@ugoren Realmente ese requisito debería ser más específico en cuanto a tu intención
Mego
No estoy completamente familiarizado con lua, así que puedo estar equivocado, pero parece que esto se imprime, Back in good ol YYYYpero debería imprimirse Back in good old YYYY. (Tenga en cuenta la d en viejo)
Pokechu22
nop buen partido, yo estaba tratando de afeitado bytes donde pude :-p
thenumbernine
2

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

Nota al margen: si elimina la necesidad de un número de año completo, reste seis bytes. La razón es que% c de lua (¡o de windows o de alguien!) No genera el año completo. Debido a esto, las marcas de tiempo pueden parecer raras.

¡Esto también aprovecha las marcas de tiempo que pueden ser separadas por caracteres que no sean dígitos!

Gracias por notificarme sobre mi antigua referencia de math.abs y otras mejoras @thenumbernine :)

Lua 5.3, 151 bytes

Esto es 'copiar' el método de @ thenumbernine de mostrar la hora simplemente mostrando la marca de tiempo en lugar de la fecha real. Esto no es competitivo ya que creo que es un poco tramposo, solo lo publico aquí para mostrar mi trabajo :)

::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
fuente
1
Publicamos nuestras respuestas Lua casi al mismo tiempo. Eso tiene que decir algo sobre el viaje en el tiempo.
thenumbernine
Ajá, gracias @thenumbernine! Finalmente pude comentar :)
MeepDarknessMeep
2

C: 363 bytes

Minified usando este útil 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);}}

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

Ejemplo de ejecución:

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!

Podría deshacerme de 10 bytes quitando el sleepsupongo.

Por cierto, algunos manejos que saltan el tiempo para 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
fuente
Siéntase libre de soltar el sleep.
Ugoren
2

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

Nota: No se ha probado con una máquina en tiempo real.

Este código se ejecuta en Firefox, Chrome, Edge, Node.js Harmony (o io.js para el caso). Sin embargo, yo uso alert, por lo que tendrá que ser sustituido por console.logde nodo y 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}.`

Explicado:

// 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
AlcaldeMonty
fuente
Logré escribir uno aún más corto, es posible que desee echarle un vistazo y posiblemente mejorar el suyo. Además, creo que es genial!
Stefnotch
¿Qué tan grande fue su solución, quiero ver si puedo vencerla? ;)
MayorMonty
Desplácese hacia abajo o haga clic en el enlace: codegolf.stackexchange.com/a/61544/33160 ¡Además, está muy cerca de superarlo! : D
Stefnotch
2

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

Esto se debe mucho a la respuesta de Morgan Thrapp. El truco principal aquí es la normalización timedelta, que convenientemente hace que timedelta.days sea negativo cuando se mueve incluso un poco hacia el pasado, y 0 cuando se mueve menos de un día hacia el futuro.

han
fuente
Después de import*que no necesites el datetime.prefijo.
ugoren
@ugoren: import*permite escribir en datetime.now()lugar de datetime.datetime.now(). Tiene sentido, de alguna manera ...
Han
De una manera confusa, lo hace.
Ugoren
1

Caché ObjectScript, 199 bytes

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

Este problema se puede resolver en MUMPS antiguos, pero sería irrazonablemente largo, ya que ANSI MUMPS carece de la $ZD[ATE]T[IME]función intrínseca para formatear fechas en marcas de tiempo legibles por humanos.

Este programa probablemente no detectará viaje en el tiempo a antes del 1 Ene 1841, ni el viaje en el tiempo a partir del 31 de Dic de 9999, ya que estos son los límites de la $H[OROLOG]intrínseca cronometraje . Este programa también solo tiene precisión de segundo nivel; las fallas de tiempo al revés del sub-segundo nivel probablemente escaparán de su atención.

senshin
fuente
1

TSQL, 355 bytes

En el trabajo, por lo que no hay languges geniales que se queden con su servidor de producción de SQL Server =)

Versión de golf

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

Versión más legible con cambios menores.

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 no es tan malo con respecto a las marcas de tiempo ya que es un tipo de datos de primera clase.

Por el bien del golf, estamos utilizando un tipo con una precisión de 3 milisegundos. El ciclo en sí toma menos que eso para iterar (dependiendo de su servidor). La clave aquí es internamente que la marca de tiempo es flotante y el tipo entero cuenta cuántos días pasaron. Funcionará bien desde el 1 de enero de 1753 hasta el 31 de diciembre de 9999.

vaquero
fuente
1

VBA, 258 bytes

Funcionó con: Excel 2007 en Windows 7

305 bytes si se requiere usabilidad

ADVERTENCIA Esto PUEDE maximizar su CPU y Crash Excel / Windows si está en una computadora de un solo núcleo de un solo subproceso (muy probablemente encontrado 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 desea que este Código sea "comprobable", agregue Application.Wait (Now() + TimeValue("0:00:01"))despuésh=t

Salida

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.

A continuación se muestra el archivo de prueba que utilicé. Estoy sinceramente sorprendido de la poca seguridad que Windows tiene a veces. Puede no ejecutarse como se esperaba en todas las computadoras

¡Correr bajo su propio riesgo podría tener efectos secundarios importantes duraderos!
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
fuente
1

Javascript 173 169 162 bytes

Javascript es bastante popular ...

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

Explicación (versión anterior del código):

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
fuente
0

Procesamiento, 270 bytes

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

Expandido:

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

Salida de muestra:

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
fuente
0

Ruby, 160 157 155 154 bytes

Muchas cosas para jugar golf aquí

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
fuente
0

Mathematica, 295 bytes

El programa solicita al sistema operativo cada segundo un nuevo 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,"."})]];

Salida

Probado por alimentación manual en fecha / hora.

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.

Definitivamente podría tener un mejor formato de salida. Cumple con los requisitos establecidos.

Perdido en el conocimiento
fuente
¿Por qué atajas LocalTime[]? Aparece solo una vez en el siguiente código.
Michael Stern
En un momento, lo estaba usando dos veces. Buena captura sin embargo.
Perdido en el conocimiento
Elimínalo y guardarás tres caracteres.
Michael Stern
0

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}
K. Klassen
fuente
0

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