पहली और आखिरी तरफ से जोड़े बनाने के लिए आवश्यक संचालन की संख्या खोजने का कार्यक्रम पायथन में समान योग के साथ है

मान लीजिए हमारे पास संख्याओं की एक सूची है जिसे अंक कहा जाता है। इस सूची की लंबाई सम है। अब एक ऑपरेशन पर विचार करें जहां हम अंकों में किसी भी संख्या का चयन करते हैं और इसे श्रेणी [1 और अधिकतम संख्या] में मान के साथ अपडेट करते हैं। हमें ऐसे ऑपरेशनों की न्यूनतम संख्या ज्ञात करनी होगी, जो प्रत्येक i के लिए, nums[i] + nums[n-1-i] समान संख्या के बराबर हों।

इसलिए, यदि इनपुट nums =[8,6,2,5,9,2] की तरह है, तो आउटपुट 2 होगा, क्योंकि अगर हम पहले 2 को nums[2] से 5, और 9 nums पर बदलते हैं [4] ] से 4, तब तत्व [8,6,5,5,4,2] होंगे, फिर अंक [i] + अंक [n-1-i] प्रत्येक i के लिए होगा (8+2) =( 6+4) =(5+5) =10.

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

• N :=अंकों का आकार
• mx :=अधिकतम अंक
• घटनाक्रम:=एक नई सूची
• आईडीएक्स:=0
• जबकि idx <एन / 2 की मंजिल, करते हैं
  • a :=nums[idx]
  • b :=nums[N - idx - 1]
  • इवेंट के अंत में एक जोड़ी (न्यूनतम (a + 1), (b + 1), 1) डालें
  • इवेंट के अंत में एक जोड़ी (a + b, 1) डालें
  • इवेंट के अंत में एक जोड़ी (a + b + 1, -1) डालें
  • इवेंट के अंत में एक जोड़ी (अधिकतम (a + mx) और (b + mx + 1), -1) डालें
  • idx :=idx + 1
• सूची ईवेंट क्रमबद्ध करें
• वर्तमान:=0
• mx_same :=0
• इवेंट में प्रत्येक जोड़ी (ईवेंट, डेल्टा) के लिए, करें
  • वर्तमान:=वर्तमान + डेल्टा
  • mx_same :=अधिकतम करंट और mx_same
• वापसी एन - mx_same

उदाहरण

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

def solve(nums):
   N = len(nums)
   mx = max(nums)
   events = []

   idx = 0
   while idx < N // 2:
      a = nums[idx]
      b = nums[N - idx - 1]

      events.append((min(a + 1, b + 1), 1))
      events.append((a + b, 1))
      events.append((a + b + 1, -1))
      events.append((max(a + mx, b + mx) + 1, -1))

   idx += 1

   events.sort()
   current = 0
   mx_same = 0

   for event, delta in events:
      current += delta
      mx_same = max(current, mx_same)

   return N - mx_same

nums = [8,6,2,5,9,2]
print(solve(nums))

इनपुट

[6, 8, 5, 2, 3]

आउटपुट

2