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

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

इसलिए, यदि इनपुट nums = [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]

हल करने के चरण

check() फ़ंक्शन परिभाषित करें। यह lst लेगा
- mn := lst का न्यूनतम, mx := lst का अधिकतम
- min_pos := null, max_pos := null
- ret := 0
- प्रत्येक इंडेक्स i और मान num के लिए lst में, करें
  - यदि num, mn के समान है, तो min_pos := i
  - यदि num, mx के समान है, तो max_pos := i
  - यदि min_pos null है या max_pos null है, तो अगले इटरेशन पर जाएं
  - ret := ret + min_pos और (max_pos + 1) का न्यूनतम
- ret लौटाएं

मुख्य विधि से निम्नलिखित करें:

यदि nums का आकार <= 1, तो nums का आकार लौटाएं
ret := check(nums)
प्रत्येक rem_cand के लिए [nums का न्यूनतम, nums का अधिकतम] में, करें
- यदि rem_cand की घटना 1 है, तो
  - idx := nums में rem_cand का इंडेक्स
  - ret := ret और check(nums[0 से idx-1] + nums[idx+1 से अंत]) का अधिकतम
ret लौटाएं

उदाहरण

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]