पायथन में दो स्ट्रिंग्स के बीच लेक्सिकोग्राफिकली बड़ी परम्युटेशन मौजूद है या नहीं जांचने का प्रोग्राम

मान लीजिए हमारे पास समान आकार की दो स्ट्रिंग्स s और t हैं, हमें जांचना है कि क्या s की कोई परम्युटेशन s1 और t की कोई परम्युटेशन t1 ऐसी है कि: सभी 0 <= i < n के लिए s1[i] <= t1[i] या सभी 0 <= i < n के लिए t1[i] <= s1[i]।

उदाहरण के लिए, यदि इनपुट s = "vyx" और t = "wzx" है, तो आउटपुट True होगा, क्योंकि हम s1 = "vxy" और t1 = "wxz" ले सकते हैं।

समाधान दृष्टिकोण

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

• यदि s और t खाली हैं: True लौटाएं
• s := sorted(s), t := sorted(t)
• एक फंक्शन util(s1, t1) परिभाषित करें:
  • i के लिए 0 से len(s1): यदि s1[i] > t1[i] तो False लौटाएं
  • True लौटाएं
• मुख्य मेथड से:
  • यदि util(s, t): True लौटाएं
  • s, t स्वैप करें
  • util(s, t) लौटाएं

उदाहरण कोड

class Solution:
    def solve(self, s, t):
        if not len(s) or not len(t):
            return True
        s = sorted(s)
        t = sorted(t)
        def util(s1, t1):
            for i in range(len(s1)):
                if s1[i] > t1[i]:
                    return False
            return True
        if util(s, t):
            return True
        s, t = t, s
        return util(s, t)

ob = Solution()
s = "vyx"
t = "wzx"
print(ob.solve(s, t))

इनपुट

"vyx", "wzx"

आउटपुट

True