Nous avons des objets qui oscillent entre deux points entiers [l, r], à la vitesse d'une unité par unité de temps, à partir lde t=0. Vous pouvez supposer l < r. Par exemple, si un objet oscille [3, 6], alors nous avons:

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

Etc. Mais les objets oscillent continuellement, nous avons donc aussi t=0.5 -> 3.5et t=3.7 -> 5.3.

Compte tenu de deux objets oscillant entre [l1, r1], [l2, r2], déterminer si jamais il y a un temps ttel que les deux objets partagent la même position. Vous faites des prises l1, r1, l2, r2dans n'importe quel format pratique, et sortez toutes les valeurs véridiques / fausses.

Entrées véridiques:

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

Entrées fausses:

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

Python 2 , 69 octets

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

Essayez-le en ligne!

Husk , 13 octets

VEΣUẊeTmȯ…¢mD

Prend l'entrée au format [[l,r],[L,R]]. Renvoie 0pour les instances fausses et un entier positif pour les instances véridiques. Essayez-le en ligne!

Explication

Les principales idées sont

1. Une collision ne peut se produire qu'à une coordonnée entière ou demi-entière.
2. Il suffit de simuler le système jusqu'à ce qu'une répétition de deux états consécutifs soit rencontrée.

Voici le code annoté.

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 octets

Une implémentation naïve qui exécute simplement la simulation. Prend (a, b, c, d) comme 4 variables distinctes.

(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)

Cas de test

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 octets

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

Une fonction pure prenant les quatre arguments l1, r1, l2, r2en entrée: par exemple, [0,3,2,4]lorsque les intervalles sont [0,3]et [2,4].

Essayez-le en ligne!

Comment ça fonctionne

Pour obtenir un point [a,b]près d'un point [c,d], en supposant a<c<b<d, nous voulons un multiple impair de l' b-aintérieur b-cd'un multiple pair de d-c. Si b-aa plus de facteurs 2que d-c, nous pouvons faire en sorte que cela se produise exactement: il y aura un moment où le premier point est au bet le deuxième point est c, et ensuite nous sommes en bonne forme. Sinon, le mieux que nous puissions faire est le GCD de b-aet d-c.

JavaScript (ES6), 89 octets

(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))

Prend l1,r1,l2,r2comme arguments séparés. Explication: La simulation est garantie de se répéter après les (r1-l1)*(r2-l2)*2unités de temps (ou un facteur correspondant); gcalcule le décalage de l'objet approprié après les i/2unités de temps, il idoit donc aller jusqu'à (r1-l1)*(r2-l2)*4.

05AB1E , 12 10 14 octets

+4 octets pour gérer les plages négatives

Retourne 0 si faux, ou un entier positif sinon

Utilisez l'idée de Zgarb de doubler les valeurs pour faciliter la détection de la même position

Merci à @ Zacharý d'avoir signalé mes erreurs

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

Essayez-le en ligne!

Explications:

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

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

Essayez-le en ligne!

Réutilisation de l'algorithme Python de xnor .