Wir haben Objekte, die zwischen zwei ganzzahligen Punkten oszillieren [l, r], mit einer Geschwindigkeit von einer Einheit pro Zeiteinheit, beginnend bei lon t=0. Sie können davon ausgehen l < r. Wenn zum Beispiel ein Objekt anschwingt [3, 6], haben wir:

t=0 -> 3
t=1 -> 4
t=2 -> 5
t=3 -> 6
t=4 -> 5
t=6 -> 4
t=7 -> 3
t=8 -> 4

Aber Objekte schwingen ununterbrochen, also haben wir auch t=0.5 -> 3.5und t=3.7 -> 5.3.

Bestimmen Sie bei zwei Objekten, die zwischen [l1, r1], oszillieren , [l2, r2]ob es jemals eine Zeit gibt t, bei der sich die beiden Objekte dieselbe Position teilen. Sie nehmen l1, r1, l2, r2ein beliebiges praktisches Format an und geben alle wahrheitsgemäßen / falschen Werte aus.

Wahrheitseingaben:

[[3, 6], [3, 6]]
[[3, 6], [4, 8]]
[[0, 2], [2, 3]]
[[0, 3], [2, 4]]
[[7, 9], [8, 9]]

Falsche Eingaben:

[[0, 3], [3, 5]] 
[[0, 2], [2, 4]]
[[5, 8], [9, 10]]
[[6, 9], [1, 2]]
[[1, 3], [2, 6]]

Python 2 , 69 Bytes

l,r,L,R=input()
d=r-l;k=1
while(R-L)*k%d:k+=1
print r-L>=k%2*d/k<=R-l

Probieren Sie es online!

Schale , 13 Bytes

VEΣUẊeTmȯ…¢mD

Übernimmt die Eingabe im Format [[l,r],[L,R]]. Gibt 0für falsche Instanzen und für wahrheitsgemäße Instanzen eine positive Ganzzahl zurück. Probieren Sie es online!

Erläuterung

Die Hauptideen sind

1. Eine Kollision kann nur bei einer Ganzzahl- oder einer halben Ganzzahlkoordinate auftreten.
2. Es reicht aus, das System zu simulieren, bis eine Wiederholung von zwei aufeinander folgenden Zuständen auftritt.

Hier ist der Code mit Anmerkungen versehen.

VEΣUẊeTmȯ…¢mD  Implicit input, say [[0,2],[2,3]]
       mȯ      For both pairs do:
           mD   Double each: [[0,4],[4,6]]
          ¢     Cycle: [[0,4,0,4..],[4,6,4,6..]]
         …      Rangify: [[0,1,2,3,4,3,2,1,0,1,2..],[4,5,6,5,4,5,6..]]
      T        Transpose: [[0,4],[1,5],[2,6],[3,5],[4,4],[3,5],[2,6]..
    Ẋe         Adjacent pairs: [[[0,4],[1,5]],[[1,5],[2,6]],[[2,6],[3,5]],[[3,5],[4,4]]..
   U           Prefix of unique elements: [[[0,4],[1,5]],[[1,5],[2,6]],[[2,6],[3,5]],[[3,5],[4,4]]..[[1,5],[0,4]]]
  Σ            Concatenate: [[0,4],[1,5],[1,5],[2,6],[2,6],[3,5],[3,5],[4,4]..[1,5],[0,4]]
VE             Index of first pair whose elements are equal (or 0 if not found): 8

JavaScript (ES6), 104 100 Byte

Eine naive Implementierung, die nur die Simulation ausführt. Nimmt (a, b, c, d) als 4 verschiedene Variablen.

(a,b,c,d)=>(g=(X,Y)=>x==y|x+X==y&(y+=Y)==x||(x+=X)-a|y-c&&g(x>a&x<b?X:-X,y>c&y<d?Y:-Y))(1,1,x=a,y=c)

Testfälle

let f =

(a,b,c,d)=>(g=(X,Y)=>x==y|x+X==y&(y+=Y)==x||(x+=X)-a|y-c&&g(x>a&x<b?X:-X,y>c&y<d?Y:-Y))(1,1,x=a,y=c)

console.log('Truthy')
console.log(f(3, 6, 3, 6))
console.log(f(3, 6, 4, 8))
console.log(f(0, 2, 2, 3))
console.log(f(0, 3, 2, 4))
console.log(f(7, 9, 8, 9))

console.log('Falsy')
console.log(f(0, 3, 3, 5))
console.log(f(0, 2, 2, 4))
console.log(f(5, 8, 9, 10))
console.log(f(6, 9, 1, 2))

Wolfram Language (Mathematica) , 77 69 61 Bytes

If[#>#3,#0[##3,#,#2],(z=GCD[x=#-#2,#3-#4])Mod[x/z,2]<=#2-#3]&

Eine reine Funktion, die die vier Argumente l1, r1, l2, r2als Eingabe verwendet: zB [0,3,2,4]wenn die Intervalle [0,3]und sind [2,4].

Probieren Sie es online!

Wie es funktioniert

Um einen Punkt in die [a,b]Nähe eines Punktes in zu bringen [c,d], a<c<b<dwollen wir ein ungerades Vielfaches von b-ainnerhalb b-ceines geraden Vielfachen von d-c. Wenn b-aes mehr Faktoren 2als gibt d-c, können wir dies genau erreichen: Es wird eine Zeit geben, in der der erste Punkt bund der zweite Punkt erreicht sind c, und dann sind wir in guter Verfassung. Wenn nicht, ist das Beste, was wir tun können, die GCD von b-aund d-c.

JavaScript (ES6), 89 Byte

(a,b,c,d)=>[...Array((b-=a)*(d-=c)*4)].some((g=e=>i/e&2?e-i/2%e:i/2%e,i)=>a+g(b)==c+g(d))

Nimmt l1,r1,l2,r2als separate Argumente. Erläuterung: Die Simulation wird garantiert nach (r1-l1)*(r2-l2)*2Zeiteinheiten (oder einem Faktor davon) wiederholt . gberechnet den Versatz des entsprechenden Objekts nach i/2Zeiteinheiten, imuss also bis reichen (r1-l1)*(r2-l2)*4.

05AB1E , 12 10 14 Bytes

+4 Bytes für negative Bereiche

Gibt 0 zurück, wenn dies falsch ist, oder eine positive Ganzzahl, wenn dies nicht der Fall ist

Verwenden Sie die Idee von Zgarb von Werte zu verdoppeln, um die Positionserkennung zu vereinfachen

Vielen Dank an @ Zacharý für den Hinweis auf meine Fehler

ÄZU\·εXиŸ}øüQO

Probieren Sie es online!

Erklärungen:

ÄZU\·εXиŸ}øüQO 
ÄZU\            Store in X the largest absolute number in the lists
    ·           Double lists ([3,6],[4,8] => [6,12],[8,16])
     ε   }      For each...
      X             Push X
       и            List-repeat that much times ([6,12]*12 => [6,12,6,12,6,...])
        Ÿ           Rangify ([6,12,6,...] => [6,7,8,9,10,11,12,11,...])
          ø     Zip lists ([6,7,8,...],[8,9,10,...] => [6,8],[7,9],[8,10],...)
           üQ   1 if both elements of a pair are equal, 0 otherwise
             O  Sum result list (=0 if the same position is never shared)
                Implicit output

Java (OpenJDK 8) , 81 Byte

(l,r,L,R)->{int d=r-l,k=0;for(;(R-L)*++k%d>0;);return(r-L<R-l?r-L:R-l)>=k%2*d/k;}

Probieren Sie es online!

Wiederverwenden des Python-Algorithmus von xnor .