पायथन में दो स्ट्रिंग्स का सबसे बड़ा मर्ज खोजने का कार्यक्रम

मान लीजिए कि हमारे पास दो तार s और t हैं। हम निम्नलिखित तरीके से मर्ज नामक एक स्ट्रिंग बनाना चाहते हैं:जबकि या तो s या t गैर-रिक्त हैं, निम्न विकल्पों में से एक का चयन करें -

• यदि s गैर-रिक्त है, तो पहले वर्ण को s में मर्ज करने के लिए संलग्न करें और इसे s से हटा दें।

• यदि t गैर-रिक्त है, तो t में पहले वर्ण को मर्ज करने के लिए संलग्न करें और इसे t से हटा दें।

अंत में, हमें शब्दावली की दृष्टि से सबसे बड़ा मर्ज ढूंढना होगा जिसे हम बना सकते हैं।

इसलिए, यदि इनपुट s ="zxyxx" t ="yzxxx" जैसा है, तो आउटपुट "zyzxyxxxxx" होगा

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

• ए:=0, बी:=0

• मर्ज :=रिक्त स्ट्रिंग

• W1 :=s का आकार

• W2 :=t का आकार

• जबकि a

  • यदि अनुक्रमणिका a से अंत तक s का प्रतिस्थापन> t को अनुक्रमणिका b से अंत तक प्रतिस्थापित किया जाए, तो

    • मर्ज :=मर्ज कॉन्टेनेट एस[ए]

    • ए:=ए + 1

  • अन्यथा,

    • मर्ज :=मर्ज कॉन्टेनेट टी[बी]

    • बी:=बी + 1

• रिटर्न मर्ज कॉन्टेनेट (इंडेक्स ए से एंड तक एस का सबस्ट्रिंग) कॉन्टेनेट (इंडेक्स बी से एंड तक टी का सबस्ट्रिंग)

उदाहरण

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

def solve(s, t):
   a = b = 0
   merge = ""

   W1 = len(s)
   W2 = len(t)
   while a < W1 and b < W2:
      if s[a:] > t[b:]:
         merge += s[a]
         a += 1
      else:
         merge += t[b]
         b += 1

   return merge + s[a:] + t[b:]

s = "zxyxx"
t = "yzxxx"
print(solve(s, t))

इनपुट

"zxyxx", "yzxxx"

आउटपुट

zyzxyxxxxx