Bir erkeğin iki cihazı vardır.

• Bir zaman makinesi - Düşünerek bu makineyi kontrol edebilir. Herhangi bir zamanda herhangi bir zamanda geçmişte veya gelecekte başka bir noktaya (veya şimdiki zamanda bile) seyahat etmesini sağlar. B'den A'ya geçmişe seyahat ederse, A'dan B'ye tüm normal olayların (zaman makineleri, alternatörler hariç) aynı şekilde tekrarlanması gerektiğini unutmayın. Sonra B noktasından, A noktasına geri götürülür. Böylece, tek seferlik bir yolculuk sonsuz bir döngü yaratır.
• Alternatör - Bu sorunu fark ederek başka bir makine yaratır. Tüm fiziksel olayların bir döngüde tekrarlanmasına rağmen, düşüncelerinin farklı olabileceğini fark ediyor. Dolayısıyla bu makine de düşünce tarafından kontrol edilebilecek şekilde tasarlanmıştır. Makine, kullandığı zamana göre alternatif bir gelecek (ancak geçmiş değil) sağlamak için herhangi bir zamanda kullanılabilir.

Misal

Tüm detayları uzun bir örnek kullanarak açıklayacağım.

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 yıl geçer. Şimdi 1000 yılı.
• 1000'den 1250'ye kadar seyahat eder.
• 250 yıl geçer. Şimdi 1500 yılı.
• 1500 ile 1500 arasında seyahat eder. Bunun bir etkisi yoktur (ve göz ardı edilebilir).
• 500 yıl geçer. Şimdi 2000 yılı
• 2000'den 1800'e kadar seyahat eder.
• 100 yıl geçer. Şimdi 1900 yılı.
• 1900'den 1850'ye kadar seyahat eder.
• 125 yıl geçti: Ancak, bu sefer, bir döngü içinde olduğu için, işler farklı. 1850'den 1900'e 50 yıl geçer. 1850'ye geri döner. 5050'den 1850'den 1900'e geçer. Tekrar geri döner. 25 yıl geçti ve 1875 oldu, böylece 125 yılını tamamladı.
• Alternatörü kullanıyor. Şimdi, içinde bulunduğu 1875 yılına alternatif bir gelecek var. Geçmiş değişmedi.
• 225 yıl geçti. Şimdi 2100 yılı.
• 2100'den 1700'e seyahat eder.
• 500 yıl geçer: 1700'den 1875'e 175 yıl normal geçer. Hayır, alternatörle tekrar karşılaşır, yani 1875'ten sonra 3. bir gelecek yaratılmıştır. 325 yıl normal geçer, 2200 yılı olur.
• Bir alternatörün kullanılmasının artık bir etkisi yoktur (ve göz ardı edilebilir) çünkü 2200 için henüz tanımlanmamış tek bir gelecek vardır.
• 100 yıl geçer. Şimdi 2300.
• 2300'den 2100'e seyahat ediyor.
• 150 yıl geçer: normalde 2100 ila 2200 arası 100 yıl. 2200'den ikinci bir gelecek yaratıldı. 50 yıl geçti ve şimdi 2250 yılı.
• 2250'den 2225'e kadar gitmesi gerekiyor. Ancak, şimdi iki farklı zaman çizgisinde iki 2225 var. Dolayısıyla bu bir paradoksa yol açar, çünkü hangi noktaya ulaşacağını belirleyemeyiz. (Son zaman çizelgesine gittiğini varsaymayacağız) Bu nedenle bu, simülasyonumuzu sonlandırıyor.
• 100 T+100 50 A 25Bir paradoks meydana geldiğinden ve simülasyonumuz çalışmayı durdurduğundan, başka her şey göz ardı edilir.

İpucu: Örneği anlamak için uğraşıyorsanız, zamanı dünyada kazdığınız bir yol gibi düşünün. Zamanında seyahat ediyorsanız, bir ışınlayıcı yaratırsınız. Alternatörü kullanıyorsanız, mevcut bir yolun duvarına yeni bir yol kazıyorsunuzdur.

paradoks

A, B ve C'nin üç zaman noktası olduğunu varsayalım (birbiri ardına). Bir paradoksun şu durumlarda meydana geldiği söylenir:

• C noktasındaysanız, B noktasında bir alternatör vardır, B noktasında birden fazla gelecek vardır (ve onlardan birindesiniz) ve B ve C arasındaki herhangi bir noktaya zaman yolculuğu yoluyla erişmeye çalışırsınız.
• A noktasındasınız, B noktasında bir alternatör vardır, B noktasına birden fazla gelecek vardır ve zaman yolculuğu yoluyla C noktasına (B'den sonra) erişmeye çalışırsınız.

Giriş

Örneğe benzer bir dizi olay. (Biçim esnektir.)

Çıktı

Bir paradoksun meydana gelip gelmediğini gösteren gerçek / falsey değeri.

Meydan okuma

En kısa kod (bayt cinsinden) kazanır.

Yakut, 510 460 bayt

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

Giriş

Örnek olarak

Çıktı

0 = Paradoks Yok, 1 = Paradoks

Örneklem

Sağlanan örnek giriş: 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 döner1 bir paradoksun oluştuğunu gösteren .

notlar

Bu sadece ilk kod golfü değil denediğim egzersizi değil, aynı zamanda yazdığım ilk Ruby programı. Bu nedenle, muhtemelen daha da kısa olabilir.

Kısa açıklama

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

Sonsuz döngüler sadece zamanda ileri giderken meydana gelir. Herhangi bir geri bildirim için mutluyum - özellikle de bunu çözmenin daha iyi bir yolunu gösteriyorsa.

05AB1E , 93 92 86 82 bayt

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

Girdi, alternatörün Abunun abcdefghijklmnopqrstuvwxyzyerine bir baytı kaydetmesi dışında, meydan okuma açıklamasındakiyle aynı formattadır . Bir paradoks meydana gelirse
çıktılar 1veya eğer değilse girdinin kendisi (yalnızca1 05AB1E'de doğrudur, diğer her şey falseydir).

Java 10 yanıtımı temel olarak gevşek .

Çevrimiçi deneyin.

Ya da eklenen hata ayıklama satırları ile çevrimiçi deneyin ( TODO: Bir seferde tüm test senaryoları ile uygun test paketi oluşturun .. ):
- Geriye doğru zaman yolculuğu paradoksu ile test örneği: Çevrimiçi deneyin.
- İleri zaman yolculuğu paradoksu ile test örneği: Çevrimiçi deneyin.
- Zaman yolculuğu paradoksu olmadan test durumu: Çevrimiçi deneyin.

Açıklama:

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

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

Girdi (şimdilik) meydan okuma açıklamasındakiyle aynı formatta.

@BenjaminUrquhart sayesinde -13 bayt . @Ceilingcat
sayesinde -7 bayt .

Çevrimiçi deneyin veya eklenen hata ayıklama satırlarıyla çevrimiçi deneyin .

Açıklama:

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