Solution for 1021-1023

Author: Garvit244

1000-1100q/1021.py

@@ -0,0 +1,59 @@
+'''
+A valid parentheses string is either empty (""), "(" + A + ")", or A + B, where A and B are valid parentheses strings, and + represents string concatenation.  For example, "", "()", "(())()", and "(()(()))" are all valid parentheses strings.
+
+A valid parentheses string S is primitive if it is nonempty, and there does not exist a way to split it into S = A+B, with A and B nonempty valid parentheses strings.
+
+Given a valid parentheses string S, consider its primitive decomposition: S = P_1 + P_2 + ... + P_k, where P_i are primitive valid parentheses strings.
+
+Return S after removing the outermost parentheses of every primitive string in the primitive decomposition of S.
+
+ 
+
+Example 1:
+
+Input: "(()())(())"
+Output: "()()()"
+Explanation: 
+The input string is "(()())(())", with primitive decomposition "(()())" + "(())".
+After removing outer parentheses of each part, this is "()()" + "()" = "()()()".
+Example 2:
+
+Input: "(()())(())(()(()))"
+Output: "()()()()(())"
+Explanation: 
+The input string is "(()())(())(()(()))", with primitive decomposition "(()())" + "(())" + "(()(()))".
+After removing outer parentheses of each part, this is "()()" + "()" + "()(())" = "()()()()(())".
+Example 3:
+
+Input: "()()"
+Output: ""
+Explanation: 
+The input string is "()()", with primitive decomposition "()" + "()".
+After removing outer parentheses of each part, this is "" + "" = "".
+ 
+
+Note:
+
+S.length <= 10000
+S[i] is "(" or ")"
+S is a valid parentheses string
+'''
+
+class Solution(object):
+    def removeOuterParentheses(self, S):
+        """
+        :type S: str
+        :rtype: str
+        """
+        temp, result = "", ""
+        start_bracket = 0
+        for char in S:
+            temp += char
+            if char == '(':
+                start_bracket += 1
+            else:
+                start_bracket -= 1
+            if start_bracket == 0:
+                result += temp[1:-1]
+                temp = ""
+        return result

1000-1100q/1022.py

@@ -0,0 +1,54 @@
+'''
+Given a binary tree, each node has value 0 or 1.  Each root-to-leaf path represents a binary number starting with the most significant bit.  For example, if the path is 0 -> 1 -> 1 -> 0 -> 1, then this could represent 01101 in binary, which is 13.
+
+For all leaves in the tree, consider the numbers represented by the path from the root to that leaf.
+
+Return the sum of these numbers.
+
+ 
+
+Example 1:
+
+
+
+Input: [1,0,1,0,1,0,1]
+Output: 22
+Explanation: (100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
+ 
+
+Note:
+
+The number of nodes in the tree is between 1 and 1000.
+node.val is 0 or 1.
+The answer will not exceed 2^31 - 1.
+'''
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def sumRootToLeaf(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        def traversal(root, paths, pathlen, allpaths):
+            if not root:
+                return 
+            if len(paths) > pathlen:
+                paths[pathlen] = root.val
+            else:
+                paths.append(root.val)
+                
+            pathlen +=1
+            if not root.left and not root.right:
+                allpaths.append(int(''.join(str(val) for val in paths[0:pathlen]), 2))
+            else:
+                traversal(root.left, paths, pathlen, allpaths)
+                traversal(root.right, paths, pathlen, allpaths)
+        paths = []
+        traversal(root, [], 0, paths)
+        return sum(paths)%1000000007

1000-1100q/1023.py

@@ -0,0 +1,76 @@
+'''
+A query word matches a given pattern if we can insert lowercase letters to the pattern word so that it equals the query. (We may insert each character at any position, and may insert 0 characters.)
+
+Given a list of queries, and a pattern, return an answer list of booleans, where answer[i] is true if and only if queries[i] matches the pattern.
+
+ 
+
+Example 1:
+
+Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FB"
+Output: [true,false,true,true,false]
+Explanation: 
+"FooBar" can be generated like this "F" + "oo" + "B" + "ar".
+"FootBall" can be generated like this "F" + "oot" + "B" + "all".
+"FrameBuffer" can be generated like this "F" + "rame" + "B" + "uffer".
+Example 2:
+
+Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBa"
+Output: [true,false,true,false,false]
+Explanation: 
+"FooBar" can be generated like this "Fo" + "o" + "Ba" + "r".
+"FootBall" can be generated like this "Fo" + "ot" + "Ba" + "ll".
+Example 3:
+
+Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBaT"
+Output: [false,true,false,false,false]
+Explanation: 
+"FooBarTest" can be generated like this "Fo" + "o" + "Ba" + "r" + "T" + "est".
+ 
+
+Note:
+
+1. 1 <= queries.length <= 100
+2. 1 <= queries[i].length <= 100
+3. 1 <= pattern.length <= 100
+4. All strings consists only of lower and upper case English letters.
+'''
+
+class Solution(object):
+    def camelMatch(self, queries, pattern):
+        """
+        :type queries: List[str]
+        :type pattern: str
+        :rtype: List[bool]
+        """
+        import re
+        result = []
+        patterns = re.findall('[A-Z][a-z]*', pattern)
+        
+        for query in queries:
+            splitter = re.findall('[A-Z][a-z]*', query)
+            flag = True
+            if len(patterns) == len(splitter):
+                for index in range(len(patterns)):
+                    # print patterns[index], splitter[index]
+                    p_i, s_i = 1, 1
+                    if patterns[index][0] == splitter[index][0]:
+                        while p_i < len(patterns[index]) and s_i < len(splitter[index]):
+                            if patterns[index][p_i] == splitter[index][s_i]:
+                                p_i += 1
+                                s_i += 1
+                            else:
+                                s_i += 1
+                        if p_i != len(patterns[index]):
+                            flag = False
+                            break
+                    else:
+                        flag = False
+                        break
+                if flag:
+                    result.append(True)
+                else:
+                    result.append(False)
+            else:
+                result.append(False)
+        return result

README.md

@@ -7,6 +7,9 @@ Python solution of problems from [LeetCode](https://leetcode.com/).
 ##### [Problems 1000-1100](./1000-1100q/)
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|1023|[Camelcase Matching](https://leetcode.com/problems/camelcase-matching)|[Python](./1000-1100q/1023.py)|Medium|
+|1022|[Sum of Root To Leaf Binary Numbers](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers)|[Python](./1000-1100q/1022.py)|Easy|
+|1021|[Remove Outermost Parentheses](https://leetcode.com/problems/remove-outermost-parentheses)|[Python](./1000-1100q/1021.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|