पायथन में एक समीकरण को ठीक करने के लिए किए जाने वाले सुधारों की संख्या का पता लगाने के लिए कार्यक्रम

मान लीजिए कि हमारे पास एक स्ट्रिंग s है जो x+y=z रूप के समीकरण का प्रतिनिधित्व करती है। हमें अंकों की न्यूनतम संख्या ज्ञात करनी है जिसे हमें s में जोड़ने की आवश्यकता है ताकि समीकरण सत्य हो जाए।

इसलिए, यदि इनपुट s ='2+6=7' जैसा है, तो आउटपुट 2 होगा।

हम "1" और "2" डालकर समीकरण को "21+6=27" में बदल सकते हैं। तो आवश्यक सुधारों की कुल संख्या 2 है।

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

"+" वर्ण के आधार पर s को भागों में विभाजित करें, बाएँ भाग को A में और दाएँ भाग को विराम में रखें
आराम को "=" वर्ण के आधार पर भागों में विभाजित करें, बाएँ भाग को B में और दाएँ भाग को C में रखें
वापसी डीपी (ए का आकार -1, बी का आकार -1, सी -1 का आकार 0)
एक फ़ंक्शन को परिभाषित करें dp() । यह i, j, k, ले जाएगा
अगर मैं <=-1 और जे <=-1 और के <=-1, तो
- वापसी 0 यदि कैरी 0 के समान है अन्यथा 1
last1 :=(A[i]) अगर i>=0 अन्यथा 0
last2 :=(B[j]) अगर j>=0 अन्यथा 0
last3 :=(C[k]) अगर k>=0 अन्यथा 0
उपसर्ग1 :=(A[सूचकांक 0 से i + 1]) यदि i>=0 अन्यथा 0
उपसर्ग 2 :=(बी[सूचकांक 0 से जे + 1]) यदि j>=0 अन्यथा 0
उपसर्ग 3:=(सी [सूचकांक 0 से k + 1]) यदि k>=0 अन्यथा 0
अगर मैं <=-1 और जे <=-1, तो
- rhs :=उपसर्ग3 - कैरी करें
- अगर rhs <=0, तो
  - वापसी |rhs|
- अगर मैं -1 के समान हूं या j, -1 के समान है, तो
  - स्ट्रिंग rhs का वापसी आकार
- अन्यथा,
  - झूठी वापसी
- अगर के <=-1, तो
  - स्ट्र का वापसी आकार (उपसर्ग1 + उपसर्ग2 + कैरी)
- उत्तर:=अनंत
- कैरी 2, एलएचएस:=रिटर्न भागफल और शेष भाग (कैरी + लास्ट 1 + लास्ट 2) को 10 से विभाजित करना
- अगर lhs last3 जैसा ही है, तो
  - उत्तर :=डीपी(i-1, j-1, k-1, कैरी2)
- अनुरोध :=last3 - कैरी - last2
- extra_zeros :=अधिकतम 0, -1 - i
- कैरी2:=1 यदि अनुरोध <0 अन्यथा 0
- उत्तर:=न्यूनतम उत्तर, 1 + extra_zeros + dp (अधिकतम -1, i, j-1, k-1, कैरी2)
- अनुरोध :=last3 - कैरी - last1
- extra_zeros :=अधिकतम 0, -1 - j
- कैरी2:=1 यदि अनुरोध <0 अन्यथा 0
- ans =न्यूनतम (ans, 1 + extra_zeros + dp(i - 1, max(-1, j), k-1, take2))
- कैरी 2, एलएचएस:=रिटर्न भागफल और शेष भाग (अंतिम 1 + अंतिम 2 + कैरी) 10
- उत्तर:=न्यूनतम उत्तर, 1 + डीपी (i - 1, j - 1, k, कैरी 2)
- वापसी उत्तर
मुख्य विधि से वापसी dp (A का आकार – 1, B का आकार – 1, C – 1, 0) का आकार

उदाहरण

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

class Solution:
   def solve(self, s):
      A, rest = s.split("+")
      B, C = rest.split("=")
      def dp(i, j, k, carry):
         if i <= -1 and j <= -1 and k <= -1:
            return 0 if carry == 0 else 1
         last1 = int(A[i]) if i >= 0 else 0
         last2 = int(B[j]) if j >= 0 else 0
         last3 = int(C[k]) if k >= 0 else 0
         prefix1 = int(A[: i + 1]) if i >= 0 else 0
         prefix2 = int(B[: j + 1]) if j >= 0 else 0
         prefix3 = int(C[: k + 1]) if k >= 0 else 0
         if i <= -1 and j <= -1:
            rhs = prefix3 - carry
            if rhs <= 0:
               return abs(rhs)
            if i == -1 or j == -1:
               return len(str(rhs))
            else:
               assert False
         if k <= -1:
            return len(str(prefix1 + prefix2 + carry))
         ans = float("inf")
         carry2, lhs = divmod(carry + last1 + last2, 10)
         if lhs == last3:
            ans = dp(i - 1, j - 1, k - 1, carry2)
         req = last3 - carry - last2
         extra_zeros = max(0, -1 - i)
         carry2 = 1 if req < 0 else 0
         ans = min(ans, 1 + extra_zeros + dp(max(-1, i), j - 1, k - 1, carry2))
         req = last3 - carry - last1
         extra_zeros = max(0, -1 - j)
         carry2 = 1 if req < 0 else 0
         ans = min(ans, 1 + extra_zeros + dp(i - 1, max(-1, j), k - 1, carry2))
         carry2, lhs = divmod(last1 + last2 + carry, 10)
         ans = min(ans, 1 + dp(i - 1, j - 1, k, carry2))
         return ans
      return dp(len(A) - 1, len(B) - 1, len(C) - 1, 0)

ob = Solution()
print (ob.solve('2+6=7'))

इनपुट

'2+6=7'