Un uomo ha due dispositivi.

• Una macchina del tempo - Può controllare questa macchina pensando. Gli consente di viaggiare da un qualsiasi momento nel tempo a un altro momento nel passato o nel futuro (o anche nel momento presente) in pochissimo tempo. Nota che se viaggia nel passato da B a A, tutti gli eventi normali (macchine del tempo, alternatori esclusi) da A a B devono ripetere allo stesso modo. Quindi dal punto B, viene riportato al punto A. Pertanto, un singolo viaggio nel tempo crea un ciclo infinito.
• Alternatore - Realizzando questo problema, crea un'altra macchina. Si accorge che, anche se tutti gli eventi fisici si ripetono in un ciclo, i suoi pensieri possono essere diversi. Quindi questa macchina è stata progettata per essere controllabile anche dal pensiero. La macchina può essere utilizzata in qualsiasi momento per fornire un futuro alternativo (ma non passato) rispetto al tempo in cui l'ha usata.

Esempio

Spiegherò tutti i dettagli usando un lungo esempio.

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

• Passano 1000 anni. È l'anno 1000 ora.
• Viaggia dal 1000 al 1250.
• Passano 250 anni. È l'anno 1500 ora.
• Viaggia dal 1500 al 1500. Questo non ha alcun effetto (e può essere ignorato).
• Passano 500 anni. Ora è l'anno 2000
• Viaggia dal 2000 al 1800.
• Passano 100 anni. È l'anno 1900 ora.
• Viaggia dal 1900 al 1850.
• Passano 125 anni: tuttavia, questa volta, dato che è in loop, le cose sono diverse. Passano 50 anni dal 1850 al 1900. Torna al 1850. Altri 50 anni passano dal 1850 al 1900. Torna indietro. Passano 25 anni ed è il 1875, completando così 125 anni.
• Usa l'alternatore. Ora esiste un futuro alternativo rispetto all'anno 1875, in cui si trova ora. Il passato non è cambiato.
• Passano 225 anni. È l'anno 2100.
• Viaggia dal 2100 al 1700.
• Passano 500 anni: 175 anni dal 1700 al 1875 passano normalmente. No, incontra di nuovo l'alternatore, il che significa che ora è stato creato un terzo futuro dopo il 1875. 325 anni passano normalmente, rendendolo l'anno 2200.
• L'uso di un alternatore ora non ha alcun effetto (e può essere ignorato) poiché esiste un solo futuro a 2200 che non è stato ancora definito.
• Passano 100 anni. Sono le 2300.
• Viaggia dal 2300 al 2100.
• Passano 150 anni: 100 anni dai 2100 ai 2200 passano normalmente. Un secondo futuro viene creato dal 2200. Passano 50 anni ed è ora l'anno 2250.
• Dovrebbe andare dal 2250 al 2225. Tuttavia, ora esistono due 2225 in due tempi diversi. Quindi questo porta a un paradosso, dal momento che non siamo in grado di determinare quale momento raggiungerà. (Non supponiamo che vada alla linea temporale più recente) Quindi questo termina la nostra simulazione.
• Qualsiasi altra cosa 100 T+100 50 A 25viene completamente ignorata da quando si è verificato un paradosso e la nostra simulazione ha smesso di funzionare.

Suggerimento: se stai lottando per capire l'esempio, immagina che il tempo sia come un sentiero che stai scavando nella terra. Se viaggi nel tempo, stai creando un teletrasporto. Se stai usando l'alternatore, stai scavando un nuovo percorso nel muro di un percorso esistente.

Paradosso

Supponiamo che A, B e C siano tre punti nel tempo (uno dopo l'altro). Si dice che si sia verificato un paradosso iff:

• vi trovate in un punto C, esiste un alternatore in un punto B, esiste più di un futuro al punto B (e vi trovate in uno di essi) e provate ad accedere a qualsiasi punto tra B e C attraverso il viaggio nel tempo.
• sei in un punto A, esiste un alternatore in un punto B, esiste più di un futuro al punto B e provi ad accedere a un punto C (dopo B) tramite il viaggio nel tempo.

Ingresso

Una serie di eventi, simili all'esempio. (Il formato è flessibile.)

Produzione

Un valore di verità / falsità, che indica se si è verificato un paradosso.

Sfida

Vince il codice più breve (in byte).

Rubino, 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

Ingresso

Come da esempio

Produzione

0 = Nessun paradosso, 1 = Paradosso

Campione

L'input di esempio fornito: 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 restituisce 1, indicando che si è verificato un paradosso.

Appunti

Questo non è solo il primo esercizio di codegolf che cerco, ma è anche il primo programma di Ruby che ho scritto. Quindi, probabilmente potrebbe essere ancora più breve.

Breve spiegazione

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

Gli anelli infiniti si verificano solo quando si viaggia in avanti nel tempo. Sono felice per qualsiasi feedback, soprattutto se sta indicando un modo migliore per risolverlo.

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

L'input è nello stesso formato della descrizione della sfida, tranne per il fatto che l'alternatore Adeve abcdefghijklmnopqrstuvwxyzinvece salvare un byte.
Emette 1se si è verificato un paradosso o l'input stesso in caso contrario ( 1è vero solo in 05AB1E, tutto il resto è falso).

Liberamente basato sulla mia risposta Java 10 .

Provalo online.

Oppure provalo online con le righe di debug aggiunte ( TODO: crea una suite di test adeguata con tutti i casi di test contemporaneamente. ):
- Caso di prova con paradosso del viaggio nel tempo all'indietro: provalo online.
- Caso di prova con paradosso del viaggio nel tempo: provalo online.
- Caso di prova senza paradosso nel viaggio nel tempo: provalo online.

Spiegazione:

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

L'input è (per ora) nello stesso formato della descrizione della sfida.

-13 byte grazie a @BenjaminUrquhart .
-7 byte grazie a @ceilingcat .

Provalo online o provalo online con le righe di debug aggiunte .

Spiegazione:

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