Seorang pria memiliki dua perangkat.

• Mesin waktu - Dia dapat mengendalikan mesin ini dengan berpikir. Ini memungkinkan dia untuk melakukan perjalanan dari titik waktu ke titik waktu di masa lalu atau masa depan (atau bahkan saat ini dalam waktu) dalam waktu singkat. Perhatikan bahwa jika ia melakukan perjalanan ke masa lalu dari B ke A, maka semua kejadian normal (mesin waktu, alternator dikecualikan) dari A ke B harus diulang dengan cara yang sama persis. Kemudian dari titik B, ia dibawa kembali ke titik A. Dengan demikian, perjalanan waktu tunggal menciptakan loop tak terbatas.
• Alternator - Menyadari masalah ini, ia menciptakan mesin lain. Dia memperhatikan bahwa, meskipun semua peristiwa fisik berulang dalam satu lingkaran, pikirannya mungkin berbeda. Karenanya mesin ini dirancang untuk dapat dikendalikan oleh pikiran juga. Mesin dapat digunakan kapan saja untuk memberikan masa depan alternatif (tetapi tidak masa lalu) sehubungan dengan waktu dia menggunakannya.

Contoh

Saya akan menjelaskan semua detail menggunakan contoh panjang.

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 tahun berlalu. Sekarang tahun 1000.
• Ia melakukan perjalanan dari 1000 ke 1250.
• 250 tahun berlalu. Sekarang tahun 1500.
• Ia melakukan perjalanan dari 1500 ke 1500. Ini tidak memiliki efek (dan dapat diabaikan).
• 500 tahun berlalu. Sekarang tahun 2000
• Ia melakukan perjalanan dari 2000 ke 1800.
• 100 tahun berlalu. Sekarang tahun 1900.
• Ia melakukan perjalanan dari tahun 1900 hingga 1850.
• 125 tahun berlalu: Namun, kali ini, saat ia berada dalam satu lingkaran, segalanya berbeda. 50 tahun berlalu dari tahun 1850 hingga 1900. Dia kembali ke tahun 1850. 50 tahun lagi berlalu dari tahun 1850 hingga 1900. Dia kembali ke loop lagi. 25 tahun berlalu dan ini adalah tahun 1875, dengan demikian menyelesaikan 125 tahun.
• Dia menggunakan alternator. Sekarang ada masa depan alternatif untuk tahun 1875, di mana dia sekarang. Masa lalu tidak berubah.
• 225 tahun berlalu. Sekarang tahun 2100.
• Ia melakukan perjalanan dari 2100 hingga 1700.
• 500 tahun berlalu: 175 tahun dari 1700 hingga 1875 berlalu secara normal. Tidak, dia bertemu dengan alternator lagi, yang berarti bahwa sekarang masa depan ke - 3 telah dibuat pasca-1875. 325 tahun berlalu secara normal, menjadikannya tahun 2200.
• Menggunakan alternator sekarang tidak memiliki efek (dan dapat diabaikan) karena hanya ada satu masa depan hingga 2200 yang belum didefinisikan.
• 100 tahun berlalu. Sekarang 2300.
• Ia melakukan perjalanan dari 2300 hingga 2100.
• 150 tahun berlalu: 100 tahun dari 2100 hingga 2200 berlalu secara normal. Masa depan kedua akan dibuat dari 2200. 50 tahun berlalu dan sekarang tahun 2250.
• Dia seharusnya pergi dari 2250 ke 2225. Namun, sekarang ada dua 2225 di dua garis waktu yang berbeda. Karena itu, hal ini mengarah pada paradoks, karena kita tidak dapat menentukan titik waktu yang akan dicapai. (Kami tidak akan menganggap bahwa ia pergi ke timeline yang lebih baru) Oleh karena itu ini mengakhiri simulasi kami.
• Apa pun lebih jauh 100 T+100 50 A 25sepenuhnya diabaikan sejak paradoks telah terjadi dan simulasi kami telah berhenti berjalan.

Petunjuk: Jika Anda berjuang untuk memahami contoh, bayangkan waktu menjadi seperti jalan yang Anda gali di bumi. Jika Anda bepergian waktu, Anda membuat teleporter. Jika Anda menggunakan alternator, Anda sedang menggali jalur baru ke dinding jalur yang ada.

Paradoks

Asumsikan A, B dan C adalah tiga titik waktu (satu demi satu). Suatu paradoks dikatakan telah terjadi jika:

• Anda berada di titik C, ada alternator di titik B, ada lebih dari satu masa depan ke titik B (dan Anda berada di salah satu dari mereka), dan Anda berupaya mengakses titik mana pun antara B dan C melalui perjalanan waktu.
• Anda berada di titik A, ada alternator di titik B, ada lebih dari satu masa depan ke titik B, dan Anda mencoba mengakses titik C (setelah B) melalui perjalanan waktu.

Memasukkan

Serangkaian acara, mirip dengan contoh. (Format fleksibel.)

Keluaran

Nilai kebenaran / kepalsuan, menunjukkan apakah suatu paradoks telah terjadi.

Tantangan

Kode terpendek (dalam byte) menang.

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

Memasukkan

Sebagai contoh

Keluaran

0 = Tidak Paradox, 1 = Paradox

Sampel

Input sampel yang disediakan: 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 pengembalian 1, menunjukkan terjadi paradoks.

Catatan

Ini bukan hanya latihan codegolf pertama yang saya coba, tetapi juga merupakan program Ruby pertama yang saya tulis. Oleh karena itu, mungkin bisa lebih pendek.

Penjelasan singkat

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

Loop tak terbatas hanya akan terjadi saat bergerak maju dalam waktu. Saya senang atas tanggapan apa pun - terutama jika ini menunjukkan cara yang lebih baik untuk menyelesaikan masalah ini.

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

Input dalam format yang sama seperti dalam deskripsi tantangan, kecuali alternator itu A adalah abcdefghijklmnopqrstuvwxyzbukan untuk menyimpan byte.
Keluaran 1jika terjadi paradoks, atau input itu sendiri jika tidak (hanya 1kebenaran di 05AB1E, yang lainnya falsey).

Secara longgar berdasarkan jawaban Java 10 saya .

Cobalah online.

Atau coba online dengan menambahkan garis-debug ( TODO: Buat suite uji yang tepat dengan semua kasus uji sekaligus .. ):
- Uji kasus dengan paradoks perjalanan waktu mundur: Cobalah online.
- Uji kasus dengan paradoks perjalanan waktu ke depan: Cobalah secara online.
- Uji kasus tanpa paradoks perjalanan waktu: Cobalah secara online.

Penjelasan:

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

Input adalah (untuk saat ini) dalam format yang sama seperti pada deskripsi tantangan.

-13 byte terima kasih kepada @BenjaminUrquhart .
-7 byte terima kasih kepada @ceilingcat .

Cobalah online atau coba online dengan menambahkan garis-debug .

Penjelasan:

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