Adding solution of 1029, 1030, 1031, 1032

Author: Garvit244

1000-1100q/1029.py

@@ -0,0 +1,41 @@
+'''
+There are 2N people a company is planning to interview. The cost of flying the i-th person to city A is costs[i][0], and the cost of flying the i-th person to city B is costs[i][1].
+
+Return the minimum cost to fly every person to a city such that exactly N people arrive in each city.
+
+ 
+
+Example 1:
+
+Input: [[10,20],[30,200],[400,50],[30,20]]
+Output: 110
+Explanation: 
+The first person goes to city A for a cost of 10.
+The second person goes to city A for a cost of 30.
+The third person goes to city B for a cost of 50.
+The fourth person goes to city B for a cost of 20.
+
+The total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.
+ 
+
+Note:
+
+1 <= costs.length <= 100
+It is guaranteed that costs.length is even.
+1 <= costs[i][0], costs[i][1] <= 1000
+'''
+
+class Solution(object):
+    def twoCitySchedCost(self, costs):
+        """
+        :type costs: List[List[int]]
+        :rtype: int
+        """
+        result = 0
+        costs = sorted(costs, key=lambda x : x[0] - x[1])
+        for index in range(len(costs)):
+            if index < len(costs)//2:
+                result += costs[index][0]
+            else:
+                result += costs[index][1]
+        return result

1000-1100q/1030.py

@@ -0,0 +1,58 @@
+'''
+We are given a matrix with R rows and C columns has cells with integer coordinates (r, c), where 0 <= r < R and 0 <= c < C.
+
+Additionally, we are given a cell in that matrix with coordinates (r0, c0).
+
+Return the coordinates of all cells in the matrix, sorted by their distance from (r0, c0) from smallest distance to largest distance.  Here, the distance between two cells (r1, c1) and (r2, c2) is the Manhattan distance, |r1 - r2| + |c1 - c2|.  (You may return the answer in any order that satisfies this condition.)
+
+ 
+
+Example 1:
+
+Input: R = 1, C = 2, r0 = 0, c0 = 0
+Output: [[0,0],[0,1]]
+Explanation: The distances from (r0, c0) to other cells are: [0,1]
+Example 2:
+
+Input: R = 2, C = 2, r0 = 0, c0 = 1
+Output: [[0,1],[0,0],[1,1],[1,0]]
+Explanation: The distances from (r0, c0) to other cells are: [0,1,1,2]
+The answer [[0,1],[1,1],[0,0],[1,0]] would also be accepted as correct.
+Example 3:
+
+Input: R = 2, C = 3, r0 = 1, c0 = 2
+Output: [[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
+Explanation: The distances from (r0, c0) to other cells are: [0,1,1,2,2,3]
+There are other answers that would also be accepted as correct, such as [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]].
+ 
+
+Note:
+
+1 <= R <= 100
+1 <= C <= 100
+0 <= r0 < R
+0 <= c0 < C
+'''
+
+class Solution(object):
+    def allCellsDistOrder(self, R, C, r0, c0):
+        """
+        :type R: int
+        :type C: int
+        :type r0: int
+        :type c0: int
+        :rtype: List[List[int]]
+        """
+        cells = [[x, y] for x in range(R) for y in range(C)]
+        distance = {}
+        for cell in cells:
+            diff = abs(cell[0]-r0) + abs(cell[1]-c0)
+            if diff in distance:
+                distance[diff].append(cell)
+            else:
+                distance[diff] = [cell]
+        result = []
+        for key in sorted(distance):
+            for value in distance[key]:
+                result.append(value)
+        return result

1000-1100q/1031.py

@@ -0,0 +1,55 @@
+'''
+Given an array A of non-negative integers, return the maximum sum of elements in two non-overlapping (contiguous) subarrays, which have lengths L and M.  (For clarification, the L-length subarray could occur before or after the M-length subarray.)
+
+Formally, return the largest V for which V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1]) and either:
+
+0 <= i < i + L - 1 < j < j + M - 1 < A.length, or
+0 <= j < j + M - 1 < i < i + L - 1 < A.length.
+ 
+
+Example 1:
+
+Input: A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2
+Output: 20
+Explanation: One choice of subarrays is [9] with length 1, and [6,5] with length 2.
+Example 2:
+
+Input: A = [3,8,1,3,2,1,8,9,0], L = 3, M = 2
+Output: 29
+Explanation: One choice of subarrays is [3,8,1] with length 3, and [8,9] with length 2.
+Example 3:
+
+Input: A = [2,1,5,6,0,9,5,0,3,8], L = 4, M = 3
+Output: 31
+Explanation: One choice of subarrays is [5,6,0,9] with length 4, and [3,8] with length 3.
+ 
+
+Note:
+
+L >= 1
+M >= 1
+L + M <= A.length <= 1000
+0 <= A[i] <= 1000
+'''
+
+class Solution(object):
+    def maxSumTwoNoOverlap(self, A, L, M):
+        """
+        :type A: List[int]
+        :type L: int
+        :type M: int
+        :rtype: int
+        """
+        cumm_sum = [0]
+        for index in range(len(A)):
+            cumm_sum.append(cumm_sum[index]+A[index])
+        result = 0
+        
+        def valid(index_i, index_j):
+            return index_i+L <=len(A) and index_j+M <= len(A) and(index_j>=index_i+L or index_i>=index_j+M)
+    
+        for index_i in range(len(A)):
+            for index_j in range(len(A)):
+                if valid(index_i, index_j):
+                    result = max(result, cumm_sum[index_i+L]-cumm_sum[index_i] + cumm_sum[index_j+M]-cumm_sum[index_j])
+        return result

1000-1100q/1032.py

@@ -0,0 +1,76 @@
+'''
+Implement the StreamChecker class as follows:
+
+StreamChecker(words): Constructor, init the data structure with the given words.
+query(letter): returns true if and only if for some k >= 1, the last k characters queried (in order from oldest to newest, including this letter just queried) spell one of the words in the given list.
+ 
+
+Example:
+
+StreamChecker streamChecker = new StreamChecker(["cd","f","kl"]); // init the dictionary.
+streamChecker.query('a');          // return false
+streamChecker.query('b');          // return false
+streamChecker.query('c');          // return false
+streamChecker.query('d');          // return true, because 'cd' is in the wordlist
+streamChecker.query('e');          // return false
+streamChecker.query('f');          // return true, because 'f' is in the wordlist
+streamChecker.query('g');          // return false
+streamChecker.query('h');          // return false
+streamChecker.query('i');          // return false
+streamChecker.query('j');          // return false
+streamChecker.query('k');          // return false
+streamChecker.query('l');          // return true, because 'kl' is in the wordlist
+ 
+
+Note:
+
+1 <= words.length <= 2000
+1 <= words[i].length <= 2000
+Words will only consist of lowercase English letters.
+Queries will only consist of lowercase English letters.
+The number of queries is at most 40000.
+'''
+
+class Trie(object):
+    def __init__(self):
+        self.nodes = {}
+        self.word = False
+        
+class StreamChecker(object):
+
+    def __init__(self, words):
+        """
+        :type words: List[str]
+        """
+        self.trie_node = Trie()
+        for word in words:
+            ptr = self.trie_node
+            for char in reversed(word):
+                if char not in ptr.nodes:
+                    ptr.nodes[char] = Trie()
+                ptr = ptr.nodes[char]
+            ptr.word = True
+        self.stream = []
+        
+
+    def query(self, letter):
+        """
+        :type letter: str
+        :rtype: bool
+        """
+        self.stream.append(letter)
+        root = self.trie_node
+        for char in reversed(self.stream):
+            if char not in root.nodes:
+                return False
+            if root.nodes[char].word:
+                return True
+            root = root.nodes[char]
+            
+        return root.word
+            
+ 
+
+# Your StreamChecker object will be instantiated and called as such:
+# obj = StreamChecker(words)
+# param_1 = obj.query(letter)

README.md

@@ -7,6 +7,10 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 ##### [Problems 1000-1100](./1000-1100q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|1032|[Stream of Characters](https://leetcode.com/problems/stream-of-characters)|[Python](./1000-1100q/1032.py)|Hard|
+|1031|[Maximum Sum of Two Non-Overlapping Subarrays](https://leetcode.com/problems/maximum-sum-of-two-non-overlapping-subarrays)|[Python](./1000-1100q/1031.py)|Medium|
+|1030|[Matrix Cells in Distance Order](https://leetcode.com/problems/matrix-cells-in-distance-order)|[Python](./1000-1100/1030.py)|Easy|
+|1029|[Two City Scheduling](https://leetcode.com/problems/two-city-scheduling)|[Python](./1000-1100q/1029.py)|Easy|
 |1028|[Recover a Tree From Preorder Traversal](https://leetcode.com/problems/recover-a-tree-from-preorder-traversal)|[Python](./1000-1100q/1028.py)|Hard|
 |1027|[Longest Arithmetic Sequence](https://leetcode.com/problems/longest-arithmetic-sequence)|[Python](./1000-1100q/1027.py)|Medium|
 |1026|[Maximum Difference Between Node and Ancestor](https://leetcode.com/problems/maximum-difference-between-node-and-ancestor)|[Python](./1000-1100q/1026.py)|Medium|