Bilgisayarlar günümüzde her yerde - otomobillerde, trenlerde, kaykaylarda, hatta nükleer reaktörlerde. Yazılımınızın bir zaman yolculuğu cihazında çalışabilme olasılığı sadece bir zaman meselesidir. Bununla baş edebilir misin? En azından tespit edebilir misin?

Senin görevin:

1. Zaman yolculuğunu algılamak için döngüyü ve sistem zamanını sorgulamaya devam eden bir program yazın.
2. Zaman art arda iki sorgu arasında bir gün veya daha fazla ileri giderse, ileri zaman yolculuğu olur. Bu durumda, programınız yazdırılmalıdır:
   TS TS: YYYY? You mean we're in the future?
3. Zaman arka arkaya iki sorgu arasında herhangi bir miktarda geriye doğru hareket ederse, geriye doğru zaman yolculuğu olur. Bu durumda, programınız yazdırılmalıdır:
   TS TS: Back in good old YYYY.
4. TS TSzaman yolculuğu öncesinde ve sonrasında zaman damgalarıdır. YYYYHedef yıl.
5. Zaman damgaları, en az 4 basamaklı yıl, ay, gün, saat, dakika ve saniyeyi içeren ve rakamsız olarak ayrılmış herhangi bir biçimde olabilir.

Sınırlamalar:

1. En azından 19., 20. ve 21. yüzyıllarda tarihleri ​​desteklemelisiniz.
2. Bu meydan okuma yayınlanmadan önce varolan bir dili kullanmanız gerekir.
3. Cevaplarınızı yalnızca bu zorluk gönderildikten sonra göndermelisiniz.
4. Cevabınız gönderilmeden önce var olan bir dili kullanmanız gerekir.
5. Yanıtınızı ancak gönderdikten sonra düzenleyebilirsiniz.
6. Programınız, istenen çıktı dışında herhangi bir çıktı yazdırmamalıdır. Arada bir "Büyük Scott!" izin verilir.

Bu kod golfü. En kısa cevap kazanır.
İlgili film referansları büyük olasılıkla cevabınızı çok uzun sürebilir, ancak sizi olumlu etkileyebilir.

CJam, 118 bayt

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

Bu çevrimiçi tercüman ile çalışmıyor.

Bilgisayarımın zamanını iki kez ayarladıktan sonra örnek çıktı:

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 bayt

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

Zaman damgaları, YYYY-MM-DD HH:MM:SSnoktalı virgülle ayrılmış biçimde formatta yazdırılır . Yazdırmak için 2 karakterden kısa olduğu için 3'ten Python 2'ye geçti. Spams ile stdout'a Great Scott!için normies o daha koşullu baskı kurmak bunu daha kolay ve ucuz olduğundan, sigara zamanlı yolcuları.

JavaScript (ES6), 263 bayt

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

Bu muhtemelen onu daha verimli / küçük hale getirmek için bazı yeniden yazmalarla yapılabilir.

Kaynak:

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)

Şu anda Büyük Scott'ı yazdırmıyor, çünkü yalnızca ara sıra yapmanın iyi bir yolunu bulamıyorum.

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 bayt

Bunu henüz boyutuna indirecek zamanım olmadı. Eminim orada saklanan birkaç optimizasyon vardır.

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 (ve çok daha okunaklı):

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

Düzenleme: Bir insandan ziyade OS'ye zaman soracak şekilde düzeltildi.

Lua 5.3, 174 bayt

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

Buna "1 Ocak 1970'ten bu yana saniye" biçimini kullanarak özgürlük aldı "Zaman damgaları herhangi bir biçimde olabilir" kuralı ... off ağır oynuyor


ben damgaları baskı benim kalitesiz yorumunu tutmak ve kabul ederse MeepDarknessMeep'in yapısını (etik olmayan şekilde) aşağı doğru sıkarak ...

155 bayt

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 bayt

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

Yan not: Eğer bir yıl sayısına ihtiyaç duymazsanız altı bayt çıkarın. Bunun nedeni, Lua'nın (veya pencerelerin veya birinin!)% C'nin tüm yılı vermemesidir. Bu nedenle, zaman damgaları tuhaf görünebilir!

Bu aynı zamanda, herhangi bir rakam olmayan karakterle ayrılabilen zaman damgalarının avantajlarından da yararlanır!

Eski math.abs referansımı ve diğer geliştirmeleri @thenumbernine bildirdiğin için teşekkürler :)

Lua 5.3, 151 bayt

Bu, @ thenumbernine'ın gerçek görüntüleme yerine sadece zaman damgasını göstererek zamanı gösterme yönteminden 'kopyalamaktır'. Bu rekabetçi değil çünkü biraz aldatma olduğunu düşünüyorum, sadece çalışmamı görüntülemek için buraya gönderiyoruz :)

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

Bu kullanışlı komut dosyası kullanılarak küçültülmüş :

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

Orijinal:

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

Örnek çalışma:

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!

sleepSanırım çıkararak 10 bayttan kurtulabilirdim .

Bu arada, Mac / Linux için biraz zaman atlamalı el işçiliği:

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 Bayt

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

Not: Gerçek zamanlı bir makine ile test edilmemiştir.

Bu kod Firefox, Chrome, Edge, Node.js Harmony (veya bu konuda io.js ) ile çalışır. Ama kullandığım alerto yerini gerekecektir böylece console.logiçin Düğüm ve Io Desteğini: (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}.`

Açıklaması:

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

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

Bu Morgan Thrapp'ın cevabına çok şey borçlu. Buradaki temel numara, normalde zamanlamaelta.days'i hafifçe hareket ederken negatif, günden güne daha da hafif hareket ederken 0'ı olumsuz yapan timedelta normalizasyonudur.

Caché ObjectScript, 199 bayt

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

Bu sorun, düz eski MUMPS'de çözülebilir, ancak ANSI MUMPS, tarihleri ​​insan tarafından okunabilen zaman damgalarına biçimlendirmek için $ZD[ATE]T[IME]iç işlevden yoksun olduğundan makul olarak uzun olacaktır .

Bunların sınırları olduğu için, bu programın büyük olasılıkla, sonra 31 Aralık 9999 önce 1 Ocak 1841 ile zaman-seyahat, ne de zaman yolculuğu algılamaz içsel zaman işleyişi . Bu program aynı zamanda sadece ikinci seviye hassasiyete sahiptir; alt-ikinci seviye geriye doğru zaman hataları muhtemelen farkına varmayacaktır.$H[OROLOG]

TSQL, 355 bayt

İşte bu nedenle, SQL Server üretim sunucunuzla hiçbir süslü serin dilimleriniz kalmaz =)

Golf versiyonu

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

Küçük değişiklikler ile daha okunabilir versiyonu.

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, birinci sınıf bir veri türü olduğundan zaman damgaları açısından o kadar da kötü değildir.

Golf uğruna 3 milisaniye hassasiyetinde bir tip kullanıyoruz. Döngünün kendisi yinelemekten daha azını alır (sunucunuza bağlı olarak). Burada anahtar, zaman damgasının bir kayan nokta olduğu içseldir ve tamsayı türü kaç gün geçtiğini sayar. 1 Ocak 1753 - 31 Aralık 9999 tarih aralığında işe yaramıyor.

VBA, 258 Bayt

Şununla koştu: Windows 7'de Excel 2007

Kullanılabilirlik gerekirse 305 bayt

UYARI Bu, Tek Dişli bir tek çekirdekli bilgisayardaysanız (muhtemelen 1985'te bulunur) CPU ve Crash Excel / Windows'unuzu Maks.

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

Bu Kod sonra add "Test edilebilir" olmak istiyorsak Application.Wait (Now() + TimeValue("0:00:01"))sonrah=t

Çıktı

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şağıda kullandığım test dosyası. Dürüstçe Windows bazen ne kadar az güvenlik, de şaşırdım. Tüm bilgisayarlarda beklendiği gibi çalışmayabilir

Kendi Riski Altında Kalan Başlıca Kalıcı Etkiler Olabilir !!!!
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 bayt

Javascript oldukça popüler ...

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

Açıklama (Kodun eski versiyonu):

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

İşlem, 270 bayt

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

Expanded:

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

Örnek çıktı:

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 bayt

Burada golf oynamak için bir sürü şey var

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 bayt

Program işletim sisteminden her saniye yeni TS istemektedir.

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,"."})]];

Çıktı

Tarih / saatte elle besleme ile test edilmiştir.

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.

Kesinlikle çıktıyı daha iyi biçimlendirebilirdi. Belirtildiği şekilde şartları yerine getirir.

Groovy, 244 bayt

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

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