एक सूची के प्रत्येक विभाजन का आकार खोजने के लिए कार्यक्रम जहां प्रत्येक अक्षर पायथन में अधिकतम एक टुकड़े पर दिखाई देता है

मान लीजिए कि हमारे पास एक लोअरकेस स्ट्रिंग s है, हम s को अधिक से अधिक टुकड़ों में विभाजित कर सकते हैं जैसे कि प्रत्येक अक्षर अधिक से अधिक एक टुकड़े में दिखाई दे और विभाजन के आकार को एक सूची के रूप में खोजें।

इसलिए, यदि इनपुट s ="momoplaykae" जैसा है, तो आउटपुट [4, 1, 1, 4, 1] होगा, क्योंकि स्ट्रिंग ["मोमो", "पी", "एल", " अयका", "ई"]।

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

• गिनती :=एक नक्शा जिसमें s और उनके बारंबारता में वर्ण होते हैं

• बाहर:=एक नई सूची, stk:=एक खाली स्टैक

• लंबाई :=0

• एस में प्रत्येक चार के लिए, करें

  • गिनती [चार]:=गिनती [चार] - 1

  • लंबाई :=लंबाई + 1

  • जबकि गिनती [चार] 0 के समान नहीं है या stk खाली नहीं है, करें

    • अगर गिनती [चार] 0 के समान नहीं है, तो

      • stk में चार पुश करें

      • लूप से बाहर आएं

    • यदि stk खाली नहीं है और गिनती [stk का शीर्ष] 0 के समान है, तो

      • stk से पॉप करें

    • अन्यथा,

      • लूप से बाहर आएं

  • यदि stk खाली है और गिनती [char] 0 के समान है, तो

    • बाहर की लंबाई डालें

    • लंबाई :=0

• वापस लौटें

उदाहरण

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

from collections import Counter
class Solution:
   def solve(self, s):
      count = Counter(s)
      out = []
      stk = []
      length = 0
      for char in s:
         count[char] -= 1
         length += 1
         while count[char] != 0 or stk:
            if count[char] != 0:
               stk.append(char)
               break
            if stk and count[stk[-1]] == 0:
               stk.pop()
            else:
               break
            if not stk and count[char] == 0:
               out += [length]
               length = 0
         return out
ob = Solution()
s = "momoplaykae"
print(ob.solve(s))

इनपुट

"momoplaykae"

आउटपुट

[4, 1, 1, 4, 1]