पायथन में सरणी में विचलन को कम करने का कार्यक्रम

मान लीजिए कि हमारे पास एक सरणी संख्या है। हम सरणी के किसी भी तत्व पर कितनी भी बार दो प्रकार के संचालन कर सकते हैं

• सम तत्वों के लिए, इसे 2 से भाग दें

• विषम तत्वों के लिए इसे 2 से गुणा करें।

अब सरणी का विचलन सरणी में किन्हीं दो तत्वों के बीच अधिकतम अंतर है। हमें कुछ संख्या में संचालन करने के बाद सरणी के न्यूनतम विचलन का पता लगाना होगा। इसलिए, यदि इनपुट nums =[6,3,7,22,5] जैसा है, तो आउटपुट 5 होगा क्योंकि हम अपनी सरणी बना सकते हैं एक ऑपरेशन [6,6,7,22,5] और दूसरे ऑपरेशन में [6,6,7,22,10], और दूसरे ऑपरेशन में [6,6,7,11,10], अब विचलन 11 है- 6 =5.

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

• सूची संख्या क्रमित करें

• max_v :=अंकों का अधिकतम तत्व

• min_v :=अंकों का न्यूनतम तत्व

• संख्याओं को ढेर करना

• रेस :=max_v - min_v

• जबकि nums[0] विषम है, करें

  • v:=हीप कतार संख्या से पॉप तत्व

  • वी:=2 * वी

  • ढेर कतार संख्या में v डालें

  • min_v :=nums[0]

  • max_v :=अधिकतम v और max_v

  • रेस :=न्यूनतम रेस और (max_v - min_v)

• अंक :=n और ऋणात्मक क्रम में सभी संख्याओं की सूची

• ढेर कतार संख्या को ढेर करें

• जबकि nums[0] सम है, करें

  • v :=-(ढेर कतार संख्या से पॉप किया गया तत्व)

  • v :=भागफल (v/2)

  • -v ढेर कतार संख्या में डालें

  • max_v :=-nums[0]

  • min_v :=न्यूनतम min_v और v

  • रेस :=न्यूनतम रेस और (max_v - min_v)

• रिटर्न रेस

उदाहरण

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

import heapq
def solve(nums):
   nums.sort()
   max_v,min_v = nums[-1],nums[0]
   heapq.heapify(nums)
   res = max_v-min_v
   while nums[0]%2==1:
      v = heapq.heappop(nums)
      v = 2 * v
      heapq.heappush(nums, v)
      min_v = nums[0]
      max_v = max(v, max_v)
      res = min(res, max_v - min_v)

   nums = [-n for n in nums]
   heapq.heapify(nums)
   while nums[0]%2==0:
      v = -heapq.heappop(nums)
      v = v // 2
      heapq.heappush(nums, -v)
      max_v = -nums[0]
      min_v = min(min_v,v)
      res = min(res, max_v - min_v)

   return res

nums = [6,3,7,22,5]
print(solve(nums))

इनपुट

[6,3,7,22,5]

आउटपुट

5