पायथन में दो बार एक ही स्ट्रिंग के संयोजन के रूप में स्ट्रिंग बनाने के लिए आवश्यक संचालन की संख्या की गणना करने के लिए कार्यक्रम

मान लीजिए कि हमारे पास एक लोअरकेस स्ट्रिंग s है। अब एक ऑपरेशन पर विचार करें, जहां हम s में किसी भी कैरेक्टर को डिलीट, इंसर्ट या अपडेट कर सकते हैं। हमें किसी भी स्ट्रिंग t के लिए s =(t concatenate t) बनाने के लिए आवश्यक न्यूनतम संक्रियाओं की संख्या गिननी होगी।

इसलिए, यदि इनपुट s ="pqrxqsr" जैसा है, तो आउटपुट 2 होगा, क्योंकि, हम "x" को "p" से अपडेट कर सकते हैं और "s" को हटा सकते हैं, तो s "pqrpqr" है, यह s =है t, t ="pqr" के लिए, t को संयोजित करें।

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

• एक फ़ंक्शन को परिभाषित करें edit_distance()। इसमें s1, s2 लगेगा
• m :=s1 का आकार
• n :=s2 का आकार
• cur :=0 से n तक की एक नई सूची
• 0 से m-1 की सीमा में i के लिए
  • पिछला :=वक्र
  • cur :=एक सूची (i + 1) और फिर n संख्या 0s
  • जे के लिए 0 से n -1 की सीमा में, करो
    • cur[j + 1] :=prev[j] अगर s1[i] और s2[j] समान हैं अन्यथा (न्यूनतम cur[j], prev[j], prev[j + 1]) + 1
• वापसी वक्र[n]
• मुख्य विधि से, निम्न कार्य करें -
• res :=s का आकार
• i के लिए 0 से लेकर s-1 के आकार तक के लिए
  • res :=कम से कम edit_distance (इंडेक्स 0 से i-1 तक s का सबस्ट्रिंग, इंडेक्स i से एंड तक s का सबस्ट्रिंग) और res
• रिटर्न रेस

उदाहरण

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

def solve(s):
   def edit_distance(s1, s2):
      m, n = len(s1), len(s2)
      cur = list(range(n + 1))
      for i in range(m):
         prev, cur = cur, [i + 1] + [0] * n
         for j in range(n):
            cur[j + 1] = (prev[j]
            if s1[i] == s2[j] else min(cur[j], prev[j], prev[j + 1]) + 1)
         return cur[n]

   res = len(s)
   for i in range(len(s)):
      res = min(edit_distance(s[:i], s[i:]), res)
   return res

s = "pqrxqsr"
print(solve(s))

इनपुट

"pqrxqsr"

आउटपुट

None