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|