पायथन में दिए गए समय के समान अंकों का पुन:उपयोग करके निकटतम समय खोजने का कार्यक्रम

मान लीजिए कि हमारे पास "hh:mm" प्रारूप में 24 घंटे की स्ट्रिंग है, तो हमें अगला निकटतम समय ज्ञात करना होगा जो दिए गए अंकों का पुन:उपयोग करके बनाया जा सकता है। हम दी गई स्ट्रिंग से अंकों को जितनी बार चाहें पुन:उपयोग कर सकते हैं।

इसलिए, यदि इनपुट s ="03:15" जैसा है, तो आउटपुट 03:30 होगा, निकटतम समय 03:30 जो दिए गए अंकों को दोहराता है।

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

• उपयोग :=दो अंकों की घंटे और दो अंकों की मिनट के मान वाली एक सूची
• संभव:=एक नया सेट
• एक फ़ंक्शन को परिभाषित करें backtrack() । यह रास्ता लेगा
• यदि पथ का आकार 4 के समान है, तो
  • (पथ [पहले दो अंक] ":" को जोड़ना पथ [अंतिम दो अंक]) और इसे संभव में सम्मिलित करें।
  • वापसी
• उपयोग में प्रत्येक p के लिए, करें
  • अगर (पथ का आकार 0 और p> "2" के समान है) गलत है और (पथ "2" के समान है और p> "3") गलत है और (पथ का आकार 2 और p के समान है)> "5") गलत है, तो
    • बैकट्रैक (पथ + पी)
• मुख्य विधि से निम्न कार्य करें:
• बैकट्रैक(रिक्त स्ट्रिंग)
• संभव:=संभव से एक नई सूची
• संभव सूची को क्रमबद्ध करें
• मैं के लिए 0 से संभव के आकार के लिए - 2, करते हैं
  • यदि संभव हो तो[i] s के समान है, तो
    • वापसी संभव[i + 1]
• वापसी संभव है[0]

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

उदाहरण

class Solution:
   def solve(self, s):
      use = [s[0], s[1], s[3], s[4]]
      possible = set()

      def backtrack(path):
         nonlocal possible, use
         if len(path) == 4:
            possible.add(path[:2] + ":" + path[2:])
            return
         for p in use:
            if (not (len(path) == 0 and p > "2") and not (path == "2" and p > "3") and not (len(path) == 2 and p > "5")):
backtrack(path + p)

         backtrack("")
         possible = list(possible)
         possible.sort()
         for i in range(len(possible) - 1):
            if possible[i] == s:
               return possible[i + 1]
         return possible[0]

ob = Solution()
s = "03:15"
print(ob.solve(s))

इनपुट

"03:15"

आउटपुट

03:30