बाद की लंबाई को खोजने के लिए कार्यक्रम जिसे अभी भी हटाया जा सकता है t पायथन में s के बाद है

मान लीजिए कि हमारे पास एक स्ट्रिंग s और दूसरी स्ट्रिंग t है। और t, s का अनुगमन है। हमें एक सबस्ट्रिंग की अधिकतम लंबाई ज्ञात करनी होगी जिसे हम s से हटा सकते हैं ताकि, t अभी भी s का अनुवर्ती हो।

इसलिए, यदि इनपुट s ="xyzxyxz" t ="yz" जैसा है, तो आउटपुट 4 होगा, क्योंकि हम सबस्ट्रिंग "abca" को हटा सकते हैं

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

बाएँ:=एक नई सूची, दाएँ:=एक नई सूची भी
c1 :=-1, c2 :=-1, c3 :=-1
जे:=0
मैं के लिए 0 से s के आकार की सीमा में, ऐसा करें
- यदि s[i] t[j] के समान है, तो
  - बाईं ओर अंत में i डालें
  - जे:=जे + 1
- यदि j, t के आकार के समान है, तो
  - c1 :=s - i - 1 का आकार
  - लूप से बाहर आएं
j :=t - 1 का आकार
मैं के लिए s - 1 से 0 के श्रेणी आकार में, 1 से घटाएं
- यदि s[i] t[j] के समान है, तो
  - i को दाईं ओर 0 की स्थिति में डालें
  - जे:=जे - 1
- अगर j, -1 के समान है, तो
  - c2 :=मैं
  - लूप से बाहर आएं
मैं के लिए 0 से टी -1 के आकार में, करो
- c3 :=अधिकतम c3 और (दाएं[i + 1] - बाएं[i] - 1)
अधिकतम c1, c2 और c3 लौटाएं

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

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

class Solution:
   def solve(self, s, t):
      left = []
      right = []
      c1 = -1
      c2 = -1
      c3 = -1
      j = 0
      for i in range(len(s)):
         if s[i] == t[j]:
            left.append(i)
            j += 1
         if j == len(t):
            c1 = len(s) - i - 1
            break
      j = len(t) - 1
      for i in range(len(s) - 1, -1, -1):
         if s[i] == t[j]:
            right.insert(0, i)
            j -= 1
         if j == -1:
            c2 = i
            break
      for i in range(len(t) - 1):
         c3 = max(c3, right[i + 1] - left[i] - 1)
      return max(c1, c2, c3)
ob = Solution()
s = "xyzxyxz"
t = "yz"
print(ob.solve(s, t))

इनपुट

"xyzxyxz", "yz"