पायथन में K नेगेशन्स के बाद ऐरे का योग अधिकतम करना

मान लीजिए हमारे पास इंटीजर्स का एक ऐरे A है, हमें निम्नलिखित तरीके से ऐरे को संशोधित करना है:

हम एक i चुन सकते हैं और A[i] को -A[i] से बदल सकते हैं, और हम इस प्रक्रिया को K बार दोहराएंगे। हमें इस तरह बदलने के बाद ऐरे का सबसे बड़ा संभव योग लौटाना है।

इसलिए, यदि ऐरे A = [4,2,3], और K = 1, तो आउटपुट 5 होगा। इसलिए इंडेक्स 1 चुनें, ऐरे [4,-2,3] बन जाएगा।

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

ऐरे A को सॉर्ट करें
i को 0 से A की लंबाई - 1 तक की रेंज में लिए
- यदि A[i] < 0, तो A[i] := -A[i], और k को 1 से घटाएं
- यदि k = 0, तो लूप से ब्रेक करें
यदि k सम है, तो
- sp := A[0]
- i := 1 से A की लंबाई - 1 तक लिए
  - यदि A[i] > 0, तो sp := sp और A[i] का न्यूनतम
- ऐरे के एलिमेंट्स का योग - (2*sp) लौटाएं
अन्यथा, ऐरे के एलिमेंट्स का योग लौटाएं

उदाहरण (पायथन)

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

class Solution(object):
    def largestSumAfterKNegations(self, A, K):
        A.sort()
        for i in range(len(A)):
            if A[i] < 0:
                A[i] = -A[i]
                K -= 1
            if K == 0:
                break
        if K % 2:
            smallest_positive = A[0]
            for i in range(1, len(A)):
                if A[i] >= 0:
                    smallest_positive = min(smallest_positive, A[i])
            return sum(A) - (2 * smallest_positive)
        else:
            return sum(A)

ob1 = Solution()
print(ob1.largestSumAfterKNegations([3, -1, 0, 2], 3))

इनपुट

[3,-1,0,2] 3