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])

1000-1100q/1023.py renamed to 1000-1100q/1016.py

@@ -0,0 +1,39 @@
+'''
+Given an array A of 0s and 1s, consider N_i: the i-th subarray from A[0] to A[i] interpreted as a binary number (from most-significant-bit to least-significant-bit.)
+
+Return a list of booleans answer, where answer[i] is true if and only if N_i is divisible by 5.
+
+Example 1:
+
+Input: [0,1,1]
+Output: [true,false,false]
+Explanation: 
+The input numbers in binary are 0, 01, 011; which are 0, 1, and 3 in base-10.  Only the first number is divisible by 5, so answer[0] is true.
+Example 2:
+
+Input: [1,1,1]
+Output: [false,false,false]
+
+Note:
+
+1 <= A.length <= 30000
+A[i] is 0 or 1
+'''
+
+class Solution(object):
+    def prefixesDivBy5(self, A):
+        """
+        :type A: List[int]
+        :rtype: List[bool]
+        """
+        result = []
+        if not A:
+            return []
+        str_bin = ''
+        for val in A:
+            str_bin += str(val)
+            if(int(str_bin, 2)%5 == 0):
+                result.append(True)
+            else:
+                result.append(False)
+        return result

1000-1100q/1017.py

@@ -0,0 +1,62 @@
+'''
+We are given a linked list with head as the first node.  Let's number the nodes in the list: node_1, node_2, node_3, ... etc.
+
+Each node may have a next larger value: for node_i, next_larger(node_i) is the node_j.val such that j > i, node_j.val > node_i.val, and j is the smallest possible choice.  If such a j does not exist, the next larger value is 0.
+
+Return an array of integers answer, where answer[i] = next_larger(node_{i+1}).
+
+Note that in the example inputs (not outputs) below, arrays such as [2,1,5] represent the serialization of a linked list with a head node value of 2, second node value of 1, and third node value of 5.
+
+ 
+
+Example 1:
+
+Input: [2,1,5]
+Output: [5,5,0]
+Example 2:
+
+Input: [2,7,4,3,5]
+Output: [7,0,5,5,0]
+Example 3:
+
+Input: [1,7,5,1,9,2,5,1]
+Output: [7,9,9,9,0,5,0,0]
+ 
+
+Note:
+
+1 <= node.val <= 10^9 for each node in the linked list.
+The given list has length in the range [0, 10000].
+'''
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def nextLargerNodes(self, head):
+        """
+        :type head: ListNode
+        :rtype: List[int]
+        """
+        result = []
+        while head:
+            result.append(head.val)
+            head = head.next
+        
+        stack = [result[-1]]
+        ans = [0]
+        for val in range(len(result)-2, -1, -1):
+            if result[val] < stack[-1]:
+                ans.append(stack[-1])
+            else:
+                while stack and stack[-1] <= result[val]:
+                    stack.pop()
+                if stack:
+                    ans.append(stack[-1])
+                else:
+                    ans.append(0)
+            stack.append(result[val])
+        return ans[::-1]

1000-1100q/1018.py

@@ -7,12 +7,15 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 ##### [Problems 1000-1100](./1000-1100q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
-|1023|[Binary String With Substrings Representing 1 To N](https://leetcode.com/problems/binary-string-with-substrings-representing-1-to-n)|[Python](./1000-1100q/1023.py)|Medium|
-|1022|[Smallest Integer Divisible by K](https://leetcode.com/problems/smallest-integer-divisible-by-k)|[Python](./1000-1100q/1022.py)|Medium|
-|1021|[Best Sightseeing Pair](https://leetcode.com/problems/best-sightseeing-pair)|[Python](./1000-1100q/1021.py)|Medium|
-|1020|[Partition Array Into Three Parts With Equal Sum ](https://leetcode.com/problems/partition-array-into-three-parts-with-equal-sum) | [Python](./1000-1100q/1020.py)|Easy|
-|1014|[Capacity To Ship Packages Within D Days](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/) | [Python](./1000-1100q/1014.py) | Medium|
-|1013|[Pairs of Songs With Total Durations Divisible by 60](https://leetcode.com/problems/pairs-of-songs-with-total-durations-divisible-by-60/)|[Python](./1000-1100q/1013.py)|Easy|
+|1019|[Next Greater Node In Linked List](https://leetcode.com/problems/next-greater-node-in-linked-list)|[Python](./1000-1100q/1019.py)|Medium|
+|1018|[Binary Prefix Divisible By 5](https://leetcode.com/problems/binary-prefix-divisible-by-5)|[Python](./1000-1100q/1018.py)|Easy|
+|1017|[Convert to Base -2](https://leetcode.com/problems/convert-to-base-2)|[Python](./1000-1100q/1017.py)|Medium|
+|1016|[Binary String With Substrings Representing 1 To N](https://leetcode.com/problems/binary-string-with-substrings-representing-1-to-n)|[Python](./1000-1100q/1016.py)|Medium|
+|1015|[Smallest Integer Divisible by K](https://leetcode.com/problems/smallest-integer-divisible-by-k)|[Python](./1000-1100q/1015.py)|Medium|
+|1014|[Best Sightseeing Pair](https://leetcode.com/problems/best-sightseeing-pair)|[Python](./1000-1100q/1014.py)|Medium|
+|1013|[Partition Array Into Three Parts With Equal Sum ](https://leetcode.com/problems/partition-array-into-three-parts-with-equal-sum) | [Python](./1000-1100q/1013.py)|Easy|
+|1011|[Capacity To Ship Packages Within D Days](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/) | [Python](./1000-1100q/1011.py) | Medium|
+|1010|[Pairs of Songs With Total Durations Divisible by 60](https://leetcode.com/problems/pairs-of-songs-with-total-durations-divisible-by-60/)|[Python](./1000-1100q/1010.py)|Easy|
 |1012|[Complement of Base 10 Integer](https://leetcode.com/problems/complement-of-base-10-integer/) | [Python](./1000-1100q/1012.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|