जब बुलेट्स टकराती हैं

Question

यह चुनौती एक पहेली से दूर है जो मैंने कुछ समय पहले किसी किताब में पढ़ी थी, जो मुझे फिर से यहाँ मिली । यह एक बंदूक से एक बार प्रति सेकंड अलग गति से चलने वाली गोलियों के बारे में है जो एक सीधी रेखा में हमेशा के लिए यात्रा करती है। जब एक गोली दूसरे से टकराती है, तो दोनों पूरी तरह से नष्ट हो जाते हैं। ("मिसाइल" के साथ "बुलेट" के सभी उदाहरणों को बदलने के लिए स्वतंत्र महसूस करें।)

काम

जिस क्रम में उन्हें निकाल दिया गया है, उसमें बुलेट की गति की सूची को देखते हुए, यह निर्धारित करें कि क्या सभी गोलियां नष्ट हो गई हैं।

नियम

• इनपुट गैर-नकारात्मक पूर्णांक की एक सूची है, जिसे किसी भी सीमांकक द्वारा अलग किया गया है और पहले और बाद में एक वैकल्पिक चरित्र के साथ। ये मान्य इनपुट हैं: 1 2 3 4 5 6और [1,2,3,4,5,6]। प्रोग्रामर चुनाव करता है।
• एक सत्य मूल्य का उत्पादन करें यदि कम से कम एक गोली हमेशा के लिए बच जाए और एक मिथ्या मूल्य।
• प्रति सेकंड इकाइयों में बुलेट की गति दी जाती है।
• गोलियां एक साथ और लगातार चलती हैं।
• गोलियां भिन्नात्मक ऑफसेट पर टकरा सकती हैं।
• कई गोलियां जो एक साथ एक ही स्थिति में पहुंचती हैं, चाहे वह मूल से एक अभिन्न या आंशिक ऑफसेट हो, सभी एक दूसरे से टकराते हैं।

उदाहरण

इन आरेखों में, Gबंदूक, >गोलियों का प्रतिनिधित्व करता है , और *ऐसे समय होते हैं जब गोलियां टकराती हैं और फट जाती हैं।

Truthy

इनपुट: 0

        0123456789
Time 0 G>
     1 G>
     2 G>
   ...

आउटपुट: 1

---

इनपुट: 0 0 0

        0123456789
Time 0 G>
     1 G*
     2 G>
     3 G>
     4 G>
   ...

आउटपुट: 1

---

इनपुट: 1

        0123456789
Time 0 G>
     1 G >
     2 G  >
     3 G   >
   ...

आउटपुट: 1

---

इनपुट: 2 1

        0123456789
Time 0 G>
     1 G> >
     2 G >  >
     3 G  >   >
     4 G   >    >
   ...

आउटपुट: 1

---

इनपुट: 2 3 1

        0123456789
Time 0 G>
     1 G> >
     2 G>  >>
     3 G >    *
     4 G  >
     5 G   >
   ...

आउटपुट: 1

---

Falsy

इनपुट: 1 2 3 4 5 6

        Unit      1111111111
        01234567890123456789
Time 0 G>
     1 G>>
     2 G> *
     3 G>  >
     4 G>   > >
     5 G>    >  >>
     6 G      >   > *
     7 G            >  >
     8 G                  > >
     9 G                        >>
    10 G                              *
                  111111111122222222223
        0123456789012345678901234567890

आउटपुट: 0

---

इनपुट: 1 0 0 3

        Unit
        0123456789
Time 0 G>
     1 G>>
     2 G* >
     3 G>  >
     4 G   >>
     5 G     *

(दूसरी टक्कर 4.5 समय पर है)
आउटपुट:0

---

इनपुट: 2 1 2 3 6 5

        Unit      1111111111
        01234567890123456789
Time 0 G>
     1 G> >
     2 G>>  >
     3 G> *   >
     4 G>  >    >
     5 G>     *   >
     6 G     >      >
     7 G          >   >
     8 G               >>
     9 G                *
                  1111111111
        01234567890123456789

आउटपुट: 0

---

इनपुट: 2 3 6

        Unit
        0123456789
Time 0 G>
     1 G> >
     2 G>  >>
     3 G      *

आउटपुट: 0

Comments

क्या मुझे इनपुट की तरह सीमांकित करने की आवश्यकता हो सकती है 1<enter>2<enter>3...?

— बिल्ली

@sysreq: वह इसे आगे बढ़ा रहा है, लेकिन मैं इसकी अनुमति दूंगा।

— एल'एंडिया स्ट्रोमैन

मैं क्यूनिटोपिया से सहमत हूं - यह चुनौती बहुत कठिन है, लेकिन मैं एक समाधान पर काम कर रहा हूं ...

— zmerch

Answer 1

पायथन 2, 388 392 388 346 342 336 331 बाइट्स

z=k=input();l=len(k);v=range;u=v(l)
while l<z:
 r="";o=[r]*l;z=l
 for h in v(l):
    if r:o[h-1]=o[m]=r;m=h;r=""
    for j in v(h+1,l):
     p=k[h];q=k[j];t=u[j];n=(1.0*q*t-p*u[h])/(q-p)if q-p else""if p>0 else t
     if t<=n<r<()>o[j]>=n<=o[h]:r=n;m=j
 i=0;s=o and min(o)
 while i<l:
    if o[i]==s!="":del k[i],o[i],u[i];l-=1
    else:i+=1
print l

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

मुझे यकीन नहीं है कि अगर मैं समझा सकता हूं कि यह घंटों तक टाइप किए बिना कैसे काम करता है, तो मैं सिर्फ एक कार्यकारी सारांश दूंगा।

जब तक इनपुट सूची सिकुड़ती नहीं है तब तक मुख्य मुख्य लूप लूपिंग होता है।

लूप के लिए नेस्टेड (क्या आप विश्वास कर सकते हैं कि लूप के लिए नेस्टेड वास्तव में यहां सबसे छोटा है?) प्रत्येक बुलेट स्पीड पर लूप करता है numpy.rootsऔर गणना करने के लिए उपयोग करता है कि किस समय पर आने वाली प्रत्येक बुलेट के साथ बुलेट टकरा जाएगी। यहां, ""अनंत (कोई चौराहा) का मतलब करने के लिए इस्तेमाल किया जा रहा है। एक अतिरिक्त सशर्त को यह सुनिश्चित करने के लिए शामिल किया जाना चाहिए कि रुकी हुई गोलियों को उस समय के रूप में चिह्नित किया जाता है जब वे समय के बजाय शून्य पर दिखाई देते हैं।

प्रत्येक संख्या के लिए हम इस बात पर नज़र रखते हैं कि यह किस गोली से टकराएगा, यदि कोई हो, और फिर oशामिल किए गए बुलेट के लिए न्यूनतम टकराव के समय के साथ अपडेट किया जाए।

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

फिर हम शेष गोलियों पर पूरी प्रक्रिया को दोहराते हैं, क्योंकि वे अब तक प्राप्त करने में सक्षम हो सकते हैं कि जिन गोलियों से वे टकराए थे वे नष्ट हो गए हैं।

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

संपादित करें: मुझे कीड़े खोजने में मदद करने के लिए परीक्षण मामलों को उत्पन्न करने के लिए विशेष धन्यवाद।

EDIT 2: 42 बाइट्स को अंकुश का उपयोग करने के बजाय रैखिक समीकरण को हाथ से हल करके सहेजा, और शुरुआती समय को एक अलग सूची में विभाजित करके एक सशर्त का पुनर्गठन किया।

EDIT 3: रेंज का नाम बदलकर 4 बाइट्स सहेजे गए

संपादित करें 4: टैब के साथ डबल रिक्त स्थान को बदलकर 6 और बाइट्स सहेजे गए। इसके अलावा, फ्रैर्सम अपने कार्यान्वयन को तुलना के लिए भिन्न और सेटों का उपयोग करने के लिए पर्याप्त था। मैंने इसे थोड़ा सा गोल्फ दिया है और यह मेरे समाधान को बांधते हुए 331 बाइट्स के लिए निकला है।

EDIT 5: एक अनावश्यक इनिशियलाइज़ेशन को हटाकर और एक सशर्त पुनर्लेखन करके 5 बाइट्स को बचाया

Comments

क्या आपने फिर से उदाहरण इनपुट का परीक्षण नहीं किया? [1, 0, 0, 3] काम नहीं करता है।

— feersum

@ Faersum केवल एक ही था जिसका मैंने परीक्षण नहीं किया था, ख़तरा। लेकिन तय हो गया। इस सभी के साथ, मैं एक उत्तर प्रदेश प्राप्त करता हूं। : पी

— क्विंटोपिया

फिर भी काम नहीं करता है। [१, १६, १ 18, २०, ३०] १ को वापस करना चाहिए

— १um

ठीक है अब यह काम करने लगता है, ज्यादातर समय कम से कम।

— feersum