पायथन का उपयोग करके सर्कुलर ट्रैक में सबसे अधिक देखे जाने वाले सेक्टर को खोजने का कार्यक्रम

मान लीजिए कि हमारे पास एक संख्या n और एक सरणी है जिसे राउंड कहा जाता है। हमारे पास एक गोलाकार ट्रैक है जिसमें 1 से n तक लेबल किए गए n विभिन्न सेक्टर हैं। अब मान लीजिए इस ट्रैक पर एक रेस होगी, रेस में मी अलग-अलग राउंड होंगे। छठा दौर सेक्टर राउंड [i - 1] से शुरू होता है और सेक्टर राउंड [i] पर समाप्त होता है। उदाहरण के लिए, यदि राउंड 1 सेक्टर राउंड [0] से शुरू होता है और सेक्टर राउंड [1] पर समाप्त होता है। इसलिए हमें सबसे अधिक देखे जाने वाले क्षेत्रों को आरोही क्रम में क्रमबद्ध करना होगा। (ट्रैक नंबर वामावर्त दिशा में सेक्टर नंबरों के आरोही क्रम में हैं)

इसलिए, यदि इनपुट n =4 राउंड =[1,3,1,2] जैसा है, तो आउटपुट [1, 2]

क्योंकि दौड़ सेक्टर 1 से शुरू होती है। विज़िट किए गए सेक्टरों का क्रम इस प्रकार है:[1,2,3 (पहले दौर का अंत), 4,1 (दूसरे दौर का अंत), 2 (तीसरे दौर का अंत)]। यहां दोनों सेक्टर 1 और 2 का दो बार दौरा किया जाता है और वे सबसे अधिक देखे जाने वाले सेक्टर हैं। और सेक्टर 3 और 4 का दौरा केवल एक बार किया जाता है।

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

• d :=एक नया नक्शा

• j के लिए 1 से n की सीमा में, करें

  • डी [जे]:=0

• d[राउंड[0]] :=1

• मेरे लिए 1 से लेकर राउंड के आकार -1 तक, करें

  • अगर राउंड[i]> राउंड[i-1], तो

    • j के लिए रेंज राउंड में[i-1]+1 से राउंड[i]+1, do

      • d[j] :=d[j] + 1

  • अन्यथा,

    • j के लिए रेंज राउंड में[i-1]+1 से n, do

      • d[j] :=d[j] + 1

    • j के लिए 1 से लेकर राउंड तक[i], करें

      • d[j] :=d[j] + 1

• curr :=d[राउंड[0]]

• आउट :=[राउंड[0]]

• 1 से n की सीमा में i के लिए, करें

  • अगर मैं राउंड [0] के समान नहीं हूं, तो

    • अगर d[i]> curr, तब

      • वक्र:=डी[i]

      • बाहर:=[i]

    • अन्यथा जब d[i] curr के समान है, तब

      • मुझे बाहर के साथ संलग्न करें

• छँटाई के बाद वापस लौटें

उदाहरण (पायथन)

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

def solve(n, rounds):
   d = {}
   for j in range(1,n+1):
      d[j] = 0
   d[rounds[0]] = 1
   for i in range(1, len(rounds)):
      if rounds[i] > rounds[i-1]:
         for j in range(rounds[i-1]+1, rounds[i]+1):
            d[j] += 1
      else:
         for j in range(rounds[i-1]+1,n+1):
            d[j] += 1
         for j in range(1,rounds[i]+1):
            d[j] += 1

   curr = d[rounds[0]]
   out = [rounds[0]]
   for i in range(1,n+1):
      if i != rounds[0]:
         if d[i] > curr:
            curr = d[i]
            out = [i]
         elif d[i] == curr:
            out = out + [i]
   return(sorted(out))

n = 4
rounds = [1,3,1,2]
print(solve(n, rounds))

इनपुट

4, [1,3,1,2]

आउटपुट

[1, 2]