Một người đàn ông có hai thiết bị.

• Một cỗ máy thời gian - Anh ta có thể điều khiển cỗ máy này bằng cách suy nghĩ. Nó cho phép anh ta đi từ bất kỳ thời điểm nào đến thời điểm khác trong quá khứ hoặc tương lai (hoặc thậm chí là thời điểm hiện tại) trong thời gian ngắn. Lưu ý rằng nếu anh ta đi về quá khứ từ B đến A, thì tất cả các sự kiện thông thường (máy thời gian, máy phát điện bị loại trừ) từ A đến B phải lặp lại theo cùng một cách chính xác. Sau đó, từ điểm B, anh ta được đưa trở lại điểm A. Do đó, một lần du hành thời gian duy nhất tạo ra một vòng lặp vô hạn.
• Alternator - Nhận ra vấn đề này, anh ta tạo ra một cỗ máy khác. Anh ta nhận thấy rằng, mặc dù tất cả các sự kiện vật lý được lặp đi lặp lại trong một vòng lặp, suy nghĩ của anh ta có thể khác. Do đó, cỗ máy này được thiết kế để có thể điều khiển bằng suy nghĩ. Máy có thể được sử dụng bất cứ lúc nào để cung cấp một tương lai thay thế (nhưng không phải là quá khứ) đối với thời gian anh ta sử dụng nó.

Thí dụ

Tôi sẽ giải thích tất cả các chi tiết bằng một ví dụ dài.

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 năm trôi qua. Bây giờ là năm 1000.
• Anh ta đi từ 1000 đến 1250.
• 250 năm trôi qua. Bây giờ là năm 1500.
• Anh ta đi từ 1500 đến 1500. Điều này không có tác dụng (và có thể bỏ qua).
• 500 năm trôi qua. Bây giờ là năm 2000
• Anh ta đi từ 2000 đến 1800.
• 100 năm trôi qua. Bây giờ là năm 1900.
• Ông đi từ 1900 đến 1850.
• 125 năm trôi qua: Tuy nhiên, lần này, khi anh ở trong một vòng lặp, mọi thứ đã khác. 50 năm trôi qua từ 1850 đến 1900. Ông lặp lại vào năm 1850. 50 năm nữa trôi qua từ 1850 đến 1900. Ông lại lặp lại. 25 năm trôi qua và đó là năm 1875, do đó hoàn thành 125 năm.
• Anh dùng máy phát điện. Bây giờ tồn tại một tương lai thay thế cho năm 1875, mà hiện tại anh đang ở. Quá khứ không thay đổi.
• 225 năm trôi qua. Bây giờ là năm 2100.
• Ông đi từ 2100 đến 1700.
• 500 năm trôi qua: 175 năm từ 1700 đến 1875 trôi qua bình thường. Không có anh gặp lại máy phát điện, điều đó có nghĩa là bây giờ tương lai thứ 3 đã được tạo ra sau năm 1875. 325 năm trôi qua bình thường, làm cho năm 2200.
• Sử dụng máy phát điện bây giờ không có hiệu lực (và có thể bỏ qua) vì chỉ tồn tại một tương lai đến 2200 chưa được xác định.
• 100 năm trôi qua. Bây giờ là 2300.
• Anh ta đi từ 2300 đến 2100.
• 150 năm trôi qua: 100 năm từ 2100 đến 2200 vượt qua bình thường. Một tương lai thứ hai được tạo ra từ năm 2200. 50 năm trôi qua và bây giờ là năm 2250.
• Ông được cho là đi từ năm 2250 đến 2225. Tuy nhiên, hiện tại đã tồn tại hai chiếc 2225 theo hai mốc thời gian khác nhau. Do đó, điều này dẫn đến một nghịch lý, vì chúng ta không thể xác định thời điểm nào anh ấy sẽ đạt đến. (Chúng tôi sẽ không cho rằng anh ta đi vào dòng thời gian gần đây hơn) Do đó, điều này chấm dứt mô phỏng của chúng tôi.
• Bất cứ điều gì hơn nữa 100 T+100 50 A 25hoàn toàn bị bỏ qua vì một nghịch lý đã xảy ra và mô phỏng của chúng tôi đã ngừng chạy.

Gợi ý: Nếu bạn đang vật lộn để hiểu ví dụ, hãy tưởng tượng thời gian giống như một con đường bạn đang đào trên trái đất. Nếu bạn đang du hành thời gian, bạn đang tạo ra một dịch chuyển tức thời. Nếu bạn đang sử dụng máy phát điện, bạn đang đào một đường dẫn mới vào tường của một đường dẫn hiện có.

Nghịch lý

Giả sử A, B và C là ba điểm trong thời gian (lần lượt từng điểm một). Một nghịch lý được cho là đã xảy ra:

• bạn đang ở một điểm C, tồn tại một máy phát điện tại một điểm B, tồn tại nhiều hơn một tương lai cho điểm B (và bạn đang ở một trong số chúng) và bạn cố gắng truy cập bất kỳ điểm nào giữa B và C thông qua du hành thời gian.
• bạn đang ở một điểm A, tồn tại một máy phát điện tại một điểm B, tồn tại nhiều hơn một tương lai cho điểm B và bạn cố gắng truy cập một điểm C (sau B) thông qua du hành thời gian.

Đầu vào

Một loạt các sự kiện, tương tự như ví dụ. (Định dạng là linh hoạt.)

Đầu ra

Một giá trị trung thực / falsey, cho biết liệu một nghịch lý đã xảy ra.

Thử thách

Mã ngắn nhất (tính bằng byte) sẽ thắng.

Ruby, 510 460 byte

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

Đầu vào

Theo ví dụ

Đầu ra

0 = Không nghịch lý, 1 = Nghịch lý

Mẫu vật

Đầu vào mẫu được cung cấp: 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 trả về 1, chỉ ra một nghịch lý xảy ra.

Ghi chú

Đây không chỉ là bài tập codegolf đầu tiên tôi thử, mà nó còn là chương trình Ruby đầu tiên tôi viết. Do đó, nó có thể thậm chí còn ngắn hơn.

Giải thích ngắn gọn

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

Vòng lặp vô hạn sẽ chỉ xảy ra trong khi du hành về phía trước trong thời gian. Tôi rất vui vì bất kỳ phản hồi nào - đặc biệt nếu đó là chỉ ra một cách tốt hơn để giải quyết vấn đề này.

05AB1E , 93 92 86 82 byte

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

Đầu vào là ở định dạng giống như trong mô tả thách thức, trừ trường hợp phát điện mà Alà abcdefghijklmnopqrstuvwxyzthay vì để tiết kiệm một byte.
Đầu ra 1nếu một nghịch lý xảy ra, hoặc chính đầu vào nếu không (chỉ có sự 1thật trong 05AB1E, mọi thứ khác là falsey).

Dựa vào câu trả lời Java 10 của tôi .

Hãy thử trực tuyến.

Hoặc dùng thử trực tuyến với các dòng gỡ lỗi bổ sung ( TODO: Tạo bộ kiểm tra phù hợp với tất cả các trường hợp kiểm tra cùng một lúc .. ):
- Trường hợp kiểm tra với nghịch lý du hành thời gian lạc hậu: Hãy thử trực tuyến.
- Trường hợp thử nghiệm với nghịch lý du hành thời gian về phía trước: Hãy thử trực tuyến.
- Trường hợp thử nghiệm không có nghịch lý du hành thời gian: Hãy thử trực tuyến.

Giải trình:

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

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

Đầu vào là (hiện tại) có cùng định dạng như trong mô tả thử thách.

-13 byte nhờ @BenjaminUrquhart .
-7 byte nhờ @ceilingcat .

Hãy thử trực tuyến hoặc thử trực tuyến với các dòng gỡ lỗi được thêm vào .

Giải trình:

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