Adding colution of 2005 and 1006

Author: Garvit244

1000-1100q/1005.py

@@ -0,0 +1,49 @@
+'''
+Given an array A of integers, we must modify the array in the following way: we choose an i and replace A[i] with -A[i], and we repeat this process K times in total.  (We may choose the same index i multiple times.)
+
+Return the largest possible sum of the array after modifying it in this way.
+
+ 
+
+Example 1:
+
+Input: A = [4,2,3], K = 1
+Output: 5
+Explanation: Choose indices (1,) and A becomes [4,-2,3].
+Example 2:
+
+Input: A = [3,-1,0,2], K = 3
+Output: 6
+Explanation: Choose indices (1, 2, 2) and A becomes [3,1,0,2].
+Example 3:
+
+Input: A = [2,-3,-1,5,-4], K = 2
+Output: 13
+Explanation: Choose indices (1, 4) and A becomes [2,3,-1,5,4].
+ 
+
+Note:
+
+1 <= A.length <= 10000
+1 <= K <= 10000
+-100 <= A[i] <= 100
+'''
+
+class Solution(object):
+    def largestSumAfterKNegations(self, A, K):
+        """
+        :type A: List[int]
+        :type K: int
+        :rtype: int
+        """
+        A.sort()
+        index = 0
+        while K > 0:
+            if A[index] < 0:
+                A[index] *= -1
+                if A[index+1] < A[index] and index < len(A)-1:
+                    index += 1
+            else:
+                A[index] *= -1
+            K -= 1
+        return sum(A)

1000-1100q/1006.py

@@ -0,0 +1,38 @@
+'''
+Normally, the factorial of a positive integer n is the product of all positive integers less than or equal to n.  For example, factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1.
+
+We instead make a clumsy factorial: using the integers in decreasing order, we swap out the multiply operations for a fixed rotation of operations: multiply (*), divide (/), add (+) and subtract (-) in this order.
+
+For example, clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1.  However, these operations are still applied using the usual order of operations of arithmetic: we do all multiplication and division steps before any addition or subtraction steps, and multiplication and division steps are processed left to right.
+
+Additionally, the division that we use is floor division such that 10 * 9 / 8 equals 11.  This guarantees the result is an integer.
+
+Implement the clumsy function as defined above: given an integer N, it returns the clumsy factorial of N.
+
+ 
+
+Example 1:
+
+Input: 4
+Output: 7
+Explanation: 7 = 4 * 3 / 2 + 1
+Example 2:
+
+Input: 10
+Output: 12
+Explanation: 12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1
+ 
+
+Note:
+
+1 <= N <= 10000
+-2^31 <= answer <= 2^31 - 1  (The answer is guaranteed to fit within a 32-bit integer.)
+'''
+
+class Solution(object):
+    def clumsy(self, N):
+        """
+        :type N: int
+        :rtype: int
+        """
+        return [0, 1, 2, 6, 7][N] if N < 5 else N + [1, 2, 2, - 1][N % 4]

README.md

@@ -27,6 +27,8 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 |1009|[Complement of Base 10 Integer](https://leetcode.com/problems/complement-of-base-10-integer/) | [Python](./1000-1100q/1009.py)|Easy|
 |1008|[Construct Binary Search Tree from Preorder Traversal](https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal)|[Python](./1000-1100q/1008.py)|Medium|
 |1007|[Minimum Domino Rotations For Equal Row](https://leetcode.com/problems/minimum-domino-rotations-for-equal-row)|[Python](./1000-1100q/1007.py)|Medium|
+|1006|[Clumsy Factorial](https://leetcode.com/problems/clumsy-factorial)|[Python](./1000-1100q/1006.py)|Medium|
+|1005|[Maximize Sum Of Array After K Negations](https://leetcode.com/problems/maximize-sum-of-array-after-k-negations)|[Python](./1000-1100q/1005.py)|Easy|
 |1004|[Max Consecutive Ones III](https://leetcode.com/problems/max-consecutive-ones-iii)|[Python](./1000-1100q/1004.py)|Medium|
 |1003|[Check If Word Is Valid After Substitutions](https://leetcode.com/problems/check-if-word-is-valid-after-substitutions)|[Python](./1000-1100q/1003.py)|Medium|
 |1002|[Find Common Characters](https://leetcode.com/problems/find-common-characters)|[Python](./1000-1100q/1002.py)|Easy|