पायथन में वर्गाकार सरणियों की संख्या खोजने का कार्यक्रम

मान लीजिए कि हम लोअरकेस अक्षरों का लक्ष्य स्ट्रिंग बनाना चाहते हैं। सबसे पहले, हमारे पास अनुक्रम n '?' है निशान (n लक्ष्य स्ट्रिंग की लंबाई है)। हमारे पास लोअरकेस अक्षरों की मुहर भी है। प्रत्येक मोड़ पर, हम स्टाम्प को अनुक्रम पर रख सकते हैं, और प्रत्येक अक्षर को उस स्टैम्प से संबंधित अक्षर से बदल सकते हैं। आप 10 * n मोड़ तक बना सकते हैं।

एक उदाहरण के रूप में प्रारंभिक अनुक्रम "???????" है, और स्टैम्प "abc" है, तो हम पहले में "abc ??", "?abc?", "??abc" जैसे तार बना सकते हैं। मोड़। यदि अनुक्रम पर मुहर लगाना संभव है, तो सूचकांक की एक सरणी लौटाएं जिसमें प्रत्येक मोड़ पर सबसे बाएं अक्षर पर मुहर लगी हो। यदि यह संभव नहीं है तो एक खाली सरणी लौटाएं। तो जब अनुक्रम "एबीसी" है, और स्टाम्प "एबीसी" है, तो उत्तर [0, 2] जैसा हो सकता है, क्योंकि हम "?????" -> "एबीसी ??" -> "एबीसी"।

इसलिए, यदि इनपुट s ="abcd" t ="abcdbcd" जैसा है, तो आउटपुट [3,0]

होगा।

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

यदि s का आकार 1 के समान है, तो
- 0 से t तक एक सूची लौटाएं जब t में सभी वर्ण समान हों और वे s [0] हों, अन्यथा एक नई रिक्त सूची
उत्तर :=एक नई सूची
जबकि t "?" के t संख्या के आकार के समान नहीं है निशान, करो
- टीएमपी:=टी
- मैं के लिए 0 से s के आकार की सीमा में, ऐसा करें
  - j के लिए s के आकार में i+1 से नीचे:
    - खोज:=मैं "?" की संख्या s [इंडेक्स i से j-1 तक] के सबस्ट्रिंग को जोड़ना
    - जब खोज t में हो, तब करें
      - उत्तर के अंत में t में जहां खोज मौजूद है वहां डालें
      - t :=खोज को "?" के s संख्या के आकार से बदलें केवल एक बार
    - यदि t, "?" के t संख्या के आकार के समान है, तो
      - लूप से बाहर आएं
    - यदि t, "?" के t संख्या के आकार के समान है, तो
      - लूप से बाहर आएं
  - अगर tmp, t के समान है, तो
    - लूप से बाहर आएं
उत्तर के विपरीत लौटें।

उदाहरण

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

def solve(s, t):
   if len(s) == 1:
      return [i for i in range(len(t))] if all(t==s[0] for t in t)else []

   ans = []
   while t != "?" * len(t):
      tmp = t
      for i in range(len(s)):
         for j in reversed(range(i+1, len(s)+1)):
            search = "?" * i + s[i:j] + "?" * (len(s)-j)
            while t.find(search) != -1:
               ans.append(t.find(search))
               t = t.replace(search, "?"*len(s), 1)
            if t == "?" * len(t): break
         if t == "?" * len(t): break
      if tmp == t: return []
   return ans[::-1]

s = "abcd"
t = "abcdbcd"
print(solve(s, t))

इनपुट

"abcd", "abcdbcd"

आउटपुट

[3,0]