У человека есть два устройства.

• Машина времени - Он может управлять этой машиной, думая. Это позволяет ему путешествовать из любого момента времени в другой момент времени в прошлом или будущем (или даже в настоящий момент времени) за мгновение. Обратите внимание, что если он путешествует в прошлое от 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 году. Еще 50 лет проходит с 1850 по 1900 год. Он возвращается снова. Проходит 25 лет, а это 1875 год, что завершает 125 лет.
• Он использует генератор. Теперь существует альтернативное будущее 1875 году, в котором он сейчас находится. Прошлое не изменилось.
• 225 лет прошло. Сейчас 2100 год.
• Он путешествует с 2100 до 1700.
• Проход 500 лет: 175 лет с 1700 по 1875 год проходят нормально. Нет, он снова сталкивается с генератором, что означает, что теперь третье будущее было создано после 1875 года. 325 лет проходят нормально, а год 2200.
• Использование генератора переменного тока теперь не имеет никакого эффекта (и его можно игнорировать), поскольку существует только одно будущее до 2200, которое еще не было определено.
• 100 лет прошло. Сейчас 2300.
• Он путешествует с 2300 до 2100.
• 150 лет проходят: 100 лет с 2100 до 2200 проходят нормально. Второе будущее создается с 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) через путешествие во времени.

вход

Серия событий, похожих на пример. (Формат гибкий.)

Выход

Значение «истина / ложь», указывающее, произошел ли парадокс.

Вызов

Самый короткий код (в байтах) выигрывает.

Рубин, 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, указывая на возникший парадокс.

Примечания

Это не только первый упражнение для 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 .

Попробуйте онлайн.

Или попробуйте это онлайн с добавленными отладочными линиями ( 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)

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 .

Попробуйте онлайн или попробуйте онлайн с добавленными линиями отладки .

Объяснение:

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