51

आजकल कंप्यूटर हर जगह हैं - कारों, ट्रेनों, स्केटबोर्ड, यहां तक कि परमाणु रिएक्टरों में भी। एक समय यात्रा उपकरण में आपका सॉफ़्टवेयर चलने की संभावना बस कुछ ही समय है। क्या आप इससे निपट सकते हैं? क्या आप कम से कम इसका पता लगा सकते हैं?

आपका कार्य:

एक कार्यक्रम लिखें जो समय यात्रा का पता लगाने के लिए सिस्टम समय को लूप करता है और क्वेरी करता रहता है।
यदि समय लगातार दो या दो से अधिक प्रश्नों के बीच आगे बढ़ता है, तो यह समय यात्रा है। इस स्थिति में, आपका कार्यक्रम प्रिंट होना चाहिए:
TS TS: YYYY? You mean we're in the future?
यदि समय दो अलग-अलग प्रश्नों के बीच, किसी भी राशि से वापस जाता है, तो यह बैकवर्ड टाइम यात्रा है। इस स्थिति में, आपका कार्यक्रम प्रिंट होना चाहिए:
TS TS: Back in good old YYYY.
TS TSसमय यात्रा से पहले और बाद में टाइमस्टैम्प हैं। YYYYगंतव्य वर्ष है।
टाइमस्टैम्प किसी भी प्रारूप में हो सकता है, जिसमें कम-से-कम 4-अंकीय वर्ष, महीना, दिन, घंटा, मिनट और दूसरा, गैर-अंकीय द्वारा अलग किया गया हो।

सीमाएं:

आपको कम से कम 19 वीं, 20 वीं और 21 वीं सदी में तारीखों का समर्थन करना चाहिए।
इस चुनौती को पोस्ट करने से पहले मौजूद भाषा का उपयोग करना चाहिए।
इस चुनौती के पोस्ट होने के बाद ही आपको अपने उत्तर पोस्ट करने होंगे।
आपको ऐसी भाषा का उपयोग करना चाहिए जो आपके उत्तर को पोस्ट करने से पहले मौजूद थी।
पोस्ट करने के बाद ही आप अपना उत्तर संपादित कर सकते हैं।
आपके प्रोग्राम को आवश्यक आउटपुट के अलावा किसी भी आउटपुट को प्रिंट नहीं करना चाहिए। एक सामयिक "महान स्कॉट!" की अनुमति है।

यह कोड-गोल्फ है। सबसे छोटा जवाब जीत जाता है।
प्रासंगिक मूवी के संदर्भ शायद आपका उत्तर बहुत लंबा कर देंगे, लेकिन हो सकता है कि आप आगे बढ़ें।

code-golf date

— ugoren
स्रोत

31

अधिक झूठ बोलने वाले प्रोग्रामर समय के बारे में मानते हैं, # 36 : " समय हमेशा आगे की ओर जाता है। "

— डॉर्कनोब

4

क्या आप # 5 के बारे में कुछ अधिक विशिष्ट हो सकते हैं?

— मेगो

4

nondigits द्वारा अलग? बू। YYYYMMDDHHmmSS मेरा पसंदीदा टाइमस्टैम्प प्रारूप है।

— शुक्राणु

3

@ असमानता आप कैसे जानते हैं? हो सकता है कि सिस्टम क्लॉक वास्तव में अपरिवर्तनीय हो और "सेटिंग" हो, यह वास्तव में यात्रा का समय है

— रुण FS

5

सीमा 2,3,4,5 वास्तव में कठोर हैं, मुझे नहीं पता कि क्या मैं इसे संभाल सकता हूं।

— सुर्त

4

सीजेएम, 118 बाइट्स

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

यह ऑनलाइन दुभाषिया के साथ काम नहीं करता है।

मेरे कंप्यूटर के समय को दो बार समायोजित करने के बाद नमूना आउटपुट:

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.

— डेनिस
स्रोत

1

क्यों यह ऑनलाइन दुभाषिया के साथ काम नहीं करता है (सिवाय इसके कि यह आपको समय के साथ बेला नहीं देता)?

— बदसूरत

1

क्योंकि यह एक अनंत लूप है, और ऑनलाइन दुभाषिया कार्यक्रम समाप्त होने के बाद ही आउटपुट दिखाता है।

— डेनिस

1

तो आप कैसे परीक्षण करते हैं कि यह काम करता है?

— ugoren

1

जावा दुभाषिया का उपयोग करना ।

— डेनिस

9

पायथन 2, 210 बाइट्स

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

टाइमस्टैम्प को YYYY-MM-DD HH:MM:SSप्रारूप में मुद्रित किया जाता है, अर्धविरामों के साथ अलग किया जाता है। 3 से पायथन 2 पर स्विच किया गया क्योंकि यह प्रिंट करने के लिए 2 चार्ट छोटा है। Spams साथ stdout Great Scott!के लिए ~~normies~~ , गैर समय यात्रियों के बाद से यह आसान और सस्ता है की तुलना में एक सशर्त प्रिंट की स्थापना की है कि क्या करना है।

— मेगो
स्रोत

क्या यह इनपुट के रूप में समय की उम्मीद करता है? यह नहीं पूछा गया है (शायद यह अस्पष्ट है)। इसके अलावा, जब समय अच्छा बर्ताव करता है तो यह खाली लाइनों को प्रिंट करता है।

— बदसूरत

मेरा मतलब था OS से पूछना, उपयोगकर्ता नहीं। मैं स्पष्ट कर दूंगा।

— बदसूरत

8

जावास्क्रिप्ट (ईएस 6), 263 बाइट्स

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

यह शायद इसे और अधिक कुशल / छोटा बनाने के लिए कुछ पुनर्लेखन के साथ कर सकता है।

स्रोत:

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

— फ्लोरी
स्रोत

1

बैकवर्ड यात्रा को एक दिन नहीं, बल्कि किसी भी राशि से आगे बढ़ने के रूप में परिभाषित किया गया है। इसके अलावा, कई now()कॉल के कारण यह एक यात्रा की घटना को याद कर सकता है।

— बदसूरत

इसे गोल्फ करने का एक प्रयास: n = दिनांक, o = n.now (); सेटइंटरवल ("d = new n, s = d +` $ {new n (o)} `; f = d.getFullYear) (;; n.now () - o> 8.64e + 7) कंसोल.लॉग (s + f + `? आपका मतलब है कि हम भविष्य में हैं?`), अगर (o> n.now ()) कंसोल.लॉग (s + `) अच्छे पुराने $ {f} .`) में वापस; o = n.now () ", 100);

— स्टीफनोट

मुझे लगता है कि आप पहले भाग को गोल्फ कर सकते हैं o=(n=Date).now()।

— कॉनर ओ'ब्रायन

+ Stefnotch 8.64e+7दो वर्णों से अधिक लंबा है 86400।

— फ़्लोरी

1

@ C @O'Bʀɪᴇɴ उफ़! मैं सोच रहा था कि यह काम क्यों नहीं किया।

— फ्लोर्री

5

पायथन 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)

वर्तमान में ग्रेट स्कॉट प्रिंट नहीं करता है क्योंकि मुझे केवल इसे सामयिक बनाने का अच्छा तरीका नहीं मिल रहा है।

— मॉर्गन थ्राप्प
स्रोत

5

बैश + कोरुटिल्स, 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?"
}

— डिजिटल आघात
स्रोत

3

रूबी, 194 बाइट्स

मेरे पास वास्तव में अभी तक आकार में कटौती करने का समय नहीं है। मुझे यकीन है कि वहां कुछ अनुकूलन छिपे हुए हैं।

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 (और बहुत अधिक पठनीय):

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

संपादित करें: मानव के बजाय ओएस के लिए समय पूछने के लिए सही।

— PotatoOmeletteSandwich
स्रोत

2

कुछ सिफारिशें: loop{}इसके बजाय का उपयोग करें while 1...end, और +प्रक्षेप के बजाय स्ट्रिंग संघनन के लिए उपयोग करने का प्रयास करें ।

— वॉइकिया

3

लुआ 5.3, 174 बाइट्स

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

यह भारी नियम "मुहर किसी भी प्रारूप में हो सकता है" ... जो मैं "1 जनवरी, 1970 के बाद से सेकंड" के प्रारूप का उपयोग कर की स्वतंत्रता ले लिया से दूर खेल रहा है

अगर मैं मुद्रण टाइम स्टांप की मेरी घटिया व्याख्या रखने के लिए, और अपनाने MeepDarknessMeep की संरचना, मैं (अनैतिक रूप से) इसे नीचे निचोड़ सकता हूं ...

155 बाइट्स

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
स्रोत

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.

- कि युग के बाद सेकंड की अनुमति नहीं है।

— मेघ

4

अच्छी बात यह है कि किसी भी प्रारूप को "बहिष्कृत" नहीं किया

— तत्पश्चात

@ यूगोरेन वास्तव में आवश्यकता आपके इरादे के अनुसार अधिक विशिष्ट होनी चाहिए

— मेगो

मैं लुआ से पूरी तरह परिचित नहीं हूं इसलिए मैं गलत हो सकता हूं, लेकिन यह इस प्रिंट की तरह दिखता है Back in good ol YYYYलेकिन इसे प्रिंट करना चाहिए Back in good old YYYY। (पुराने में डी नोट करें)

— Pokechu22

नहीं अच्छा पकड़, मैं जहाँ भी मैं :-P सकता बाइट्स दाढ़ी बनाने के लिए कोशिश कर रहा था

— thenumbernine

2

लुआ 5.3, 179 178 173 171 169 168 163 बाइट्स

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

साइड नोट: यदि आप पूरे वर्ष की संख्या की आवश्यकता को पूरा करते हैं तो छह बाइट घटाएं। कारण यह है कि लुआ (या विंडोज़ 'या किसी का!)% C पूरे वर्ष आउटपुट नहीं करता है। इस वजह से, टाइमस्टैम्प अजीब लग सकता है!

यह भी किसी भी गैर अंक पात्रों द्वारा अलग होने में सक्षम होने के लिए टाइमस्टैम्प का लाभ उठाता है!

मेरे पुराने math.abs संदर्भ और अन्य सुधार @thenumbernine की सूचना देने के लिए धन्यवाद :)

लुआ 5.3, 151 बाइट्स

यह वास्तविक समय के बजाय सिर्फ टाइमस्टैम्प दिखा कर समय प्रदर्शित करने की @ तत्कालीन विधि की 'नकल' है। यह प्रतिस्पर्धी नहीं है क्योंकि मुझे लगता है कि यह एक धोखा है, बस इसे यहाँ पोस्ट करके अपना काम प्रदर्शित करूँगा :)

::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
स्रोत

1

हमने लगभग ठीक उसी समय अपने दोनों लुआ उत्तर पोस्ट किए। समय यात्रा के बारे में कुछ कहना है।

— तत्कालीन नायिका

अहा, थैंक्स @thenumbernine! मुझे आखिरकार टिप्पणी करने की मेरी क्षमता मिल गई :)

— MeepDarknessMeep

2

C: 363 बाइट्स

इस आसान स्क्रिप्ट का उपयोग करते हुए न्यूनतम :

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

मूल:

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

उदाहरण रन:

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!

मैं sleepअनुमान लगाकर 10 बाइट्स निकाल सकता था ।

वैसे, मैक / लिनक्स के लिए कुछ समय-कूदने वाला हाथ:

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!

— एंड्रयू ई
स्रोत

बेझिझक गिरा देना sleep।

— बदसूरत

2

जावास्क्रिप्ट (ईएस 6) 181 174 170 बाइट्स

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

नोट: एक वास्तविक समय मशीन के साथ परीक्षण नहीं किया गया है।

यह कोड फ़ायरफ़ॉक्स, क्रोम, एज, Node.js हार्मनी (या उस मामले के लिए io.js ) में चलता है। लेकिन, मुझे का उपयोग alert, कि द्वारा प्रतिस्थापित किया जा करना होगा ताकि console.logके लिए नोड और आईओ Suport: (187 बाइट्स)

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

व्याख्या की:

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

— MayorMonty
स्रोत

मैं एक और भी छोटा लिखने में कामयाब रहा, आप शायद इस पर एक नज़र रखना चाहते हैं और संभवतः आपको बेहतर बना सकते हैं। इसके अलावा, मुझे लगता है कि यह बहुत अच्छा है!

— स्टेफनोट

आपका समाधान कितना बड़ा था, मैं देखना चाहता हूं कि क्या मैं इसे हरा सकता हूं? ;)

— मेयरमोनी

नीचे स्क्रॉल करें या लिंक पर क्लिक करें: codegolf.stackexchange.com/a/61544/33160 इसके अलावा, आप इसे मारने के लिए बहुत करीब हैं! : डी

— स्टेफनोच

2

पायथन, 170 165 बाइट्स

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

यह मॉर्गन थ्राप्प के जवाब के लिए बहुत कुछ है। यहां की मुख्य चाल समयबद्धता सामान्यीकरण है, जो आसानी से समय की ओर थोड़ा आगे बढ़ने पर, और भविष्य में एक दिन से भी कम समय होने पर 0 से आगे बढ़ने पर आसानी से समय पर नकारात्मक बनाता है।

— हान
स्रोत

import*आप datetime.उपसर्ग की जरूरत नहीं है के बाद ।

— ugoren

@ यूगोरेन: import*एक के datetime.now()बजाय लिखने की अनुमति देता है datetime.datetime.now()। यह एक तरह से एक तरह से समझ में आता है, ...

— हान

भ्रामक तरीके से, यह करता है।

— ugoren

1

कैच ऑब्जेक्टस्क्रिप्ट, 199 बाइट्स

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

यह समस्या सादे पुराने MUMPS में हल करने योग्य है, लेकिन अनुचित रूप से लंबा होगा, क्योंकि ANSI MUMPS में मानव-पठनीय टाइमस्टैम्प में तिथियों को प्रारूपित करने के लिए आंतरिक कार्य का अभाव है$ZD[ATE]T[IME] ।

इस कार्यक्रम शायद, के बाद 31 दिसंबर 9999 को पहले 1 जनवरी 1841 तक समय यात्रा, और न ही समय-साथी का पता नहीं लगा होगा क्योंकि इन की सीमा से कर रहे हैं समयनिर्धारक आंतरिक । इस कार्यक्रम में भी केवल दूसरे स्तर की सटीकता है; उप-सेकंड-लेवल बैकवर्ड टाइम ग्लिच संभवतः इसकी सूचना से बच जाएगा।$H[OROLOG]

— senshin
स्रोत

1

TSQL, 355 बाइट्स

काम पर कोई फैंसी शांत languges अपने SQL सर्वर उत्पादन सर्वर =) के साथ रहना

गोल्फ संस्करण

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

छोटे परिवर्तनों के साथ अधिक पठनीय संस्करण।

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 टाइमस्टैम्प के संबंध में SQL इतना बुरा नहीं है क्योंकि यह प्रथम श्रेणी का डेटा प्रकार है।

गोल्फ की खातिर हम 3 मिलीसेकंड परिशुद्धता के साथ एक प्रकार का उपयोग कर रहे हैं। लूप खुद को कम करता है जो कि इसे पुनरावृत्त करता है (आपके सर्वर के आधार पर)। यहाँ कुंजी आंतरिक है कि समय टिकट एक फ्लोट है और पूर्णांक प्रकार गिना जाता है कि कितने दिन बीत गए। यह 31 दिसंबर, 9999 तारीख सीमा के माध्यम से 1 जनवरी, 1753 में ठीक काम करता है।

— जीन
स्रोत

1

VBA, 258 बाइट्स

साथ भाग गया: विंडोज 7 में एक्सेल 2007

यदि आवश्यक हो तो 305 बाइट्स

यदि आप अपने सीपीयू और क्रैश एक्सेल / विंडोज को देख रहे हैं, यदि आप सिंगल थ्रेडेड सिंगल कोर कंप्यूटर पर हैं (सबसे अधिक संभावना 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

यदि आप चाहते हैं कि यह कोड "परीक्षण योग्य" हो तो Application.Wait (Now() + TimeValue("0:00:01"))बाद में जोड़ेंh=t

उत्पादन

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.

नीचे मैंने परीक्षण फ़ाइल का उपयोग किया है। मैं ईमानदारी से हैरान हूँ कि कभी-कभार कम सुरक्षा वाला विंडोज कैसा होता है। सभी कंप्यूटरों पर अपेक्षित रूप से नहीं चल सकता है

खुद के जोखिम पर चलाएं मेजर स्थायी दुष्प्रभाव हो सकते हैं !!!!
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
स्रोत

1

जावास्क्रिप्ट 173 169 162 बाइट्स

जावास्क्रिप्ट बहुत लोकप्रिय है ...

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

स्पष्टीकरण (कोड का पुराना संस्करण):

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
स्रोत

0

प्रसंस्करण, 270 बाइट्स

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

विस्तारित:

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

नमूना उत्पादन:

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

— केविन कर्मकार
स्रोत

0

रूबी, 160 157 155 154 बाइट्स

यहाँ गोल्फ के लिए बहुत सारी चीज़ें

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}

— पीटर लेनकेफी
स्रोत

0

गणितज्ञ, 295 बाइट्स

कार्यक्रम नए टीएस के लिए ओएस को हर सेकंड पूछता है।

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

उत्पादन

तारीख / समय में मैन्युअल रूप से खिलाकर परीक्षण किया गया।

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.

निश्चित रूप से आउटपुट को बेहतर स्वरूप दे सकता है। यह आवश्यकताओं को पूरा करता है जैसा कि कहा गया है।

— ज्ञान में खो गया
स्रोत

आप शॉर्टकट क्यों करते हैं LocalTime[]? यह निम्न कोड में केवल एक बार दिखाई देता है।

— माइकल स्टर्न

एक बिंदु पर, मैं इसे दो बार उपयोग कर रहा था। हालांकि अच्छा कैच।

— नॉलेज

इसे निकालें और आप तीन वर्णों को सहेजते हैं।

— माइकल स्टर्न

0

ग्रूवी, 244 बाइट्स

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}

— के। क्लासेन
स्रोत

0

जावा, 378 बाइट्स।

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
स्रोत

टाइम ट्रेवल का पता लगाएं

सीजेएम, 118 बाइट्स

पायथन 2, 210 बाइट्स

जावास्क्रिप्ट (ईएस 6), 263 बाइट्स

पायथन 3, 195

बैश + कोरुटिल्स, 177

रूबी, 194 बाइट्स

लुआ 5.3, 174 बाइट्स

155 बाइट्स

लुआ 5.3, 179 178 173 171 169 168 163 बाइट्स

लुआ 5.3, 151 बाइट्स

C: 363 बाइट्स

जावास्क्रिप्ट (ईएस 6) 181 174 170 बाइट्स

पायथन, 170 165 बाइट्स

कैच ऑब्जेक्टस्क्रिप्ट, 199 बाइट्स

TSQL, 355 बाइट्स

VBA, 258 बाइट्स

साथ भाग गया: विंडोज 7 में एक्सेल 2007

उत्पादन

जावास्क्रिप्ट 173 169 162 बाइट्स

प्रसंस्करण, 270 बाइट्स

रूबी, 160 157 155 154 बाइट्स

गणितज्ञ, 295 बाइट्स

उत्पादन

ग्रूवी, 244 बाइट्स

जावा, 378 बाइट्स।