Un homme a deux appareils.

• Une machine à voyager dans le temps - Il peut contrôler cette machine en pensant. Cela lui permet de voyager d'un moment à un autre dans le passé ou le futur (ou même le moment présent) en un rien de temps. Notez que s'il voyage dans le passé de B à A, alors tous les événements normaux (machines à remonter le temps, alternateurs exclus) de A à B doivent se répéter exactement de la même manière. Puis du point B, il est ramené au point A. Ainsi, un seul voyage dans le temps crée une boucle infinie.
• Alternateur - Réalisant ce problème, il crée une autre machine. Il remarque que, même si tous les événements physiques se répètent en boucle, ses pensées peuvent être différentes. Par conséquent, cette machine a été conçue pour être également contrôlable par la pensée. La machine peut être utilisée à tout moment pour fournir un futur alternatif (mais pas passé) par rapport au moment où il l'a utilisée.

Exemple

Je vais expliquer tous les détails en utilisant un long exemple.

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 ans passent. Nous sommes maintenant en l'an 1000.
• Il voyage de 1000 à 1250.
• 250 ans passent. Nous sommes en l'an 1500 maintenant.
• Il voyage de 1500 à 1500. Cela n'a aucun effet (et peut être ignoré).
• 500 ans passent. C'est maintenant l'an 2000
• Il voyage de 2000 à 1800.
• 100 ans passent. C'est l'année 1900 maintenant.
• Il voyage de 1900 à 1850.
• 125 ans passent: Cependant, cette fois, comme il est dans une boucle, les choses sont différentes. 50 ans passent de 1850 à 1900. Il revient en boucle vers 1850. Encore 50 ans passent de 1850 à 1900. Il revient en boucle. 25 ans passent et c'est 1875, complétant ainsi 125 ans.
• Il utilise l'alternateur. Maintenant, il existe un avenir alternatif à l'année 1875, dans laquelle il est maintenant. Le passé n'a pas changé.
• 225 ans passent. Nous sommes maintenant en 2100.
• Il voyage de 2100 à 1700.
• 500 ans passent: 175 ans de 1700 à 1875 passent normalement. Non, il retrouve l'alternateur, ce qui signifie qu'un troisième avenir a été créé après 1875. 325 ans passent normalement, ce qui en fait l'année 2200.
• L'utilisation d'un alternateur n'a désormais aucun effet (et peut être ignoré) car il n'existe qu'un seul futur à 2200 qui n'a pas encore été défini.
• 100 ans passent. Il est maintenant 23 heures.
• Il voyage de 2300 à 2100.
• 150 ans passent: 100 ans de 2100 à 2200 passent normalement. Un deuxième avenir se crée à partir de 2200. 50 ans passent et c'est maintenant l'année 2250.
• Il est censé passer de 2250 à 2225. Cependant, il existe maintenant deux 2225 dans deux délais différents. Cela conduit donc à un paradoxe, car nous ne pouvons pas déterminer à quel moment il atteindra. (Nous ne supposerons pas qu'il passe à la chronologie la plus récente). Ceci termine donc notre simulation.
• Tout le 100 T+100 50 A 25reste est complètement ignoré car un paradoxe s'est produit et notre simulation a cessé de fonctionner.

Astuce: Si vous avez du mal à comprendre l'exemple, imaginez le temps comme un chemin que vous creusez dans la terre. Si vous voyagez dans le temps, vous créez un téléporteur. Si vous utilisez l'alternateur, vous creusez un nouveau chemin dans le mur d'un chemin existant.

Paradoxe

Supposons que A, B et C sont trois points dans le temps (l'un après l'autre). Un paradoxe se serait produit si:

• vous êtes au point C, il existe un alternateur au point B, il existe plus d'un futur au point B (et vous êtes dans l'un d'eux), et vous tentez d'accéder à n'importe quel point entre B et C via un voyage dans le temps.
• vous êtes au point A, il existe un alternateur au point B, il existe plus d'un futur au point B, et vous essayez d'accéder à un point C (après B) via un voyage dans le temps.

Contribution

Une série d'événements, similaire à l'exemple. (Le format est flexible.)

Production

Une valeur truey / falsey, indiquant si un paradoxe s'est produit.

Défi

Le code le plus court (en octets) gagne.

Rubis, 510 460 octets

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

Contribution

Comme par exemple

Production

0 = pas de paradoxe, 1 = paradoxe

Échantillon

L'échantillon d'entrée a fourni: 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 renvoie 1, indiquant qu'un paradoxe s'est produit.

Remarques

Ce n'est pas seulement le premier exercice de golf de code que j'essaie , mais c'est aussi le premier programme Ruby que j'ai écrit. Par conséquent, il pourrait probablement être encore plus court.

Brève explication

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

Des boucles infinies ne se produiront qu'en voyageant dans le temps. Je suis heureux de tout commentaire - surtout s'il indique une meilleure façon de résoudre ce problème.

05AB1E , 93 92 86 82 octets

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

L'entrée est dans le même format que dans la description du défi, sauf que l'alternateur Aest à la abcdefghijklmnopqrstuvwxyzplace pour enregistrer un octet.
Sorties 1si un paradoxe s'est produit, ou l'entrée elle-même sinon (seulement1 est véridique dans 05AB1E, tout le reste est falsey).

Librement basé sur ma réponse Java 10 .

Essayez-le en ligne.

Ou essayez-le en ligne avec des lignes de débogage supplémentaires ( TODO: Créez une suite de tests appropriée avec tous les cas de test à la fois .. ):
- Cas de test avec paradoxe de voyage dans le temps: essayez-le en ligne.
- Cas de test avec le paradoxe du voyage dans le temps: essayez-le en ligne.
- Cas de test sans paradoxe du voyage dans le temps: essayez-le en ligne.

Explication:

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

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

L'entrée est (pour l'instant) dans le même format que dans la description du défi.

-13 octets grâce à @BenjaminUrquhart .
-7 octets grâce à @ceilingcat .

Essayez-le en ligne ou essayez-le en ligne avec des lignes de débogage supplémentaires .

Explication:

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