Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> Python

पायथन में अच्छे उपसरणियों की संख्या गिनने का कार्यक्रम

मान लीजिए कि हमारे पास nums नामक एक सरणी है और दूसरा मान k है। हमें अच्छे उप-सरणियों की संख्या ज्ञात करनी है। एक सबअरे को अच्छा सबअरे कहा जाता है यदि उस पर k विषम संख्याएँ हों।

इसलिए, यदि इनपुट nums =[1,1,2,1,1], k =3 जैसा है, तो आउटपुट 2 होगा क्योंकि दो उप-सरणी हैं [1,1,2,1] और [1,2 ,1,1].

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

  • od_i :=एक नई सूची

  • मैं के लिए 0 से लेकर अंकों के आकार -1 तक की सीमा में हूं

    • अगर nums[i] mod 2 1 के समान है, तो

      • Od_i के अंत में i डालें

  • प्रारंभ:=0, अंत:=k-1

  • मैं :=0

  • गिनती :=0

  • जबकि अंत

    • अगर अंत विषम_आई -1 के आकार के समान है, तो

      • j :=अंकों का आकार - 1

    • अन्यथा,

      • जे:=विषम_i[अंत + 1] - 1

    • गिनती :=गिनती +(विषम_i[प्रारंभ] - i + 1) *(j - विषम_i[अंत] + 1)

    • मैं :=odd_i[शुरू] + 1

    • प्रारंभ:=प्रारंभ + 1

    • अंत:=अंत + 1

  • वापसी की संख्या

उदाहरण

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

def solve(nums, k):
   odd_i = []
   for i in range(len(nums)):
      if nums[i] % 2 == 1:
         odd_i.append(i)
   start = 0
   end = k - 1
   i = 0
   count = 0
   while end < len(odd_i):
      if end == len(odd_i) - 1:
         j = len(nums) - 1
      else:
         j = odd_i[end + 1] - 1
      count = count + (odd_i[start] - i + 1) * (j - odd_i[end] + 1)
      i = odd_i[start] + 1
      start = start + 1
      end = end + 1
   return count

nums = [1,1,2,1,1]
k = 3
print(solve(nums, k))

इनपुट

[1,2,3,4,5,6,7,8]

आउटपुट

2

  1. पायथन में एस में अलग-अलग सबस्ट्रिंग की संख्या गिनने का कार्यक्रम

    मान लीजिए कि हमारे पास एक स्ट्रिंग s है, हमें s के अलग-अलग गैर-रिक्त सबस्ट्रिंग की संख्या ज्ञात करनी है। इसलिए, यदि इनपुट s =abaa जैसा है, तो आउटपुट 8 होगा, क्योंकि सबस्ट्रिंग [a, b, ab, ba, aa, aba, बा, आबा]। इसे हल करने के लिए, हम इन चरणों का पालन करेंगे - कोशिश करें:=एक नया नक्शा n :=आकार का

  1. पायथन में प्रत्येक ब्रैकेट गहराई में वर्णों की संख्या गिनने का कार्यक्रम

    मान लीजिए कि हमारे पास एक स्ट्रिंग है जिसमें केवल तीन वर्ण X, (, और ) हैं। स्ट्रिंग में संतुलित कोष्ठक होते हैं और कुछ X के बीच में संभावित रूप से नेस्टेड कोष्ठक भी पुनरावर्ती रूप से हो सकते हैं। हमें s में कोष्ठक की प्रत्येक गहराई पर X की संख्या ज्ञात करनी है, जो सबसे कम गहराई से शुरू होकर सबसे गहर

  1. पायथन में n नोड्स के साथ BST की संख्या गिनने का कार्यक्रम

    मान लीजिए कि हमारे पास अलग-अलग नोड हैं। सभी अलग हैं। हमें यह पता लगाना है कि हम उन्हें कितने तरीकों से व्यवस्थित कर सकते हैं ताकि हम बाइनरी सर्च ट्री बना सकें। जैसा कि हम बाइनरी सर्च ट्री के बारे में जानते हैं, लेफ्ट सबट्री में हमेशा छोटे मान होते हैं और राइट सबट्री में बड़े मान होते हैं। इसे हल कर