पायथन में सेल फ्यूजन

मान लीजिए कि हमारे पास संख्याओं की एक सूची है जिसे सेल कहते हैं; यह सूची विभिन्न कोशिकाओं के आकार का प्रतिनिधित्व कर रही है। अब, प्रत्येक पुनरावृत्ति में, दो सबसे बड़े कक्ष a और b इन नियमों के अनुसार परस्पर क्रिया करते हैं:इसलिए, यदि a =b, तो वे दोनों मर जाते हैं। अन्यथा, दो कोशिकाएँ विलीन हो जाती हैं और उनका आकार ((a + b) / 3) का तल बन जाता है। हमें अंतिम सेल का आकार ज्ञात करना होगा या यदि कोई सेल शेष नहीं है तो -1 वापस करना होगा।

इसलिए, यदि इनपुट [20,40,40,30] जैसा है, तो आउटपुट 16 होगा, पहले पुनरावृत्ति में, 40 और 40 मर जाएंगे, फिर 20 और 30 ((20+30) / 3) के तल बन जाएंगे। =50/3 का तल =16

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

• सेल :=सेल सरणी के प्रत्येक मान को नकारात्मक में बदलें

• कोशिकाओं के साथ ढेर बनाएं

• जबकि सेल खाली नहीं हैं, −

  . करें

  • कोशिकाओं से दो तत्वों को हटाएं और उन्हें फिर से नकारात्मक में परिवर्तित करें, और उन्हें लगातार पहले और दूसरे के रूप में असाइन करें

• अगर पहला दूसरे के बराबर नहीं है, तो -

  • (पहले+सेकंड)/3) के तल का ऋणात्मक ढेर में डालें

• कोशिकाओं की ऋणात्मक वापसी[0] यदि कोशिकाओं में कुछ तत्व हैं अन्यथा - 1

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

उदाहरण

from heapq import heapify, heappop, heappush
class Solution:
   def solve(self, cells):
      cells=[-x for x in cells]
      heapify(cells)
      while len(cells)>1:
         first,second = -heappop(cells), -heappop(cells)
         if first!=second:
            heappush(cells, -((first+second)//3))
      return -cells[0] if cells else -1
ob = Solution()
cells = [20,40,40,30]
print(ob.solve(cells))

इनपुट

[20,40,40,30]

आउटपुट

16