पायथन में सूची को गैर-बढ़ती सूची में बदलने के लिए आवश्यक संचालन की संख्या खोजने के लिए कार्यक्रम

मान लीजिए हमारे पास संख्याओं की एक सूची है जिसे अंक कहा जाता है। अब हम एक संक्रिया पर विचार करते हैं जिसमें हम दो क्रमागत मान लेते हैं और उनका योग लेकर एक मान में मिला देते हैं। हमें आवश्यक संचालनों की न्यूनतम संख्या ज्ञात करनी होगी ताकि सूची गैर-बढ़ती हो।

इसलिए, यदि इनपुट संख्या =[2, 6, 4, 10, 2] की तरह है, तो आउटपुट 2 होगा, क्योंकि हम [2, 6] को [8, 4, 10, 2] प्राप्त करने के लिए मर्ज कर सकते हैं और फिर [12, 10, 2] प्राप्त करने के लिए [8, 4] को मिलाएं।

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

• अगर अंक खाली हैं, तो

  • वापसी 0

• अंकों के अंत में −inf डालें

• N :=अंकों का आकार

• dp:=आकार N की सूची और 0 से भरें

• arr :=आकार N की सूची और 0 से भरें

• p :=गिरफ्तारी का आकार

• arr[p−1] :=nums[N−1]

• arr[p−2] :=nums[N−2]

• एन -3 से 0 की श्रेणी में i के लिए, 1 से घटाएं, करें

  • जे:=मैं

  • एक्स:=अंक [जे]

  • जबकि j

    • जे:=जे + 1

    • एक्स:=एक्स + अंक [जे]

  • dp[i] :=j - i + dp[j + 1]

  • गिरफ्तार [i] :=x

• वापसी डीपी [0]

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

उदाहरण

class Solution:
   def solve(self, nums):
      if not nums:
         return 0
      nums.append(float("−inf"))
      N = len(nums)
      dp = [0] * N
      arr = [0] * N
      arr[−1] = nums[−1]
      arr[−2] = nums[−2]
      for i in range(N − 3, −1, −1):
         j = i
         x = nums[j]
         while j < N − 1 and x < arr[j + 1]:
            j += 1
            x += nums[j]
         dp[i] = j − i + dp[j + 1]
         arr[i] = x
      return dp[0]
ob = Solution()
nums = [2, 6, 4, 10, 2]
print(ob.solve(nums))

इनपुट

[2, 6, 4, 10, 2]

आउटपुट

2