मान लीजिए कि हमारे पास एक बाइनरी स्ट्रिंग है। हम निम्नलिखित में से प्रत्येक ऑपरेशन को कितनी भी बार लागू कर सकते हैं -
-
यदि संख्या में एक विकल्प "00" है, तो हम इसे "10" से बदल सकते हैं।
-
यदि संख्या में एक विकल्प "10" है, तो हम इसे "01" से बदल सकते हैं।
फिर हमें अधिकतम बाइनरी (इसके संख्यात्मक मान के आधार पर) स्ट्रिंग को खोजना होगा जिसे हम किसी भी संख्या में संचालन के बाद प्राप्त कर सकते हैं।
इसलिए, यदि इनपुट s ="001100" जैसा है, तो आउटपुट 111011 होगा, क्योंकि हम उन्हें (00)1100 -> 101(10)0 -> 1010(10) -> 10(10)01 जैसे स्थानांतरित कर सकते हैं -> 100(10)1 -> 1(00)011 -> 111011.
इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -
- लंबाई:=s का आकार
- शून्य :=s में 0s की संख्या
- यदि शून्य <2 है, तो
- वापसी
- s :=s के बाईं ओर से सभी '1' हटा दें
- leading_ones :=लंबाई - आकार s
- लीडिंग_ओन्स :=लीडिंग_ऑन्स + जीरो - 1
- trailing_ones :=लंबाई - अग्रणी_ones - 1
- answer_बाएं :=अग्रणी_वनों की संख्या 1s
- answer_right :=1s की पिछली_संख्या
- answer_left concatenate 0 concatenate answer_right and return
उदाहरण
आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -
def solve(s):
length = len(s)
zeros = s.count('0')
if zeros < 2:
return s
s = s.lstrip('1')
leading_ones = length - len(s)
leading_ones += zeros - 1
trailing_ones = length - leading_ones - 1
answer_left = '1' * leading_ones
answer_right = '1' * trailing_ones
return ''.join([answer_left, '0', answer_right])
s = "001100"
print(solve(s)) इनपुट
"001100"
आउटपुट
111011