पायथन में विकल्प लेकर सभी संभावित तार उत्पन्न करने का कार्यक्रम

मान लीजिए कि हमारे पास लोअरकेस वर्णमाला वर्णों की एक स्ट्रिंग है, अन्य वर्ण जैसे "[", "|", और "]"। यहाँ "[a|b|c]" इंगित करता है कि या तो "a", "b", या "c" को एक संभावना के रूप में चुना जा सकता है। हमें उन सभी संभावित मानों वाले स्ट्रिंग्स की एक सूची ढूंढनी होगी जो s प्रतिनिधित्व कर सकते हैं। यहां "[]" को नेस्ट नहीं किया जा सकता है और इसमें कई विकल्प हो सकते हैं।

इसलिए, यदि इनपुट s ="[d|t|l]im[e|s]" जैसा है, तो आउटपुट ['डाइम', 'डिम्स', 'लाइम', 'लिम्स', 'टाइम' होगा। , 'टाइम्स']

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

अगर s खाली है, तो
- रिक्त स्ट्रिंग वाली सूची लौटाएं
n :=आकार का
seq:=एक नई सूची, res:=एक नई सूची
एक फंक्शन हेल्पर () को परिभाषित करें। यह स्थिति लेगा
- यदि स्थिति n के समान है, तो
  - seq में मौजूद प्रत्येक तत्व से जुड़ें और res में डालें
- अन्यथा,
  - अगर "[" एस के विकल्प में [सूचकांक स्थिति से अंत तक], तो
    - प्रारंभ :=pos + अनुक्रमणिका "[" s के स्थानापन्न में [सूचकांक स्थिति से अंत तक]
    - end :=pos + index of "]" s के सबस्ट्रिंग में [इंडेक्स पॉज़ से एंड तक]
    - एस के सबस्ट्रिंग में प्रत्येक विकल्प के लिए शुरू से अंत तक "|" से विभाजित किया जाता है, करते हैं
      - एस [इंडेक्स पॉज़ से स्टार्ट - 1] डालें
      - seq के अंत में विकल्प डालें
      - सहायक(अंत + 1)
      - seq से अंतिम दो तत्व हटाएं
- अन्यथा,
  - seq के अंत में [सूचकांक स्थिति से अंत तक] डालें
  - सहायक(एन)
  - seq से अंतिम तत्व हटाएं
मुख्य विधि से निम्न कार्य करें:
सहायक(0)
रिटर्न रेस को क्रमबद्ध क्रम में

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

उदाहरण

class Solution:
   def solve(self, s):
      if not s:
         return [""]
      n = len(s)

      def helper(pos):
         if pos == n:
            res.append("".join(seq))
         else:
            if "[" in s[pos:]:
               start = pos + s[pos:].index("[")
               end = pos + s[pos:].index("]")
               for option in s[start + 1 : end].split("|"):
                  seq.append(s[pos:start])
                  seq.append(option)
                  helper(end + 1)
                  seq.pop()
                  seq.pop()
            else:
               seq.append(s[pos:])
               helper(n)
               seq.pop()

         seq = []
         res = []
         helper(0)
         return sorted(res)

ob = Solution()
s = "[d|t|l]im[e|s]"
print(ob.solve(s))

इनपुट

"[d|t|l]im[e|s]"

आउटपुट

['dime', 'dims', 'lime', 'lims', 'time', 'tims']