पायथन में संख्याओं के बीच ऑपरेटरों को सम्मिलित करके अधिकतम मूल्य खोजने का कार्यक्रम

मान लीजिए कि हमारे पास nums नामक संख्याओं की एक सूची है, हमें दिए गए नंबरों के बीच +, -, और * जैसे किसी भी बाइनरी ऑपरेटर को जोड़कर उत्पन्न किया जा सकने वाला अधिकतम मान ज्ञात करना होगा। जैसा कि कोई भी मान्य कोष्ठक सम्मिलित करता है।

इसलिए, यदि इनपुट nums =[−6, −4, −10] जैसा है, तो आउटपुट 100 होगा, क्योंकि हम इस तरह का व्यंजक बना सकते हैं:((−6) + (−4)) * -10।

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

• ओपीएस :=ऑपरेटरों की एक सूची [+, -, *]

• N:=A का आकार

• यदि A में सभी अवयव 0 हैं, तो

  • वापसी 0

• एक फ़ंक्शन को परिभाषित करें dp() । यह मैं, जम्मू ले जाएगा

• अगर मैं j के समान हूं, तो

  • एक जोड़ी लौटाएं (ए[i], ए[i])

• निम्न :=inf, उच्च :=−inf

• k के लिए i से j − 1 की श्रेणी में, करें

  • dp(i, k) में प्रत्येक बाएँ के लिए, करें

    • dp(k + 1, j) में प्रत्येक अधिकार के लिए करें

      • ओपीएस में प्रत्येक ऑपरेटर के लिए, करें

        • रेस :=लेफ्ट सेशन राइट

        • अगर रेस <कम है, तो

          • कम :=रेस

        • यदि रेस> उच्च है, तो

          • उच्च:=रेस

• वापसी जोड़ी (निम्न, उच्च)

• मुख्य विधि से निम्न कार्य करें -

• उत्तर :=डीपी(0, एन -1)

• उत्तर का दूसरा मान लौटाएं

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

उदाहरण

import operator
class Solution:
   def solve(self, A):
      OPS = [operator.add, operator.sub, operator.mul]
      N = len(A)
      if not any(A):
         return 0
      def dp(i, j):
         if i == j:
            return [A[i], A[i]]
         low = float("inf")
         high = float("−inf")
         for k in range(i, j):
            for left in dp(i, k):
               for right in dp(k + 1, j):
                  for op in OPS:
                     res = op(left, right)
                     if res < low:
                        low = res
                     if res > high:
                        high = res
         return [low, high]
      return dp(0, N − 1)[1]
ob = Solution()
nums = [−6, −4, −10]
print(ob.solve(nums))

इनपुट

[−6, −4, −10]

आउटपुट

100