समय यात्रा का विरोधाभास

Question

एक आदमी के पास दो डिवाइस हैं।

• एक टाइम मशीन - वह सोचकर इस मशीन को नियंत्रित कर सकता है। यह उसे किसी भी समय अतीत या भविष्य के समय में किसी अन्य बिंदु से यात्रा करने की अनुमति देता है (या यहां तक ​​कि वर्तमान समय में) कुछ समय में नहीं। ध्यान दें कि यदि वह B से A तक अतीत की यात्रा करता है, तो A से B तक की सभी सामान्य घटनाएं (टाइम मशीन, अल्टरनेटर) को उसी तरह से दोहराना होगा। फिर बिंदु B से, उसे बिंदु A पर वापस ले जाया जाता है। इस प्रकार, एक एकल समय यात्रा एक अनंत लूप बनाती है।
• अल्टरनेटर - इस समस्या को महसूस करते हुए, वह एक और मशीन बनाता है। वह यह नोटिस करता है कि भले ही सभी शारीरिक घटनाएं एक पाश में दोहराई जाती हैं, लेकिन उसके विचार भिन्न हो सकते हैं। इसलिए इस मशीन को सोच समझकर नियंत्रित किया गया था। मशीन का उपयोग किसी भी समय एक वैकल्पिक भविष्य प्रदान करने के लिए किया जा सकता है (लेकिन अतीत नहीं) उस समय के संबंध में जब उसने इसका उपयोग किया।

उदाहरण

मैं एक लंबा उदाहरण का उपयोग कर सभी विवरण समझाता हूँ।

1000 T+250 250 T+0 500 T-200 100 T-50 125 A 225 T-400 500 A 100 T-200 150 T-25 100 T+100 50 A 25

• 1000 साल गुजर गए। यह वर्ष 1000 है।
• वह 1000 से 1250 तक यात्रा करता है।
• 250 साल गुजर गए। अभी साल 1500 है।
• वह 1500 से 1500 तक यात्रा करता है। इसका कोई प्रभाव नहीं है (और इसे अनदेखा किया जा सकता है)।
• 500 साल गुजर गए। अब वर्ष 2000 है
• वह 2000 से 1800 तक यात्रा करता है।
• 100 साल गुजर गए। अभी साल 1900 है।
• वह 1900 से 1850 तक यात्रा करते हैं।
• 125 वर्ष बीत चुके हैं: हालांकि, इस बार, जैसा कि वह एक पाश में है, चीजें अलग हैं। 50 साल 1850 से 1900 तक गुजरते हैं। वह 1850 से वापस लौट जाता है। 1850 से 1900 तक 50 साल गुजर जाते हैं। वह फिर से लौट आता है। 25 साल बीत गए और यह 1875 है, इस प्रकार 125 साल पूरे हो रहे हैं।
• वह अल्टरनेटर का उपयोग करता है। अब वर्ष 1875 में एक वैकल्पिक भविष्य मौजूद है, जो अब वह है। अतीत नहीं बदला है।
• 225 साल गुजर गए। अभी वर्ष २१०० है।
• वह 2100 से 1700 तक यात्रा करता है।
• 500 साल गुजरते हैं: 175 साल 1700 से 1875 तक सामान्य रूप से गुजरते हैं। नहीं, वह अल्टरनेटर से फिर से भिड़ता है, जिसका अर्थ है कि अब एक 3 जी भविष्य 1875 के बाद बनाया गया है। 325 वर्ष सामान्य रूप से गुजरते हैं, जिससे यह वर्ष 2200 हो जाता है।
• एक अल्टरनेटर का उपयोग करने का अब कोई प्रभाव नहीं है (और इसे नजरअंदाज किया जा सकता है) क्योंकि 2200 में केवल एक भविष्य मौजूद है जिसे अभी तक परिभाषित नहीं किया गया है।
• 100 साल गुजर गए। यह अब 2300 है।
• वह 2300 से 2100 तक यात्रा करता है।
• 150 वर्ष पास: 2100 से 2200 तक 100 वर्ष सामान्य रूप से पास होते हैं। एक दूसरा भविष्य 2200 से बन जाता है। 50 वर्ष बीत जाते हैं और यह वर्ष 2250 हो जाता है।
• वह 2250 से 2225 तक जाने वाला है। हालांकि, अब दो अलग-अलग समयसीमाओं में दो 2225 मौजूद हैं। इसलिए यह विरोधाभास की ओर जाता है, क्योंकि हम यह निर्धारित नहीं कर सकते हैं कि वह किस समय तक पहुंचेगा। (हम यह नहीं मानेंगे कि वह अधिक हालिया समयरेखा पर जाता है) इसलिए यह हमारे अनुकरण को समाप्त करता है।
• 100 T+100 50 A 25एक विरोधाभास के बाद से कुछ भी पूरी तरह से नजरअंदाज कर दिया गया है और हमारे सिमुलेशन ने चलना बंद कर दिया है।

संकेत: यदि आप उदाहरण को समझने के लिए संघर्ष कर रहे हैं, तो उस समय की कल्पना करें, जब आप पृथ्वी में खुदाई कर रहे हैं। यदि आप यात्रा कर रहे हैं, तो आप एक टेलीफ़ोन बना रहे हैं। यदि आप अल्टरनेटर का उपयोग कर रहे हैं, तो आप एक मौजूदा पथ की दीवार में एक नया रास्ता खोद रहे हैं।

विरोधाभास

मान लें कि A, B और C तीन बिंदु हैं (एक के बाद एक)। एक विरोधाभास कहा जाता है कि यदि आईएफएफ:

• आप एक बिंदु C पर हैं, एक बिंदु B पर एक अल्टरनेटर मौजूद है, B को इंगित करने के लिए एक से अधिक भविष्य मौजूद है (और आप उनमें से एक में हैं), और आप समय यात्रा के माध्यम से B और C के बीच किसी भी बिंदु तक पहुंचने का प्रयास करते हैं।
• आप एक बिंदु A पर हैं, एक बिंदु B पर एक अल्टरनेटर मौजूद है, B को इंगित करने के लिए एक से अधिक भविष्य मौजूद है, और आप समय यात्रा के माध्यम से एक बिंदु C (B के बाद) तक पहुँचने का प्रयास करते हैं।

इनपुट

उदाहरण के समान घटनाओं की एक श्रृंखला। (प्रारूप लचीला है।)

उत्पादन

एक सत्य / गलत मूल्य, यह दर्शाता है कि क्या एक विरोधाभास हुआ है।

चुनौती

सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

कैसा flexibleहै format?

— बिल्ली

@ GlennRanders-Pehrson ओह, मुझे वही मिला जो तुम्हारा मतलब था। संपादित।

— भूत_न_थे_कोड ०२s

@sysreq इनपुट में किसी भी अतिरिक्त विराम चिह्न (व्हाट्सएप, कॉमा, ब्रैकेट आदि) की अनुमति है। किसी भी चरित्र (ओं) को समय यात्रा और अल्टरनेटर के बीच अंतर करने की अनुमति है। किसी भी वर्ण (ओं) को + और - (आगे / पीछे की यात्रा) के बजाय उपयोग करने की अनुमति दी गई है। संख्या किसी भी आधार (बाइनरी, दशमलव, आदि) में हो सकती है। घटनाओं को उसी क्रम में दर्ज किया जाएगा। कोई वास्तविक वर्ष संख्याएं प्रदान नहीं की जाएंगी, आपको लगता है कि आपको शून्य (या किसी अन्य पूर्णांक) को शुरू करना चाहिए और वास्तविक वर्ष की संख्याओं को स्वयं पता लगाना होगा (यदि आपको आवश्यकता है)।

— ghosts_in_the_code

यह मेरी मदद करेगा अगर एक बड़े के बजाय कई छोटे उदाहरण थे, लेकिन मैंने अभी भी मतदान किया!

— उज्ज्वल

Answer 1

रूबी, 510 460 बाइट्स

p=[0];w=[n=x=0]
i=gets.split.map{|s|
if x!=1
if s[0]=="A"
w<<n
else
if s[0..1]=="T+"
t=n
q=s[2..-1].to_i
if w[-1]==t||(w[-1]>t&&w[-1]<n+q)
w<<w[-1]
n+=q
else
n+=(t<p[-1]&&n+q>p[-1])?q%(p[-1]-n):q
end
elsif s[0..1]=="T-"
t=n
p<<n
n-=s[2..-1].to_i
x=(x==0&&w[-1]>0&&t>w[-1]&&n>w[-1])?1:0
else
t=n
q=s.to_i
if w[-1]==t||(w[-1]>t&&w[-1]<n+q)
w<<w[-1]
n+=q
else
n+=(t<p[-1]&&n+q>p[-1])?q%(p[-1]-n):q
end
end
end
else
break
end}
p x

इनपुट

उदाहरण के अनुसार

उत्पादन

0 = कोई विरोधाभास नहीं, 1 = विरोधाभास

नमूना

नमूना इनपुट प्रदान किया गया: 1000 T+250 250 T+0 500 T-200 100 T-50 125 A 225 T-400 500 A 100 T-200 150 T-25 100 T+100 50 A 25 रिटर्न 1, एक विरोधाभास दर्शाता है।

टिप्पणियाँ

यह न केवल पहला कोडगॉल्फ व्यायाम है जो मैं प्रयास करता हूं, बल्कि यह पहला रूबी कार्यक्रम भी है जिसे मैंने लिखा है। इसलिए, यह शायद कम भी हो सकता है।

संक्षिप्त विवरण

p: Infinite loops
w: Alternate timelines
n: Now (regardless of timeline)
x: Paradox

अनंत लूप केवल समय में आगे की यात्रा करते समय होंगे। मैं किसी भी प्रतिक्रिया के लिए खुश हूं - खासकर अगर यह इसे हल करने के लिए एक बेहतर तरीका इंगित कर रहा है।

Comments

क्या आप कुछ नमूना इनपुट / आउटपुट डेटा प्रदान कर सकते हैं?

— एडिसन क्रम्प

@VoteToClose - प्रश्न में दिए गए डेटा के अलावा, यदि आवश्यक हो तो मैं और अधिक नमूना डेटा बना सकता हूं?

— पीटर एबोलिंस 4

ओह, गोश, मैं पूरी तरह से "नमूना" भाग से चूक गया। मैं बेवकूफ़ हूँ। +1

— Addison Crump

सभी thens अनावश्यक हैं और उन्हें हटाया जा सकता है। इसके अलावा, आपको अधिक वर्णों को सहेजने के {...}बजाय उपयोग करना चाहिए do...end। mapएक बाइट को बचाता है each, और splitडिफ़ॉल्ट रूप से व्हाट्सएप पर विभाजित करता है। आरंभीकरण की पहली चार पंक्तियों को छोटा किया जा सकता है p=[];w=[n=x=0]।

— दरवाज़े

मुझे पता है कि यह 3.5 साल (lol ..) है, लेकिन मुझे लगता है कि आप अपने वर्तमान कोड को 288 बाइट्स में बदल सकते हैं (पूरी तरह से सुनिश्चित नहीं हैं, क्योंकि मैं रूबी को अच्छी तरह से नहीं जानता हूं)। हालांकि, आपका वर्तमान कोड आगे के समय की यात्रा (ओपी के विवरण में दूसरा बुलेट-पॉइंट) के साथ विरोधाभास के लिए जिम्मेदार नहीं है।

— केविन क्रूज़सेन

Answer 2

05AB1E , 93 92 86 82 बाइट्स

ðU0V#vyAQiYˆðUëy.ïiYy+DX˜såàiXD€нY@Ïн©θ-®¥OÄ%®θY-YOVëVëYy¦+©¯@àXðʘà*i1q}XY®Ÿª{U®V

इनपुट, चुनौती विवरण में के स्वरूप में ही है, सिवाय इसके कि अल्टरनेटर Aहै abcdefghijklmnopqrstuvwxyzएक बाइट को बचाने के लिए के बजाय। विरोधाभास होने पर
आउटपुट 1या स्वयं इनपुट यदि नहीं (केवल 105AB1E में सत्य है, तो बाकी सब गलत है)।

मेरे जावा 10 जवाब पर आधारित है ।

इसे ऑनलाइन आज़माएं।

या इसके साथ ऑनलाइन डिबग-लाइन्स ( TODO: एक बार में सभी टेस्ट मामलों के साथ उचित टेस्ट सूट बनाएँ ) के
साथ इसे आज़माएं :): - पिछड़े समय-यात्रा विरोधाभास के साथ टेस्ट केस: इसे ऑनलाइन आज़माएं।
- फॉरवर्ड-ट्रैवल विरोधाभास के साथ टेस्ट केस: इसे ऑनलाइन आज़माएं।
- समय-यात्रा विरोधाभास के बिना परीक्षण मामला: इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

ðU                         # Set variable `X` (time-travels) to a space character " "
0V                         # Set variable `Y` (current year) to 0
#                          # Split the (implicit) input by spaces
 v                         # And loop over each event `y`:
  yAQi                     #  If the current event `y` is an alternator ("abcdefghijklmnopqrstuvwxyz"):
      Yˆ                   #   Add the current year `Y` to alternators-list `GB`
      ðU                   #   And reset variable `X` to " "
  ëy.ïi                    #  Else-if the current event `y` is an integer:
       Yy+                 #   Calculate the current year `Y` plus the integer `y`
          D                #   Duplicate `Y+y`
           X˜såài          #   If this `Y+y` is within any of the time-travel ranges:
                 X €н      #    Get the starting positions of each time-travel
                     Y@    #    Check for each starting position if the current year `Y` is >= it
                  D    Ï   #    And only leave the time-travel ranges for which this is truthy
                        н  #    Then pop and push the first one
                         © #    Store this time-travel range in variable `r` (without popping)
                 θ         #    Pop and only leave the time-travel destination
                  -        #    Subtract it from the `Y+y` we duplicated
                       %   #    And modulo it with:
                   ®¥OÄ    #     The absolute distance of the time-travel `r`
                 ®θ        #    Then push the time-travel destination again
                   Y-      #    And subtract the current year `Y`
                 YO        #    Then sum these two and the current year `Y` together
                   V       #    And pop and store it as new year `Y`
       ë                   #   Else (`Y+y` is not within any time-travel ranges)
        V                  #    Simply pop and store the duplicated `Y+y` as new year `Y`
  ë                        #  Else (the current event `y` is a time-travel)
    y¦                     #   Remove the leading "T"
   Y  +                    #   And add the value to the current year `Y`
       ©                   #   Store this value in variable `r`
        ¯@à                #   Check if any alternator in list `GB` is >= this value
           XðÊ˜à           #   Check if there are any time-travels
                *i  }      #   And if both are truhy:
                  1        #    Push a 1
                   q       #    Stop the program
                           #    (after which the top of the stack is output implicitly)
    Y®Ÿ                    #   Create a list in the range [current year `Y`, new year `r`]
   X   ª                   #   Append it to the time-travels `X`
        {                  #   And then sort these time-travels
         U                 #   After which we pop and store it as updated `X`
   ®V                      #   And then set `Y` to the new year `r`
                           # (if we haven't reached `q`, the (implicit) input is output instead)

Answer 3

जावा 10, 498 485 478 बाइट्स

import java.util.*;s->{var a=new Stack<Long>();var m=new TreeMap<Long,Long>();long p=0,c=0,t,v,k;o:for(var S:s.split(" "))if((t=S.charAt(0))>65){var b=S.charAt(1)>44;v=new Long(S.substring(2));for(var A:a)p=A>c+(b?-v:v)|m.size()<1?p:1;if(v>0)m.put(c,b?c-v:c+v);c+=b?-v:v;}else if(t>64){a.add(c);m.clear();}else{t=new Long(S);e:for(var e:m.entrySet())if((k=e.getKey())>=c){for(v=c;v<=c+t;)if(a.contains(v++))break e;c=(v=e.getValue())+(c+t-v)%(k-v);continue o;}c+=t;}return p>0;}

इनपुट (अभी के लिए) एक ही प्रारूप में चुनौती विवरण में है।

-13 बाइट्स @BenjaminUrquhart को धन्यवाद ।
-7 बाइट्स @ceilingcat की बदौलत ।

इसे ऑनलाइन आज़माएँ या जोड़े गए डीबग-लाइनों के साथ इसे ऑनलाइन आज़माएँ ।

स्पष्टीकरण:

import java.util.*;            // Required import for the List and TreeMap
s->{                           // Method with String parameter and boolean return-type
  var a=new Stack<Long>();     //  Create a List for the alternators
  var m=new TreeMap<Long,Long>();
                               //  Create a sorted Map for the time-travels
  long p=0,                    //  Paradox-flag, initially 0
       c=0,                    //  Current year, initially 0
       t,v,k;                  //  Temp-values, uninitialized
  o:for(var S:s.split(" "))    //  Loop over the input substrings split by space:
    if((t=S.charAt(0))>65){    //   If the first character is a 'T':
      var b=S.charAt(1)>44;    //    Check if the second character is a '-'
      v=new Long(S.substring(2));
                               //    Convert the String-value to a number
      for(long A:a)            //    Loop over the alternators
        p=A>                   //     If an alternator is larger than:
            c+                 //      The current year, plus
              (b?              //      If we travel backwards in time:
                 -v            //       Subtract the value
                :              //      Else (we travel forward in time):
                 v)            //       Add the value
          |m.size()<1?         //     Or if no previous time-travels occurred:
           p                   //      Leave the paradox-flag the same
          :                    //     Else:
           1;                  //      Set the paradox-flag to 1
      if(v>0)                  //     If the value is not 0 (edge-case for "T+0")
        m.put(c,b?c-v:c+v);    //      Add the from-to time-travel to the Map
      c+=b?-v:v;}              //     Increase/decrease the year accordingly
    else if(t>64){             //   Else-if the character is an 'A':
      a.add(c);                //    Add the current year to the alternators-list
      m.clear();}              //    And empty the time-travel Map
    else{                      //   Else (it's a number)
      t=new Long(S);           //    Convert the String to a number
      e:for(var e:m.entrySet())//    Loop over the time-travels:
        if((k=e.getKey())      //     If the time-travel starting point is
                         >=c){ //     larger than or equal to the current year
          for(v=c;v<=c+t;)     //      Loop from the current year to the year+number:
            if(a.contains(v++))//       If the alternator-list contains any of these years
              break e;         //        Stop the time-travel loop
          c=                   //      Set the current year to:
             (v=e.getValue())  //       The time-travel destination
             +                 //       Plus:
              (c+t             //        The current year plus the number
                  -v)          //        minus the time-travel destination
                     %(k-v);   //        Modulo the time-travel from-to distance
          continue o;}         //      And then continue the outer input-loop
      c+=t;}                   //    Increase the current year by the number 
  return p>0;}                 //  Return whether the paradox-flag is 1

Comments

उपयोग क्यों नहीं Long?

— बेंजामिन उरक्हार्ट

@BenjaminUrquhart अच्छा सवाल .. शुरू में मेरी सूची और मानचित्र कच्चे टाइप के थे, इसलिए intकम थे, लेकिन इसने मैप-एंट्री कीवाल्यू-पेयर के साथ त्रुटियां दीं। उसके बाद लंबे समय तक सब कुछ बदलने के बारे में नहीं सोचा था .. धन्यवाद -13 के लिए!

— केविन क्रूज़सेन