पायथन में बाइनरी गैप

मान लीजिए हमारे पास एक धनात्मक पूर्णांक N है, हमें N के बाइनरी प्रतिनिधित्व में दो लगातार 1's के बीच की सबसे लंबी दूरी ज्ञात करनी है। यदि दो लगातार 1's नहीं हैं, तो 0 वापस करें।

उदाहरण के लिए, यदि इनपुट 22 है, तो आउटपुट 2 होगा, क्योंकि 22 का बाइनरी 10110 है। 22 के बाइनरी प्रतिनिधित्व में तीन 1 हैं, और 1's के दो लगातार जोड़े हैं। पहले लगातार जोड़े की दूरी 2 है, दूसरे जोड़े की दूरी 1 है। इन दो दूरियों में से सबसे बड़ी 2 है, जो उत्तर है।

हल करने के चरण

• K := N के बाइनरी प्रतिनिधित्व के बिट्स की सूची बनाएं
• Max := 0, C := 0, S := 0
• Flag := False
• i को 0 से K के आकार तक लूप करें:
  • यदि K[i] '1' है और C 0 है और Flag False है, तो:
    • C := i
    • Flag := True
  • अन्यथा जब K[i] '1' है और Flag True है, तो:
    • S := i
    • यदि Max < |S-C|, तो:
      • Max := |S-C|
    • C := S
• Max वापस करें

उदाहरण

class Solution:
    def binaryGap(self, N):
        B = bin(N).replace('0b','')
        K = str(B)
        K = list(K)
        Max = 0
        C = 0
        S = 0
        Flag = False
        for i in range(len(K)):
            if K[i] == '1' and C == 0 and Flag == False:
                C = i
                Flag = True
            elif K[i] == '1' and Flag:
                S = i
                if Max < abs(S - C):
                    Max = abs(S - C)
                C = S
        return Max

ob = Solution()
print(ob.binaryGap(22))

इनपुट

22

आउटपुट

2