Fix the questions numbers issue and solution of new problems

Author: Garvit244

1000-1100q/1010.py

@@ -0,0 +1,51 @@
+'''
+In a list of songs, the i-th song has a duration of time[i] seconds. 
+
+Return the number of pairs of songs for which their total duration in seconds is divisible by 60.  Formally, we want the number of indices i < j with (time[i] + time[j]) % 60 == 0.
+
+ 
+
+Example 1:
+
+Input: [30,20,150,100,40]
+Output: 3
+Explanation: Three pairs have a total duration divisible by 60:
+(time[0] = 30, time[2] = 150): total duration 180
+(time[1] = 20, time[3] = 100): total duration 120
+(time[1] = 20, time[4] = 40): total duration 60
+Example 2:
+
+Input: [60,60,60]
+Output: 3
+Explanation: All three pairs have a total duration of 120, which is divisible by 60.
+
+Note:
+
+1 <= time.length <= 60000
+1 <= time[i] <= 500
+'''
+
+class Solution(object):
+    def numPairsDivisibleBy60(self, time):
+        """
+        :type time: List[int]
+        :rtype: int
+        """
+        count_arr = [0]*60
+        result = 0
+        for t in time:
+            remainder = t%60
+            complement = (60-remainder)%60
+            result += count_arr[complement]
+            count_arr[remainder] += 1
+        return result
+ 
+ '''
+	Explanation: 
+	Q1: why create array of size 60? 
+		it is similar to the map which store the count. Why only 60 because 60 modulo of number cannot be more than 60
+	Q2: why we need complement?
+		to check the pair if it exisit with given value or not example: if remainder is 20 then we need to check if we have any number with remainder 40 or not.
+	Q3: why 60 modulo complement?
+		for handle cause when remainder is zero 
+ '''

1000-1100q/1011.py

@@ -0,0 +1,94 @@
+'''
+A conveyor belt has packages that must be shipped from one port to another within D days.
+
+The i-th package on the conveyor belt has a weight of weights[i].  Each day, we load the ship with packages on the conveyor belt (in the order given by weights). We may not load more weight than the maximum weight capacity of the ship.
+
+Return the least weight capacity of the ship that will result in all the packages on the conveyor belt being shipped within D days.
+
+ 
+
+Example 1:
+
+Input: weights = [1,2,3,4,5,6,7,8,9,10], D = 5
+Output: 15
+Explanation: 
+A ship capacity of 15 is the minimum to ship all the packages in 5 days like this:
+1st day: 1, 2, 3, 4, 5
+2nd day: 6, 7
+3rd day: 8
+4th day: 9
+5th day: 10
+
+Note that the cargo must be shipped in the order given, so using a ship of capacity 14 and splitting the packages into parts like (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) is not allowed. 
+Example 2:
+
+Input: weights = [3,2,2,4,1,4], D = 3
+Output: 6
+Explanation: 
+A ship capacity of 6 is the minimum to ship all the packages in 3 days like this:
+1st day: 3, 2
+2nd day: 2, 4
+3rd day: 1, 4
+
+Note:
+
+1 <= D <= weights.length <= 50000
+1 <= weights[i] <= 500
+
+'''
+
+
+class Solution(object):
+    def shipWithinDays(self, weights, D):
+        """
+        :type weights: List[int]
+        :type D: int
+        :rtype: int
+        """
+        high, low = sum(weights)+1, max(weights)
+        
+        while(low < high):
+            mid = (high+low)/2
+            temp_left = mid
+            packet_at_left = D-1
+            for weight in weights:
+                if weight <= mid:
+                    if temp_left < weight:
+                        if packet_at_left == 0:
+                            low = mid+1
+                            break
+                        packet_at_left -= 1
+                        temp_left = mid-weight
+                    else:
+                        temp_left -= weight
+            else:
+                high = mid
+                
+        return low
+
+
+class Solution(object):
+    def shipWithinDays(self, weights, D):
+        """
+        :type weights: List[int]
+        :type D: int
+        :rtype: int
+        """
+        left, right = max(weights), sum(weights)
+        
+        while left < right:
+            curr_sum, groups, invalid = 0, 0, True
+            mid = left + ((right-left) >> 1)
+            for weight in weights:
+                if weight > mid:
+                    invalid = False
+                    break
+                if curr_sum + weight > mid:
+                    groups += 1
+                    curr_sum = 0
+                curr_sum += weight
+            if invalid and groups < D:
+                right = mid
+            else:
+                left = mid + 1
+        return left

1000-1100q/1013.py

@@ -1,51 +1,51 @@
 '''
-In a list of songs, the i-th song has a duration of time[i] seconds. 
+Given an array A of integers, return true if and only if we can partition the array into three non-empty parts with equal sums.
 
-Return the number of pairs of songs for which their total duration in seconds is divisible by 60.  Formally, we want the number of indices i < j with (time[i] + time[j]) % 60 == 0.
+Formally, we can partition the array if we can find indexes i+1 < j with (A[0] + A[1] + ... + A[i] == A[i+1] + A[i+2] + ... + A[j-1] == A[j] + A[j-1] + ... + A[A.length - 1])
 
  
 
 Example 1:
 
-Input: [30,20,150,100,40]
-Output: 3
-Explanation: Three pairs have a total duration divisible by 60:
-(time[0] = 30, time[2] = 150): total duration 180
-(time[1] = 20, time[3] = 100): total duration 120
-(time[1] = 20, time[4] = 40): total duration 60
+Input: [0,2,1,-6,6,-7,9,1,2,0,1]
+Output: true
+Explanation: 0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1
 Example 2:
 
-Input: [60,60,60]
-Output: 3
-Explanation: All three pairs have a total duration of 120, which is divisible by 60.
+Input: [0,2,1,-6,6,7,9,-1,2,0,1]
+Output: false
+Example 3:
+
+Input: [3,3,6,5,-2,2,5,1,-9,4]
+Output: true
+Explanation: 3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4
+ 
 
 Note:
 
-1 <= time.length <= 60000
-1 <= time[i] <= 500
+3 <= A.length <= 50000
+-10000 <= A[i] <= 10000
 '''
 
 class Solution(object):
-    def numPairsDivisibleBy60(self, time):
+    def canThreePartsEqualSum(self, A):
         """
-        :type time: List[int]
-        :rtype: int
+        :type A: List[int]
+        :rtype: bool
         """
-        count_arr = [0]*60
-        result = 0
-        for t in time:
-            remainder = t%60
-            complement = (60-remainder)%60
-            result += count_arr[complement]
-            count_arr[remainder] += 1
-        return result
- 
- '''
-	Explanation: 
-	Q1: why create array of size 60? 
-		it is similar to the map which store the count. Why only 60 because 60 modulo of number cannot be more than 60
-	Q2: why we need complement?
-		to check the pair if it exisit with given value or not example: if remainder is 20 then we need to check if we have any number with remainder 40 or not.
-	Q3: why 60 modulo complement?
-		for handle cause when remainder is zero 
- '''
+        total_sum = 0
+        for val in A:
+            total_sum += val
+            
+        if(total_sum%3 != 0):
+            return False
+        
+        curr_sum, groups = 0, 0
+        for val in A:
+            curr_sum += val
+            if curr_sum == total_sum/3:
+                curr_sum = 0
+                groups +=1
+        print groups
+        return groups == 3
+            

1000-1100q/1014.py

@@ -1,94 +1,33 @@
 '''
-A conveyor belt has packages that must be shipped from one port to another within D days.
+Given an array A of positive integers, A[i] represents the value of the i-th sightseeing spot, and two sightseeing spots i and j have distance j - i between them.
 
-The i-th package on the conveyor belt has a weight of weights[i].  Each day, we load the ship with packages on the conveyor belt (in the order given by weights). We may not load more weight than the maximum weight capacity of the ship.
+The score of a pair (i < j) of sightseeing spots is (A[i] + A[j] + i - j) : the sum of the values of the sightseeing spots, minus the distance between them.
 
-Return the least weight capacity of the ship that will result in all the packages on the conveyor belt being shipped within D days.
+Return the maximum score of a pair of sightseeing spots.
 
  
 
 Example 1:
 
-Input: weights = [1,2,3,4,5,6,7,8,9,10], D = 5
-Output: 15
-Explanation: 
-A ship capacity of 15 is the minimum to ship all the packages in 5 days like this:
-1st day: 1, 2, 3, 4, 5
-2nd day: 6, 7
-3rd day: 8
-4th day: 9
-5th day: 10
-
-Note that the cargo must be shipped in the order given, so using a ship of capacity 14 and splitting the packages into parts like (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) is not allowed. 
-Example 2:
-
-Input: weights = [3,2,2,4,1,4], D = 3
-Output: 6
-Explanation: 
-A ship capacity of 6 is the minimum to ship all the packages in 3 days like this:
-1st day: 3, 2
-2nd day: 2, 4
-3rd day: 1, 4
+Input: [8,1,5,2,6]
+Output: 11
+Explanation: i = 0, j = 2, A[i] + A[j] + i - j = 8 + 5 + 0 - 2 = 11
+ 
 
 Note:
 
-1 <= D <= weights.length <= 50000
-1 <= weights[i] <= 500
-
+2 <= A.length <= 50000
+1 <= A[i] <= 1000
 '''
-
-
-class Solution(object):
-    def shipWithinDays(self, weights, D):
-        """
-        :type weights: List[int]
-        :type D: int
-        :rtype: int
-        """
-        high, low = sum(weights)+1, max(weights)
-        
-        while(low < high):
-            mid = (high+low)/2
-            temp_left = mid
-            packet_at_left = D-1
-            for weight in weights:
-                if weight <= mid:
-                    if temp_left < weight:
-                        if packet_at_left == 0:
-                            low = mid+1
-                            break
-                        packet_at_left -= 1
-                        temp_left = mid-weight
-                    else:
-                        temp_left -= weight
-            else:
-                high = mid
-                
-        return low
-
-
 class Solution(object):
-    def shipWithinDays(self, weights, D):
+    def maxScoreSightseeingPair(self, A):
         """
-        :type weights: List[int]
-        :type D: int
+        :type A: List[int]
         :rtype: int
         """
-        left, right = max(weights), sum(weights)
-        
-        while left < right:
-            curr_sum, groups, invalid = 0, 0, True
-            mid = left + ((right-left) >> 1)
-            for weight in weights:
-                if weight > mid:
-                    invalid = False
-                    break
-                if curr_sum + weight > mid:
-                    groups += 1
-                    curr_sum = 0
-                curr_sum += weight
-            if invalid and groups < D:
-                right = mid
-            else:
-                left = mid + 1
-        return left
+        prev_best, result = 0, 0
+        for index in range(0, len(A)):
+            result = max(result, A[index]-index+prev_best)
+            prev_best = max(prev_best, A[index]+index)
+        return result
+ 

1000-1100q/1022.py renamed to 1000-1100q/1015.py

@@ -0,0 +1,45 @@
+'''
+Given a number N, return a string consisting of "0"s and "1"s that represents its value in base -2 (negative two).
+
+The returned string must have no leading zeroes, unless the string is "0".
+
+
+Example 1:
+
+Input: 2
+Output: "110"
+Explantion: (-2) ^ 2 + (-2) ^ 1 = 2
+Example 2:
+
+Input: 3
+Output: "111"
+Explantion: (-2) ^ 2 + (-2) ^ 1 + (-2) ^ 0 = 3
+
+Example 3:
+
+Input: 4
+Output: "100"
+Explantion: (-2) ^ 2 = 4
+ 
+
+Note:
+
+0 <= N <= 10^9
+'''
+
+class Solution(object):
+    def baseNeg2(self, N):
+        """
+        :type N: int
+        :rtype: str
+        """
+        if N == 0:
+            digits = ['0']
+        else:
+            digits = []
+            while N != 0:
+                N, remainder = divmod(N, -2)
+                if remainder < 0:
+                    N, remainder = N+1, remainder + 2
+                digits.append(str(remainder))
+        return ''.join(digits[::-1])