दोलन समानता

Question

हमारे पास ऐसी वस्तुएँ हैं जो दो पूर्णांक बिंदुओं के बीच [l, r], एक इकाई की गति प्रति समय इकाई lपर शुरू होती हैं t=0। आप मान सकते हैं l < r। उदाहरण के लिए, यदि कोई वस्तु दोलन करती है [3, 6], तो हमारे पास है:

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

आदि। लेकिन वस्तुओं लगातार दोलन करती हैं, इसलिए हमारे पास भी है t=0.5 -> 3.5और t=3.7 -> 5.3।

यह देखते हुए दो वस्तुओं के बीच झूलते [l1, r1], [l2, r2], निर्धारित अगर वहाँ कभी एक समय होता है tऐसी है कि दो वस्तुओं एक ही स्थिति को साझा करें। आप l1, r1, l2, r2किसी भी सुविधाजनक प्रारूप में लेते हैं , और किसी भी सत्य / झूठे मूल्यों का उत्पादन करते हैं।

---

सत्य इनपुट्स:

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

मिथ्या इनपुट:

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

Comments

तो यह एक नुकीला लहर एक sinusoid, सही नहीं है?

— हाइपरनेत्रिनो

संदर्भ के लिए यह चुनौती इस खेल को संदर्भित करती है , जहां आपको यह पता लगाना होगा कि क्या एक ब्लॉक से दूसरे में कूदना संभव है।

— user202729

@ हाइपरनेट्रिनो सही।

— orlp

क्या झूठे मूल्य 0किसी भी सकारात्मक पूर्णांक को सत्य कर सकते हैं या उन्हें सुसंगत होना चाहिए। इससे भी अधिक, क्या झूठी सूची खाली सूची हो सकती है और सत्य किसी भी गैर-खाली सूची हो सकती है?

— श्री Xcoder

एक अच्छा मिथ्या परीक्षण है [[1,3],[2,6]]: यह अनुमान के अनुसार "अंतरालों को ओवरलैप करता है और समान लंबाई नहीं है" को गलत ठहराता है ।

— मिशा लावरोव

Answer 1

पायथन 2 , 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 2

भूसी , 13 बाइट्स

VEΣUẊeTmȯ…¢mD

प्रारूप में इनपुट लेता है [[l,r],[L,R]]। 0मिथ्या उदाहरणों के लिए रिटर्न और सत्य उदाहरणों के लिए एक सकारात्मक पूर्णांक। इसे ऑनलाइन आज़माएं!

व्याख्या

मुख्य विचार हैं

1. एक टकराव केवल पूर्णांक या आधे-पूर्णांक समन्वय पर हो सकता है।
2. यह लगातार दो राज्यों की पुनरावृत्ति होने तक सिस्टम को अनुकरण करने के लिए पर्याप्त है।

यहाँ कोड एनोटेट किया गया है।

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

Comments

चालाक जवाब। आपको प्रत्येक को दोगुना करने की आवश्यकता क्यों है? यह है कि बयान को टकराने के लिए "टकराव केवल पूर्णांकों पर हो सकता है या आधे पूर्णांक" में हो सकता है "टकराव केवल पूर्णांक पर हो सकता है"?

— योना

@ जोना हां, बिल्कुल।

— जर्बर्ग

Answer 3

जावास्क्रिप्ट (ईएस 6), 104 100 बाइट्स

एक भोली कार्यान्वयन जो सिर्फ सिमुलेशन चलाता है। 4 अलग चर के रूप में (ए, बी, सी, डी) लेता है ।

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

परीक्षण के मामलों

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

Answer 4

Wolfram भाषा (Mathematica) , 77 69 61 बाइट्स

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

l1, r1, l2, r2इनपुट के रूप में चार तर्कों को लेते हुए एक शुद्ध कार्य : जैसे,[0,3,2,4] जब अंतराल होते हैं [0,3]और [2,4]।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

एक बिंदु के [a,b]करीब एक बिंदु प्राप्त करने के लिए [c,d], मान a<c<b<dलेते हैं, हम एक से भी अधिक के b-aभीतर एक विषम एकाधिक चाहते b-cहैं d-c। अगर b-aकी अधिक कारकों है 2की तुलना में d-c, हम इस वास्तव में ऐसा कर सकते हैं: जब पहली बिंदु पर है एक समय हो जाएगा bऔर दूसरे बिंदु पर है c, और फिर हम अच्छी हालत में हैं। यदि नहीं, तो हम जो सबसे अच्छा कर सकते हैं वह है जीसीडी b-aऔर d-c।

Answer 5

जावास्क्रिप्ट (ईएस 6), 89 बाइट्स

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

l1,r1,l2,r2अलग तर्क के रूप में लेता है। स्पष्टीकरण: सिमुलेशन को (r1-l1)*(r2-l2)*2समय इकाइयों (या उसके बाद एक कारक) के बाद दोहराने की गारंटी है ; समय इकाइयों के gबाद उपयुक्त वस्तु की ऑफसेट गणना करता है i/2, इसलिए iइसे ऊपर तक सीमित करने की आवश्यकता है (r1-l1)*(r2-l2)*4।

Answer 6

05AB1E , 12 10 14 बाइट्स

नकारात्मक सीमाओं को संभालने के लिए +4 बाइट्स

अगर गलत है, तो 0 लौटाएँ, अन्यथा सकारात्मक पूर्णांक

एक ही स्थिति का पता लगाने को आसान बनाने के लिए ज़र्गब के मूल्यों को दोगुना करने के विचार का उपयोग करें

मेरी गलतियों को इंगित करने के लिए @ Zacharý को धन्यवाद

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

Ä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

Comments

मुझे नहीं लगता कि यह बड़ी सूची श्रेणियों के लिए काम करेगा, क्योंकि 100 बहुत मनमाना लगता है।

— जकार्इ

@ Zacharý धन्यवाद! मैंने इसे बहुत अप्रभावी तरीके से तय किया है, क्योंकि अब सूचियों को कई बार दोहराया जाता है। :-)

— स्कूटनीट

वास्तव में, यह अभी भी काम नहीं कर सकता है (मुझे यह पता लगाने के लिए परेशान नहीं किया जाएगा कि कैसे, क्योंकि इसमें बहुत लंबा समय लगेगा, और ईमानदारी से, सूचियों को एक छोटी रेंज और एक बड़ी रेंज होना होगा जो मुझे लगता है कि काम नहीं करेगा। )

— ज़ाचारि

@ Zacharý यह मनमाने ढंग से बड़े सकारात्मक पूर्णांकों के लिए काम करना चाहिए, क्योंकि सबसे खराब स्थिति होगी [[0,n],[n-1, n]]और यहां तक ​​कि उस मामले में, पहली बार अपनी ऊपरी सीमा तक पहुंचने के लिए दूसरी सूची को पर्याप्त बार (और अधिक) दोहराया जाएगा। लेकिन मैं नकारात्मक संख्याओं को ध्यान में रखना भूल गया: [[-100, 1], [0, 1]]काम नहीं करता। 4 बाइट्स की लागत से इसे ठीक करना :-(

— स्कूटनीट

Answer 7

जावा (ओपनजेडके 8) , 81 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पुन: उपयोग करना xnor का पायथन एल्गोरिथम ।