def parse(cls, root: OrgNode, chap: str, sect: str) -> 'CardType':
key, page = cls.keytitle(root)
q, a = root.content
assert q.heading.strip() == 'Question', q.heading
assert a.heading.strip() == 'Solution', a.heading
return Exercise(q=Tree.from_str(q.content),
a=Tree.from_str(a.content),
chap=chap,
sect=sect,
key=key,
page=page)
def parse(cls, root: OrgNode, chap: str, sect: str,
part: str) -> 'CardType':
key, page = cls.keytitle(root)
term, def_ = root.content
assert term.heading.strip() == 'Term', term.heading
assert def_.heading.strip() == 'Def', def_.heading
return Def(term=Tree.from_str(term.content),
def_=Tree.from_str(def_.content),
chap=chap,
sect=sect,
part=part,
key=key,
page=page)
def parse(cls, root: OrgNode, chap: str, sect: str,
part: str) -> 'CardType':
key, page = cls.keytitle(root)
pp, pf = root.content
assert pp.heading.strip() == 'Proposition'
assert pf.heading.strip() == 'Proof'
return Prop(prop=Tree.from_str(pp.content),
proof=Tree.from_str(pf.content),
chap=chap,
sect=sect,
part=part,
key=key,
page=page)
def parse(root: OrgNode, chap: str, sect: str, part: str) -> 'CardType':
key = root.heading.replace('<', '').replace('>', '').strip()
return Example(x=Tree.from_str(root.content),
chap=chap,
sect=sect,
part=part,
key=key)
def test_func():
test_cases = [{
'input': {
'root': Tree([4, 2, 7, 1, 3]).root,
'val': 2
},
'output': Tree([2, 1, 3]).root
}, {
'input': {
'root': Tree([4, 2, 7, 1, 3]).root,
'val': 5
},
'output': Tree([]).root
}]
solution = Solution_1()
for test_case in test_cases:
assert solution.searchBST(**test_case['input']) == test_case['output']
def template_parser(template_file):
template = Tree()
with open(template_file, 'r') as lines:
for line in lines:
line = line.rstrip()
if not line.strip(): # ignore empty lines
continue
if line == '# Global config items beginning ignore':
context = 'glb_beg_ign'
template[context] = []
elif line == '# Global config items subset or exact ignore':
context = 'glb_sub_ign'
template[context] = []
elif line == '# Global config items beginning with':
context = 'glb_beg_with'
template[context] = []
elif line == '# Global config items':
context = 'glb_cfg'
template[context] = []
elif line == '# Grouped optional config items':
key = uuid.uuid4().hex
context = 'grp_opt'
template['grp_opt'][key] = []
elif line == '# Global hierarchical config items':
context = 'glb_hier'
hierarc_cfg = []
template[context] = []
if '#' in line:
continue
if context == 'glb_hier':
if line == '!':
template['glb_hier'].append(hierarc_cfg)
hierarc_cfg = []
else:
hierarc_cfg.append(line)
elif context == 'grp_opt':
template['grp_opt'][key].append(line)
else:
template[context].append(line)
return template
def inference(self, src_info):
src_ids, src_lengths = src_info
encoder_outputs, hidden = self.model.encoder(src_ids, src_lengths)
# print(self.device)
root = Tree(torch.LongTensor([self.trg_dictionary.SOS]).to(self.device))
mask = self.model.create_mask(src_ids)
with torch.no_grad():
alpha = torch.ones(self.trg_dictionary.size()).to(src_ids)
self.build_tree(root, hidden, encoder_outputs, mask, alpha, 0)
return Trie(node = root).get_path()
def test_func():
test_cases = [{
'input': {
'root': Tree([5, 3, 6, 2, 4, None, 7]).root,
'k': 9
},
'expected': True,
}, {
'input': {
'root': Tree([5, 3, 6, 2, 4, None, 7]).root,
'k': 28
},
'expected': False
}, {
'input': {
'root': Tree([2, 1, 3]).root,
'k': 4
},
'expected': True
}, {
'input': {
'root': Tree([2, 1, 3]).root,
'k': 1
},
'expected': False
}, {
'input': {
'root': Tree([2, 1, 3]).root,
'k': 3
},
'expected': True
}]
# solution = Solution_1()
# solution = Solution_2()
solution = Solution_3()
for test_case in test_cases:
assert solution.findTarget(**test_case['input']) == test_case['expected']
def build_tree(self, tree_node, hidden, encoder_outputs, mask, alpha, depth):
if depth > 20:
return
input = tree_node.value
if input == self.trg_dictionary.EOS:
return
output, hidden, _ = self.model.decoder(input, hidden, encoder_outputs, mask)
output = alpha * torch.sigmoid(output.squeeze(0))
for i in range(output.shape[0]):
if output[i] > 0.5:
child = Tree(torch.LongTensor([i]).to(self.device))
tree_node.children[i] = child
for k, child in tree_node.children.items():
self.build_tree(child, hidden, encoder_outputs, mask, alpha, depth+1)
def predict(self, trees):
trees = sorted(trees, key=lambda x: len(x.tokens))
output_trees = []
tree_idx = 0
for batch in self.batchify_X(trees):
batch_trees = trees[tree_idx:(tree_idx + batch[0].shape[0])]
batch_probs = self.model.predict_on_batch(batch)
if not isinstance(batch_probs, list):
batch_probs = [batch_probs]
batch_preds = self.targets_factory.inverse_transform(
batch_probs, batch_trees)
for row_idx, old_tree in enumerate(batch_trees):
row_probs = [p[row_idx] for p in batch_probs]
row_preds = [p[row_idx] for p in batch_preds]
emb = None
new_tokens = []
for token_idx, token in enumerate(old_tree.tokens):
new_token = deepcopy(token)
for field, pred in zip(self.params.targets, row_preds):
if field == 'sent':
emb = pred
else:
new_token.fields[field] = pred[token_idx]
new_tokens.append(new_token)
output_trees.append(
Tree(
tree_id=old_tree.id,
tokens=new_tokens,
words=old_tree.words,
comments=old_tree.comments,
probs=row_probs if self.params.save_probs else None,
emb=emb,
))
tree_idx += 1
output_trees = sorted(output_trees, key=lambda x: x.id)
return output_trees
def param_card_edit(par_expr, decays, model_name, output_dir, param_dir = '../Cards', truncate = 2):
# Resolve the symbolic expressions
parameters = Tree.convert_parameters(par_expr)
# Get parameter name
par_suffix = ''
for p in sorted(parameters.keys()):
# Truncate values to n decimals in file name
truncate_string = "{{0:.{}f}}".format(truncate)
value_name = truncate_string.format(parameters[p])
par_suffix += "{}{}_".format(p, value_name.replace(
'.', 'p')).replace('p0_', '_').replace(' ', '')
par_file_name = 'param_card_{}.dat'.format(par_suffix.rstrip('_'))
# Build new card
new_card = ''
with open("{}/param_card_{}.dat".format(param_dir, model_name)) as card:
for c in card:
newstring = c
comments = c.strip().split('#')
# Change particle properties
if len(comments) == 2:
name = comments[1].strip()
if name in parameters.keys():
leading_spaces = len(c) - len(c.lstrip(' '))
newstring = ' ' * leading_spaces + " ".join(
comments[0].split()[:-1]) + ' ' + str(parameters[name])\
+ ' # ' + comments[1] + '\n'
# Change decay properties
if decays != None:
if c.startswith("DECAY"):
pid = int(c.split()[1])
if pid in decays.keys():
dsplit = decays[pid].split()
br = dsplit[0]
products = " ".join(dsplit[1:])
nbody = len(dsplit[1:])
newstring += " {} {} {}\n".format(
br, nbody, products)
new_card += newstring
# Print new card to file
par_path = "{}/{}".format(output_dir, par_file_name)
print(new_card, file = open(par_path, 'w'))
return par_file_name
class Solution:
def binaryTreePaths(self, root):
"""
:type root: TreeNode
:rtype: List[str]
"""
res = []
if not root:
return []
if not root.left and not root.right:
res.append(str(root.val))
return res
left = self.binaryTreePaths(root.left)
for each in left:
res.append(str(root.val) + '->' + each)
right = self.binaryTreePaths(root.right)
for each in right:
res.append(str(root.val) + '->' + each)
return res
if __name__ == '__main__':
s = Solution()
root = Tree("[1,2,3,null,5]")
print(s.binaryTreePaths(root))
class Solution:
def minDepth(self, root):
"""
:type root: TreeNode
:rtype: int
"""
return self.getDepth(root)
def getDepth(self, root):
if root is None:
return 0
if root.right is None:
return self.getDepth(root.left) + 1
if root.left is None:
return self.getDepth(root.right) + 1
l_height = self.getDepth(root.left) + 1
r_height = self.getDepth(root.right) + 1
return min(l_height, r_height)
if __name__ == '__main__':
s = Solution()
root = Tree('[3,9,20,null,null,15,7]')
print(s.minDepth(root))
class Solution(object):
def lowestCommonAncestor(self, root, p, q):
pathp = []
pathq = []
self.path_finder(root, pathp, p)
self.path_finder(root, pathq, q)
while len(pathp) and len(pathq):
a = pathp.pop(0)
b = pathq.pop(0)
if a == b:
return a
return -1
def path_finder(self, node, path, m):
if not node:
return False
path.extend([node.val])
if node.val == m:
return True
if self.path_finder(node.left, path, m):
return True
if self.path_finder(node.right, path, m):
return True
path.pop()
return False
tree = Tree.creatTree([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4])
print(Solution().lowestCommonAncestor(tree, 5, 1))
class Solution(object):
def distanceK(self, root, target, K):
dfs = defaultdict(list)
def connect(parent, child):
if parent and child:
dfs[parent.val].append(child.val)
dfs[child.val].append(parent.val)
if child.left:
connect(child, child.left)
if child.right:
connect(child, child.right)
connect(None, root)
seemed = {target.val}
bfs = [target.val]
for _ in range(K):
bfs = [y for x in bfs for y in dfs[x] if y not in seemed]
seemed |= set(bfs)
return bfs
if __name__ == '__main__':
s = Solution()
root = Tree('[3,5,1,6,2,0,8,null,null,7,4]')
print(s.distanceK(root, TreeNode(5), 2))
:type t1: TreeNode
:type t2: TreeNode
:rtype: TreeNode
"""
return self._mergeTrees(t1, t2)
def _mergeTrees(self, t1, t2):
if not t1 and not t2:
return None
if not t1:
return t2
if not t2:
return t1
t1.val = (t1.val or 0) + (t2.val or 0)
t1.left = self._mergeTrees(t1.left, t2.left)
t1.right = self._mergeTrees(t1.right, t2.right)
return t1
if __name__ == '__main__':
s = Solution()
t1 = Tree('[1,3,2,5]')
t2 = Tree('[2,1,3,null,4,null,7]')
t = s.mergeTrees(t1, t2)
print(t.get_nodes())
def ios_xe_parser(configfile):
"""
This function parses banners, interface, vlan, global and hierarchical
config items into a Python data structure
"""
with open(configfile, 'r') as lines:
match = ReSearcher()
tree = Tree()
key_exceptions = ['ip vrf forwarding']
key_length = {1: ['hold-queue', 'standby', 'channel-group',
'description'],
2: ['switchport port-security', 'ip', 'spanning-tree',
'speed auto', 'srr-queue bandwidth']
}
list_items = ['switchport trunk allowed vlan', 'standby',
'ip helper-address', 'logging event']
intf_parser = InterfaceParser(list_items, key_exceptions, key_length)
context = ''
global_cfg = []
hierarc_cfg = [] # Individual hierarchical config part
hierarc_cfgs = [] # list with all individual hierarchical config parts
for previous_line, line in prev_cur_generator(lines):
if not line.strip(): # skip empty lines
continue
line = line.rstrip()
if previous_line is not None:
previous_line = previous_line.rstrip()
if match(r'^hostname (.*)', line):
hostname = format(match.group(1))
tree['hostname'] = hostname
elif match(r'^interface (.*)', line):
context = 'port'
portindex = format(match.group(1))
tree['port'][portindex] = {}
intf_parser.initialize_lists()
elif match(r'^vlan ([\d,-]+)', line):
context = 'vlan'
for vlan in splitrange(format(match.group(1))):
tree['vlan'][vlan] = {}
elif match(r'^banner (\w+) (\S)', line):
banner_type = format(match.group(1))
delimeter_char = format(match.group(2))
tree['banner'][banner_type]['delimeter_char'] = delimeter_char
tree['banner'][banner_type]['lines'] = []
context = 'banner'
elif context == 'port':
if match(r'^ no (.*)', line):
key = format(match.group(1))
value = format(match.group(0))
tree['port'][portindex][key] = value
# interface items are stored with helper class
elif match('^ .*', line):
tree = intf_parser.parse_line(tree, portindex, line)
elif match(r'!$', line):
context = ''
elif context == 'vlan':
if match(r'^ name (.*)', line):
tree['vlan'][vlan]['name'] = format(match.group(1))
elif match(r'!$', line):
context = ''
elif not line.startswith(' '):
global_cfg.append(line)
context = ''
# Both line and previous line are global items
elif line.lstrip() == line and context == '':
if previous_line is None:
pass
elif not previous_line.startswith('!'):
global_cfg.append(previous_line)
# Previous line was beginning of hierarchical item
elif line.lstrip() != line and context == '':
hierarc_cfg = []
hierarc_cfg.append(previous_line)
context = 'hierarc'
# Both current and previous line belongs to hierarchical item
elif line.lstrip() != line and context == 'hierarc':
hierarc_cfg.append(previous_line)
# Previous line was last hierarchical item
elif line == '!' or line.startswith('') and context == 'hierarc':
hierarc_cfg.append(previous_line)
hierarc_cfgs.append(hierarc_cfg)
context = ''
# Previous line was last hierarchical item and directly followed
# by start of another hierarchical item
elif line.lstrip() == line and context == 'hierarc':
hierarc_cfg.append(previous_line)
hierarc_cfgs.append(hierarc_cfg)
hierarc_cfg = []
elif context == 'banner' and not line.startswith(delimeter_char):
tree['banner'][banner_type]['lines'].append(line)
elif context == 'banner' and line.startswith(delimeter_char):
context = ''
tree['global_cfg'] = global_cfg
tree['hierarc_cfgs'] = hierarc_cfgs
return tree
def longestUnivaluePath(self, root):
"""
:type root: TreeNode
:rtype: int
"""
maxL = 0
def getMaxL(node, val):
nonlocal maxL
if not root:
return 0
leftMaxL = getMaxL(node.left, node.val)
rightMaxL = getMaxL(node.right, node.val)
maxL = max(maxL, leftMaxL + rightMaxL)
if (node.val == val):
return max(leftMaxL, rightMaxL) + 1
else:
return 0
if root:
getMaxL(root, root.val)
return maxL
if __name__ == '__main__':
s = Solution2()
root = Tree('[4, 4, 4, 4, 4, 4, 4]')
print(s.longestUnivaluePath(root))
:type R: int
:rtype: TreeNode
"""
if not node:
return
if node.val is not None and node.val < L:
node = self._trimBST(node.right, L, R)
elif node.val is not None and node.val > R:
node = self._trimBST(node.left, L, R)
if not node:
return
node.right = self._trimBST(node.right, L, R)
node.left = self.trimBST(node.left, L, R)
return node
if __name__ == '__main__':
s = Solution()
root = Tree([1, 0, 2])
print(root.get_nodes())
print(s.trimBST(root, 1, 2).get_nodes())
root = Tree([3, 0, 4, None, 2, None, None, 1])
print(root.get_nodes())
print(s.trimBST(root, 1, 3).get_nodes())
if not node.left and not node.right:
leaves.append(node.val)
return leaves
return leaves
if __name__ == '__main__':
s = Solution()
# r1 = Tree('[3,5,1,6,2,9,8,null,null,7,4]')
# r2 = Tree('[3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]')
# print(s.leafSimilar(r1, r2))
#
# r3 = Tree('[1]')
# r4 = Tree('[2]')
# print(r3.get_nodes())
# print(r4.get_nodes())
#
# print(s.leafSimilar(r3, r4))
r5 = Tree('[1,2,3]')
r6 = Tree('[1,3,2]')
print(r5.get_nodes())
print(r6.get_nodes())
print(s._tree_leaves(r5))
print(s._tree_leaves(r6))
print(s.leafSimilar(r5, r6))
left_val, left_tilt = self._findTilt(node.left)
right_val, right_tilt = self._findTilt(node.right)
return node.val + left_val + right_val, abs(
left_val - right_val) + left_tilt + right_tilt
class Solution2(object):
def findTilt(self, root):
"""
:type root: TreeNode
:rtype: int
"""
def find(root):
if not root:
return 0, 0
ldif, lsm = find(root.left)
rdif, rsm = find(root.right)
return abs(lsm - rsm) + ldif + rdif, lsm + rsm + root.val
d, s = find(root)
return d
if __name__ == '__main__':
s = Solution()
root = Tree([1, 2, 3])
print((s.findTilt(root)))
