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

नेस्टेड लिस्ट वेट सम II पायथन में


पूर्णांकों की एक नेस्टेड सूची दी गई है, सूची में सभी पूर्णांकों का योग उनकी गहराई से भारित करके लौटाएं। प्रत्येक तत्व या तो एक पूर्णांक है, या एक सूची -- जिसके तत्व भी पूर्णांक या अन्य सूचियां हो सकते हैं। पिछले प्रश्न से अलग जहां वजन रूट से लीफ की ओर बढ़ता है, अब वजन नीचे से ऊपर परिभाषित है। यानी, लीफ लेवल के पूर्णांकों का वजन 1 होता है, और रूट लेवल के पूर्णांकों का सबसे बड़ा वजन होता है।

उदाहरण के लिए, यदि इनपुट [[1,1],2,[1,1]] है, तो आउटपुट 8 होगा, क्योंकि चार 1 गहराई 1 पर हैं, एक 2 गहराई 2 पर है।

समाधान दृष्टिकोण

इसे हल करने के लिए हम निम्नलिखित चरणों का पालन करेंगे:

  • एक फंक्शन depthSumInverse() परिभाषित करें जो nestedList लेता है
  • flats := एक नई सूची (तत्व, गहराई) जोड़े स्टोर करने के लिए
  • maxd := 0 (अधिकतम गहराई)
  • एक फंक्शन flatten() परिभाषित करें जो nlst, dist लेता है:
    • dist := dist + 1
    • maxd := max(maxd, dist)
    • प्रत्येक node के लिए nlst में:
      • यदि node पूर्णांक है:
        • (node, dist) को flats में जोड़ें
      • अन्यथा:
        • flatten(node, dist) कॉल करें
    • flatten(nestedList, 0) कॉल करें
    • summ := 0
    • प्रत्येक (v, d) के लिए flats में:
      • summ := summ + v * (maxd + 1 - d)
    • summ लौटाएं

    उदाहरण कोड

    class Solution(object):
        def depthSumInverse(self, nestedList):
            flats = []
            self.maxd = 0
            def flatten(nlst, dist):
                if isinstance(nlst, list):
                    nlst = nlst
                dist += 1
                self.maxd = max(self.maxd, dist)
                for node in nlst:
                    if isinstance(node, int):
                        flats.append((node, dist))
                    else:
                        flatten(node, dist)
            flatten(nestedList, 0)
            summ = 0
            for v, d in flats:
                summ += v * (self.maxd + 1 - d)
            return summ
    
    ob = Solution()
    print(ob.depthSumInverse([[1,1],2,[1,1]]))

    इनपुट

    [[1,1],2,[1,1]]

    आउटपुट

    8

  1. Python में बाइनरी ट्री अधिकतम पथ योग Python में बाइनरी ट्री अधिकतम पथ योग

    मान लीजिए हमारे पास एक गैर-खाली बाइनरी ट्री है। हमें पथ योग ढूंढना है। तो यहां, एक पथ कुछ प्रारंभिक नोड से किसी भी नोड तक नोड्स का कोई अनुक्रम है जहां पैरेंट-चाइल्ड कनेक्शन मौजूद हैं। पथ में कम से कम एक नोड होना चाहिए और रूट नोड से गुजरने की आवश्यकता नहीं है। इसलिए यदि इनपुट ट्री है −यहां आउटपुट 32

  1. पायथन प्रोग्राम: लिस्ट का संचयी योग ज्ञात करें पायथन प्रोग्राम: लिस्ट का संचयी योग ज्ञात करें

    इस लेख में हम दी गई समस्या के समाधान के बारे में जानेंगे। समस्या कथन हमें एक लिस्ट दी गई है, हमें संचयी योग के साथ एक लिस्ट बनानी है। उदाहरण # संचयी योग def Cumulative(l): new = [] cumsum = 0 for element in l: cumsum += element new.append(cumsum) return new # ड्राइवर

  1. पायथन प्रोग्राम: लिस्ट में एलिमेंट्स का योग ढूंढें पायथन प्रोग्राम: लिस्ट में एलिमेंट्स का योग ढूंढें

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