पायथन प्रोग्राम यह पता लगाने के लिए कि एक गोलाकार ट्यूब में गेंदें कितनी बार टकराएंगी

मान लीजिए, एक गोलाकार ट्यूब में n गेंदें हैं। ट्यूब 100 मीटर लंबी है और शुरू में, ट्यूब में प्रत्येक गेंद एक बिंदु से i मीटर दूर है जिसे हम शुरुआती बिंदु कहते हैं। अब गेंदें अलग-अलग दिशाओं में गोलाकार क्रम में ट्यूब के भीतर यात्रा करना शुरू कर देती हैं। गेंदें ट्यूब के भीतर 0.1 मीटर प्रति सेकंड की यात्रा करती हैं। जब दो गेंदें एक बिंदु पर मिलती हैं, तो टक्कर होती है और गेंदें अपनी यात्रा की दिशा बदल देती हैं। यदि यह प्रक्रिया लंबे समय तक चलती है, तो मान लें कि 10^9 + 6 सेकंड; हमें यह पता लगाना है कि गेंदें कितनी बार टकराती हैं। प्रारंभिक बिंदु से गेंदों की प्रारंभिक दूरी इनपुट के रूप में दी गई है।

इसलिए, यदि इनपुट input_array =[0, 10] जैसा है, तो आउटपुट 400000

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

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• सूची को क्रमबद्ध करें input_array
• आकार:=input_array का आकार
• lap_count :=(10^5)*2
• आउटपुट :=2 * lap_count * फ्लोर वैल्यू (आकार / 2) * (आकार - फ्लोर वैल्यू (आकार / 2))
• रोकें:=0
• मैं के लिए 0 से आकार -1 की सीमा में, करो
• यदि स्टॉप 1 के समान नहीं है, तो
  • अगर input_array[i] + 1 input_array[i+1] के समान है, तो
    • आउटपुट:=आउटपुट + 2
    • रोकें:=1
  • अन्यथा,
    • रोकें:=0
• अन्यथा,
  • रोकें:=0
• रिटर्न आउटपुट

उदाहरण

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

def solve(input_array):
   input_array.sort()
   size = len(input_array)
   lap_count = (10**5)*2
   output = 2*lap_count*(size//2)*(size - size//2)
   stop = 0
   for i in range(size - 1):
      if stop != 1:
         if input_array[i] + 1 == input_array[i+1]:
            output+=2
            stop = 1
         else:
            stop = 0
      else:
         stop = 0
   return output
print(solve([0, 10]))

इनपुट

[0, 10]

आउटपुट

400000