पायथन में तीन शर्तों में से एक को पूरा करने के लिए न्यूनतम वर्ण बदलने का कार्यक्रम

मान लीजिए कि हमारे पास केवल लोअरकेस अक्षरों के साथ दो तार s और t हैं। एक ऑपरेशन में, हम s या t के किसी भी वर्ण को किसी भी छोटे अक्षर में बदल सकते हैं। हमें निम्नलिखित तीन शर्तों में से एक को पूरा करना होगा -

s का प्रत्येक अक्षर वर्णमाला के t के प्रत्येक अक्षर से कड़ाई से छोटा होता है।
t में प्रत्येक अक्षर वर्णमाला के s के प्रत्येक अक्षर से कड़ाई से छोटा है।
s और t दोनों में केवल एक अलग अक्षर होता है।

हमें परिणाम प्राप्त करने के लिए आवश्यक न्यूनतम संक्रियाओं की संख्या ज्ञात करनी होगी।

इसलिए, यदि इनपुट s ="sts", t ="uss" जैसा है, तो आउटपुट 2 होगा क्योंकि

यदि हम 2 संक्रियाओं में t को "uuu" में बदलते हैं, तो s का प्रत्येक अक्षर t के प्रत्येक अक्षर से छोटा होता है।
यदि हम 3 ऑपरेशनों में s को "ttt" और t को "sss" में बदलते हैं, तो t का प्रत्येक अक्षर s के प्रत्येक अक्षर से छोटा होता है।
अगर हम 2 ऑपरेशनों में s को "sss" और t को "sss" में बदलते हैं, तो s और t में एक अलग अक्षर होता है।

यहां 2 ऑपरेशन (या तो 1 या 3) में सबसे अच्छा तरीका किया गया था।

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

काउंटर_एस:=प्रत्येक वर्ण की आवृत्ति को s में रखने के लिए नक्शा
काउंटर_टी:=टी में प्रत्येक वर्ण की आवृत्ति रखने के लिए नक्शा
less_s:=अनंत, कम_t:=अनंत, अद्वितीय:=अनंत
accu_s:=0, accu_t:=0
लोअरकेस अंग्रेज़ी वर्ण में प्रत्येक वर्ण c के लिए, करें
- अद्वितीय:=अद्वितीय का न्यूनतम और (एस का आकार + टी का आकार - काउंटर_एस [सी] - काउंटर_टी [सी])
  - काउंटर_टी[सी])
- यदि c का ascii 'a' के ascii से बड़ा है, तो
  - less_a :=कम से कम_s और (s का आकार - accu_s + accu_t)
  - less_b :=कम से कम कम_t और (आकार t - accu_t + accu_s)
- accu_s :=accu_s + counter_s[c]
- accu_t:=accu_t + counter_t[c]
कम से कम कम_s, less_t और अद्वितीय लौटाएं

उदाहरण

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

from collections import Counter
import string
def solve(s, t):
   counter_s = Counter(s)
   counter_t = Counter(t)
   less_s, less_t, unique = float('inf'), float('inf'), float('inf')
   accu_s, accu_t = 0, 0
   for c in string.ascii_lowercase:
      unique = min(unique, len(s) + len(t) - counter_s[c] - counter_t[c])
      if c > 'a':
         less_a = min(less_s, len(s) - accu_s + accu_t)
         less_b = min(less_t, len(t) - accu_t + accu_s)
      accu_s += counter_s[c]
      accu_t += counter_t[c]
   return min(less_s, less_t, unique)

s = "sts"
t = "uss"
print(solve(s, t))

इनपुट

"sts", "uss"