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

पायथन का उपयोग करके दोगुने जोड़े की सरणी खोजने का कार्यक्रम

मान लीजिए कि हमारे पास संख्याओं की एक सरणी है जिसकी लंबाई सम है, हमें यह जांचना है कि क्या इसे इस तरह से पुन:व्यवस्थित करना संभव है कि nums[2*i + 1] =2*nums[2*i] प्रत्येक 0 <के लिए =मैं <अंकों का आकार/2.

इसलिए, अगर इनपुट nums =[4,-2,2,-4] जैसा है, तो आउटपुट ट्रू होगा।

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

  • cnt :=एक नक्शा जिसमें सभी तत्वों की संख्या और उनके आवृत्ति मान शामिल हैं

  • क्रमबद्ध सूची में प्रत्येक x के लिए cnt जो उनके निरपेक्ष मूल्यों के आधार पर क्रमबद्ध है, करें

    • अगर cnt[x]> cnt[2 * x], तो

      • झूठी वापसी

    • सीएनटी [2 * एक्स]:=सीएनटी [2 * एक्स] - सीएनटी [एक्स]

  • सही लौटें

उदाहरण

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

from collections import Counter
def solve(nums):
   cnt = Counter(nums)
   for x in sorted(cnt, key=abs):
      if cnt[x] > cnt[2 * x]:
         return False
      cnt[2 * x] -= cnt[x]
   return True

nums = [4,-2,2,-4]
print(solve(nums))

इनपुट

[6,0,8,2,1,5]

आउटपुट

True

  1. पायथन का उपयोग करके अच्छे लीफ नोड्स जोड़े की संख्या खोजने का कार्यक्रम

    मान लीजिए कि हमारे पास एक बाइनरी ट्री है। और दूसरा मान दूरी d. दो अलग-अलग लीफ नोड्स की एक जोड़ी को अच्छा कहा जाता है, जब इन दो नोड्स के बीच का सबसे छोटा रास्ता छोटा या दूरी d के समान होता है। तो, अगर इनपुट पसंद है और दूरी d =4, तो आउटपुट 2 होगा क्योंकि जोड़े (8,7) और (5,6) हैं क्योंकि उनकी पथ लं

  1. पायथन प्रोग्राम में सरणी का योग ज्ञात करें

    इस लेख में, हम नीचे दिए गए समस्या कथन के समाधान के बारे में जानेंगे। समस्या कथन - हमें एक सरणी दी गई है, जिसकी हमें सरणी के योग की गणना करने की आवश्यकता है। योग प्राप्त करने के लिए प्रत्येक अनुक्रमणिका में संपूर्ण सरणी और तत्व को पार करने के लिए पाशविक-बल दृष्टिकोण की चर्चा नीचे प्रत्येक अनुक्रमण

  1. सरणी का योग खोजने के लिए पायथन कार्यक्रम

    इस लेख में, हम दिए गए समस्या कथन को हल करने के लिए समाधान और दृष्टिकोण के बारे में जानेंगे। समस्या कथन एक इनपुट के रूप में एक सरणी को देखते हुए, हमें दिए गए सरणी के योग की गणना करने की आवश्यकता है। यहां हम ब्रूट-फोर्स अप्रोच का अनुसरण कर सकते हैं, यानी एक सूची को पार करना और प्रत्येक तत्व को एक खा