ผู้ชายมีอุปกรณ์สองชิ้น

• A time machine - เขาสามารถควบคุมเครื่องจักรนี้ได้โดยการคิด ช่วยให้เขาสามารถเดินทางจากจุดใด ๆ ในเวลาไปยังจุดอื่นในเวลาในอดีตหรืออนาคต (หรือแม้แต่จุดปัจจุบันในเวลา) ในเวลาไม่นานเลย โปรดทราบว่าหากเขาเดินทางไปที่ผ่านมาจาก B ถึง A เหตุการณ์ปกติทั้งหมด (ไทม์แมชชีนนอกเวลา, ตัวแยกกระแสสลับ) จาก A ถึง B ต้องทำซ้ำในลักษณะเดียวกัน จากจุด B เขาจะถูกนำกลับไปยังจุด A ดังนั้นการเดินทางข้ามเวลาครั้งเดียวจะสร้างวงวนไม่สิ้นสุด
• Alternator - ตระหนักถึงปัญหานี้เขาสร้างเครื่องอื่น เขาสังเกตเห็นว่าแม้ว่าเหตุการณ์ทางกายภาพทั้งหมดจะเกิดขึ้นซ้ำแล้วซ้ำอีกความคิดของเขาอาจแตกต่างออกไป ดังนั้นเครื่องนี้ถูกออกแบบมาให้สามารถควบคุมได้ด้วยความคิดเช่นกัน เครื่องจักรสามารถใช้งานได้ตลอดเวลาเพื่อจัดหาอนาคตสำรอง (แต่ไม่ใช่ในอดีต) เกี่ยวกับเวลาที่ใช้

ตัวอย่าง

ฉันจะอธิบายรายละเอียดทั้งหมดโดยใช้ตัวอย่างที่มีความยาว

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,000 ปี ตอนนี้เป็นปีที่ 1,000 แล้ว
• เขาเดินทางจาก 1,000 ถึง 1,250
• 250 ปีที่ผ่านมา ตอนนี้เป็นปี 1500 แล้ว
• เขาเดินทางจาก 1,500 ถึง 1,500 นี่ไม่มีผลกระทบ (และสามารถละเว้นได้)
• 500 ปีผ่านไป ตอนนี้คือปี 2000
• เขาเดินทางจาก 2000 ถึง 1800
• 100 ปีผ่านไป ตอนนี้เป็นปี 1900
• เขาเดินทางจาก 1900 ถึง 1850
• 125 ปีผ่านไป: อย่างไรก็ตามเวลานี้ในขณะที่เขาอยู่ในวงสิ่งต่าง ๆ 50 ปีผ่านจาก 1850 ถึง 1900 เขาวนกลับไปเป็น 1850 อีก 50 ปีผ่านจาก 1850 ถึง 1900 เขาวนกลับมาอีกครั้ง 25 ปีผ่านไปและมันคือปี 1875 ดังนั้นจะสำเร็จ 125 ปี
• เขาใช้อัลเทอร์เนเตอร์ ขณะนี้มีอนาคตทางเลือกสำหรับปี 1875 ซึ่งขณะนี้เขาอยู่สิ่งที่ผ่านมาไม่ได้เปลี่ยนไป
• 225 ปีที่ผ่านมา ตอนนี้คือปี 2100
• เขาเดินทางจาก 2,100 ถึง 1,700
• 500 ปีผ่าน: 175 ปีจาก 1700 ถึง 1875 ผ่านปกติ ไม่มีเขาได้พบกับเครื่องกำเนิดไฟฟ้ากระแสสลับอีกครั้งซึ่งหมายความว่าตอนนี้อนาคตที่ 3ได้ถูกสร้างขึ้นในปี 1875 325 ปีผ่านไปตามปกติทำให้ปี 2200
• การใช้เครื่องกำเนิดไฟฟ้ากระแสสลับในขณะนี้ไม่มีผลกระทบ (และสามารถถูกละเว้น) เนื่องจากมีเพียงหนึ่งอนาคตถึง 2200 ซึ่งยังไม่ได้กำหนด
• 100 ปีผ่านไป ตอนนี้ 2300
• เขาเดินทางจาก 2300 ถึง 2100
• 150 ปีผ่าน: 100 ปีจาก 2,100-2,200 ผ่านปกติ อนาคตที่สองได้รับการสร้างขึ้นจาก 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) ผ่านการเดินทางข้ามเวลา

อินพุต

ชุดของเหตุการณ์คล้ายกับตัวอย่าง (รูปแบบมีความยืดหยุ่น)

เอาท์พุต

ค่าความจริง / เท็จแสดงถึงความขัดแย้งที่เกิดขึ้น

ท้าทาย

รหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

Ruby, 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 = ไม่มี Paradox, 1 = Paradox

ตัวอย่าง

อินพุตตัวอย่างที่ให้ไว้: 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ซึ่งบ่งชี้ถึงความขัดแย้งที่เกิดขึ้น

หมายเหตุ

นี่ไม่ใช่แค่การฝึกcodegolfครั้งแรกที่ฉันพยายาม แต่มันก็เป็นโปรแกรม Ruby แรกที่ฉันเขียน ดังนั้นจึงอาจสั้นกว่านี้ได้

คำอธิบายสั้น ๆ

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

ลูปไม่มีที่สิ้นสุดจะเกิดขึ้นเฉพาะในขณะที่เดินทางไปข้างหน้าในเวลา ฉันมีความสุขสำหรับความคิดเห็นใด ๆ - โดยเฉพาะอย่างยิ่งหากมันชี้ให้เห็นวิธีที่ดีกว่าในการแก้ปัญหานี้

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หากเกิดความขัดแย้งหรือป้อนข้อมูลเองถ้าไม่ (เฉพาะความ1จริงใน 05AB1E ทุกอย่างอื่นเป็นเท็จ)

อย่างอิสระบนพื้นฐานของฉัน Java 10 คำตอบ

ลองออนไลน์

หรือลองออนไลน์ด้วยการเพิ่ม debug-line ( สิ่งที่ต้องทำ: สร้างชุดการทดสอบที่เหมาะสมพร้อมกับกรณีทดสอบทั้งหมดในครั้งเดียว .. ):
- กรณีทดสอบที่มีเส้นขนานย้อนหลังการเดินทาง: ลองออนไลน์
- กรณีทดสอบกับเส้นขนานการเดินทางข้ามเวลา: ลองออนไลน์
- กรณีทดสอบที่ไม่มีเส้นขนานการเดินทาง: ลองออนไลน์

คำอธิบาย:

ð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)

Java 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

ลองออนไลน์หรือทดลองออนไลน์ด้วย debug-line ที่เพิ่มเข้ามาลองออนไลน์ที่มีการเพิ่มการแก้ปัญหาเส้น

คำอธิบาย:

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