पायथन में केवल एक तत्व को हटाने के बाद अधिकतम और न्यूनतम वाले उप-सूचियों की संख्या खोजने का कार्यक्रम

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

इसलिए, यदि इनपुट अंकों की तरह है =[3, 2, 6, 2, 4, 10], तो आउटपुट 8 होगा, जैसे कि हम 10 को हटा दें तो हमें [3, 2, 6, 2, 4] मिलेगा और आठ उपन्यासकार हैं जहां इसमें अधिकतम और न्यूनतम दोनों शामिल हैं -

[2, 6]
[6, 2]
[2, 6, 2]
[3, 2, 6]
[6, 2, 4]
[2, 6, 2, 4]
[3, 2, 6, 2]
[3, 2, 6, 2, 4]।

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

फ़ंक्शन चेक() को परिभाषित करें। इसमें पहली बार लगेगा
एमएन:=न्यूनतम एलएसटी, एमएक्स:=अधिकतम एलएसटी
min_pos:=शून्य, max_pos:=शून्य
रिट:=0
प्रत्येक अनुक्रमणिका के लिए i और मान संख्या lst में, करें
- यदि संख्या mn के समान है, तो
  - min_pos:=मैं
- अगर संख्या एमएक्स के समान है, तो
  - max_pos:=मैं
- अगर min_pos शून्य है या max_pos शून्य है, तो
  - अगले पुनरावृत्ति के लिए जाएं
- ret :=ret + न्यूनतम min_pos और (max_pos + 1)
वापसी रिट
मुख्य विधि से निम्न कार्य करें -
यदि अंकों का आकार <=1, तो
- अंकों का वापसी आकार
रिट:=चेक (अंक)
प्रत्येक rem_cand के लिए [न्यूनतम अंक , अधिकतम अंक ], करें
- अगर rem_cand की घटना 1 है, तो
  - idx :=अंकों में rem_cand की अनुक्रमणिका
  - रिट:=अधिकतम रिट और चेक (अंक [इंडेक्स 0 से आईडीएक्स -1 तक] समवर्ती अंक [इंडेक्स आईडीएक्स + 1 से अंत तक]
वापसी रिट

उदाहरण

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

class Solution:
   def solve(self, nums):
      if len(nums) <= 1:
         return len(nums)
      def check(lst):
         mn, mx = min(lst), max(lst)
         min_pos, max_pos = None, None
         ret = 0
         for i, num in enumerate(lst):
            if num == mn:
               min_pos = i
            if num == mx:
               max_pos = i
            if min_pos is None or max_pos is None:
               continue
            ret += min(min_pos, max_pos) + 1
         return ret
      ret = check(nums)
      for rem_cand in [min(nums), max(nums)]:
         if nums.count(rem_cand) == 1:
            idx = nums.index(rem_cand)
            ret = max(ret, check(nums[:idx] + nums[idx + 1 :]))
      return ret
ob = Solution()
nums = [3, 2, 6, 2, 4, 10]
print(ob.solve(nums))

इनपुट

[3, 2, 6, 2, 4, 10]