def iteritems(self, key_type=None, value_type=None): """Iterate for every key / value in an abstract database object.""" if not tc.adb_iterinit(self.db): self._raise('Error initializing the iterator of an abstract ' \ 'database object.') while True: c_key, c_key_len = tc.adb_iternext(self.db) if not c_key: break (c_value, c_value_len) = tc.adb_get(self.db, c_key, c_key_len) key = util.deserialize(c_key, c_key_len, key_type) value = util.deserialize(c_value, c_value_len, value_type) yield (key, value)
def _getitem(self, key, raw_key=False, value_type=None): """Retrieve a Python object in a B+ tree database object.""" (c_key, c_key_len) = util.serialize(key, raw_key) (c_value, c_value_len) = tc.bdb_get(self.db, c_key, c_key_len) if not c_value: raise KeyError(key) return util.deserialize(c_value, c_value_len, value_type)
def key(self, as_type=None): """Get the key of the record where the cursor object is.""" c_key, c_key_len = tc.bdb_curkey(self.cur) if not c_key: raise tc.TCException(tc.bdb_errmsg(tc.bdb_ecode(self.db))) key = util.deserialize(c_key, c_key_len, as_type) return key
def value(self, as_type=None): """Get the value of the record where the cursor object is.""" c_value, c_value_len = tc.bdb_curval(self.cur) if not c_value: raise tc.TCException(tc.bdb_errmsg(tc.bdb_ecode(self.db))) value = util.deserialize(c_value, c_value_len, as_type) return value
def _getitem(self, key, raw_key=False, value_type=None): """Retrieve a Python object in a hash database object.""" (c_key, c_key_len) = util.serialize(key, raw_key) (c_value, c_value_len) = tc.hdb_get(self.db, c_key, c_key_len) if not c_value: raise KeyError(key) return util.deserialize(c_value, c_value_len, value_type)
def iterkeys(self, as_type=None): """Iterate for every key in a table database object.""" if not tc.tdb_iterinit(self.db): raise tc.TCException(tc.tdb_errmsg(tc.tdb_ecode(self.db))) while True: c_key, c_key_len = tc.tdb_iternext(self.db) if not c_key: break key = util.deserialize(c_key, c_key_len, as_type) yield key
def iterkeys(self, as_type=None): """Iterate for every key in a hash database object.""" if not tc.hdb_iterinit(self.db): raise tc.TCException(tc.hdb_errmsg(tc.hdb_ecode(self.db))) while True: c_key, c_key_len = tc.hdb_iternext(self.db) if not c_key: break key = util.deserialize(c_key, c_key_len, as_type) yield key
def iterkeys(self, as_type=None): """Iterate for every key in an abstract database object.""" if not tc.adb_iterinit(self.db): self._raise('Error initializing the iterator of an abstract ' \ 'database object.') while True: c_key, c_key_len = tc.adb_iternext(self.db) if not c_key: break key = util.deserialize(c_key, c_key_len, as_type) yield key
def post(self, project): nodes = deserialize(self.request.body)['nodes'] names = [ {"name": n['name']} for n in nodes ] if project in self.cache: if self.cache[project].finished: self.cache[project].clear() self.cache[project].update_tree(nodes) else: self.cache[project] = CacheMember.from_init_event( nodes, maxlen=options.bufferlen) self.cache[project].events.append(events.init(names))
def itervalues(self, as_type=None): """Iterate for every value in a fixed-length database object.""" if not tc.fdb_iterinit(self.db): raise tc.TCException(tc.fdb_errmsg(tc.fdb_ecode(self.db))) while True: key = tc.fdb_iternext(self.db) if not key: break (c_value, c_value_len) = tc.fdb_get(self.db, key) value = util.deserialize(c_value, c_value_len, as_type) yield value
def itervalues(self, as_type=None): """Iterate for every value in a hash database object.""" if not tc.hdb_iterinit(self.db): raise tc.TCException(tc.hdb_errmsg(tc.hdb_ecode(self.db))) while True: c_key, c_key_len = tc.hdb_iternext(self.db) if not c_key: break (c_value, c_value_len) = tc.hdb_get(self.db, c_key, c_key_len) value = util.deserialize(c_value, c_value_len, as_type) yield value
def get_col(self, key, col, default=None, raw_key=False, value_type=None): """Retrieve the value of a column of a record in a table database object.""" (c_key, c_key_len) = util.serialize(key, raw_key) (c_col, c_col_len) = util.serialize(col, as_raw=True) (c_value, c_value_len) = tc.tdb_get4(self.db, c_key, c_key_len, c_col, c_col_len) if c_value: value = util.deserialize(c_value, c_value_len, value_type) else: value = default return value
def iteritems(self, key_type=None, schema=None): """Iterate for every key / value in a table database object.""" if not tc.tdb_iterinit(self.db): raise tc.TCException(tc.tdb_errmsg(tc.tdb_ecode(self.db))) while True: c_key, c_key_len = tc.tdb_iternext(self.db) if not c_key: break cols_tcmap = tc.tdb_get(self.db, c_key, c_key_len) key = util.deserialize(c_key, c_key_len, key_type) cols = util.deserialize_tcmap(cols_tcmap, schema) yield (key, cols)
def iteritems(self, as_type=None): """Iterate for every key / value in a fixed-length database object.""" if not tc.fdb_iterinit(self.db): raise tc.TCException(tc.fdb_errmsg(tc.fdb_ecode(self.db))) while True: key = tc.fdb_iternext(self.db) if not key: break (c_value, c_value_len) = tc.fdb_get(self.db, key) value = util.deserialize(c_value, c_value_len, as_type) yield (key, value)
def proc_wraper(c_key, c_key_len, c_cols, c_cols_len, op): key = util.deserialize(ctypes.cast(c_key, ctypes.c_void_p), c_key_len, key_type) cols = util.deserialize(ctypes.cast(c_cols, ctypes.c_void_p), c_cols_len, str) return proc(key, cols, ctypes.cast(op, ctypes.c_char_p).value)
class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class Solution: def widthOfBinaryTree(self, root: TreeNode) -> int: q = deque([(root,0)]) cnt , ans = 1, 1 while q : node , col = q.popleft() cnt -= 1 if node.left : q.append((node.left, 2 * col)) if node.right : q.append((node.right, 2 * col+1)) if cnt == 0: cnt = len(q) if cnt > 1 : ans = max(ans,q[-1][1]-q[0][1] + 1) return ans import sys , os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree , deserialize, serialize root = deserialize('[1,1,1,1,null,null,1,1,null,null,1]') # drawtree(root) # serialize(root) s = Solution() ans = s.widthOfBinaryTree(root) print(ans)
left = traverse(root.left,arr,par) par.pop() if root.right: right = traverse(root.right,arr,par) par.pop() return left or right return traverse(root,arr,[]) def isValidSequence(self, root: TreeNode, arr: List[int]) -> bool: N = len(arr) def dfs(node, index): if node and node.val == arr[index]: index += 1 if index == N: return not node.left and not node.right else: return dfs(node.left, index) or dfs(node.right, index) return False return dfs(root, 0) import sys , os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree , deserialize, serialize root = deserialize('[0,1,0,0,1,0,null,null,1,0,0]') # drawtree(root) # serialize(root) arr = [0,1,0,1] s = Solution() print(s.isValidSequence(root,arr))
def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class Solution: def maxPathSum(self, root: TreeNode) -> int: def helper(root): if not root: return 0 left = max(0, helper(root.left)) right = max(0, helper(root.right)) self.ans = max(self.ans, root.val + left + right) return root.val + max(left, right) self.ans = root.val helper(root) return self.ans s = Solution() import sys, os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree, deserialize, serialize root = deserialize('[-10,9,20,null,null,15,7]') # drawtree(root) # serialize(root) ans = s.maxPathSum(root) print(ans)
self.right = right class Solution: def maxAncestorDiff(self, root: TreeNode) -> int: if not root: return 0 def helper(node, cur_max, cur_min): # if encounter leaves, return the max-min along the path if not node: return cur_max - cur_min # else, update max and min # and return the max of left and right subtrees cur_max = max(cur_max, node.val) cur_min = min(cur_min, node.val) left = helper(node.left, cur_max, cur_min) right = helper(node.right, cur_max, cur_min) return max(left, right) return helper(root, root.val, root.val) import sys , os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree , deserialize, serialize root = deserialize('[8,3,10,1,6,null,14,null,null,4,7,13]') # drawtree(root) # serialize(root) s = Solution() ans = s.maxAncestorDiff(root) print(ans)
def proc_wraper(c_pkey, c_pkey_len, c_cols, op): pkey = util.deserialize(ctypes.cast(c_pkey, ctypes.c_void_p), c_pkey_len, as_type=int) cols = util.deserialize_tcmap(c_cols) return proc(pkey, cols, ctypes.cast(op, ctypes.c_char_p).value)
def cmp_wraper(c_keya, c_keya_len, c_keyb, c_keyb_len, op): keya = util.deserialize(ctypes.cast(c_keya, ctypes.c_void_p), c_keya_len, raw_key) keyb = util.deserialize(ctypes.cast(c_keyb, ctypes.c_void_p), c_keyb_len, value_type) return cmp_(keya, keyb, ctypes.cast(op, ctypes.c_char_p).value)
# to its father, and they will be connected on the higher level recursion. if not root.left: return root.right # if it has a left child, we want to find the max val on the left subtree to # replace the node we want to delete. else: # try to find the max value on the left subtree tmp = root.left while tmp.right: tmp = tmp.right # replace root.val = tmp.val # since we have replaced the node we want to delete with the tmp, now we don't # want to keep the tmp on this tree, so we just use our function to delete it. # pass the val of tmp to the left subtree and repeat the whole approach. root.left = self.deleteNode(root.left, tmp.val) return root import sys, os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree, deserialize root = deserialize('[5,3,6,2,4,null,7]') s = Solution() r = s.deleteNode(root, 3) drawtree(r)
class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None class Solution: def rightSideView(self, root: TreeNode) -> List[int]: q , res , cnt = deque() , [] , 1 if not root : return [] q.append(root) while q: n = q.popleft() cnt -= 1 if n.left : q.append(n.left) if n.right : q.append(n.right) if cnt == 0: res.append(n.val) cnt = len(q) # print(q, cnt) return res import sys , os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree , deserialize, serialize root = deserialize('1,2,3,null,5,null,4') # drawtree(root) # serialize(root) s = Solution() ans = s.rightSideView(root) print(ans)
def validate_project(self, project, do_deserialize=True): if project not in self.cache: raise tornado.web.HTTPError( 404, "Project `{}' not found".format(project)) if do_deserialize: return deserialize(self.request.body)
# Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None class Solution: def searchBST(self, root: TreeNode, val: int) -> TreeNode: if root and val < root.val: return self.searchBST(root.left, val) elif root and val > root.val: return self.searchBST(root.right, val) else : return root import sys import os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree , deserialize root = deserialize('[4,2,7,1,3,null,null]') # drawtree(root) s = Solution() r = s.searchBST(root,2) drawtree(r)
def proc_wraper(c_key, c_key_len, c_value, c_value_len, op): key = util.deserialize(ctypes.cast(c_key, ctypes.c_void_p), c_key_len, str) value = util.deserialize(ctypes.cast(c_value, ctypes.c_void_p), c_value_len, str) return proc(key, value, ctypes.cast(op, ctypes.c_char_p).value)
def _getitem(self, key, as_type=None): """Retrieve a Python object in a fixed-length database object.""" (c_value, c_value_len) = tc.fdb_get(self.db, key) if not c_value: raise KeyError(key) return util.deserialize(c_value, c_value_len, as_type)
self.right = right class Solution: def upsideDownBinaryTree(self, root: TreeNode) -> TreeNode: def upsideDown(node, parent, parentRight): oldLeft, oldRight = node.left, node.right # consider the left child as node node.left = parentRight node.right = parent # if left most with no other children then this is the new root if not oldLeft and not oldRight: return node # tail recusrion Memory - O(1) but not in python :( return upsideDown(oldLeft, node, oldRight) if not root: return None return upsideDown(root, None, None) import sys, os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree, deserialize, serialize root = deserialize('[1,2,3,4,5]') # drawtree(root) s = Solution() new_root = s.upsideDownBinaryTree(root) drawtree(new_root)
def traverse(root, order=0, level=0): nonlocal min_order, max_order if not root: return if root.left: traverse(root.left, order - 1, level + 1) if root.right: traverse(root.right, order + 1, level + 1) order_dict[order].append((level, root.val)) min_order = min(min_order, order) max_order = max(max_order, order) order_dict = collections.defaultdict(list) traverse(root) # print(order_dict) ans = [] for i in range(min_order, max_order + 1): lst = [n[1] for n in sorted(order_dict[i])] ans.append(lst) return ans import sys, os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree, deserialize, serialize root = deserialize('[1,2,3,4,5,6,7]') # drawtree(root) # serialize(root) s = Solution() ans = s.verticalTraversal(root) print(ans)
# One of (x, y) will be negative, which makes it difficult to do (c ^ x) % n # To solve that problem, we compute the modular inverse d of c such that: # d ^ (-x) === c ^ x (mod n) if x < 0: c1 = util.modinv(c1, n) x = -x elif y < 0: c2 = util.modinv(c2, n) y = -y # Use knowledge of c1, c2, x, y to solve for m m = ((c1 ** x) * (c2 ** y)) % n return m if __name__ == '__main__': # TODO(Public modulus, from the chat logs) n = # TODO(Public exponents, also from chat logs) e1 = e2 = # TODO(Ciphertexts, also from chat logs) c1 = c2 = # Decrypt paired ciphertexts m_guess = decrypt(c1, c2, e1, e2, n) print 'guess = %s' % (util.deserialize(m_guess))
# p = p.right # PostOrder - Reverse the traversal process of preorder else: node = stk.pop() ans.append(node.val) # InOrder - Add after all left children p = node.right # Preorder & InOrder # p = node.left # PostOrder - Reverse the traversal process of preorder return ans def inorderMorris(self, root): cur = root while cur: if cur.left: temp = cur.left while temp.right and temp.right != cur: temp = temp.right if not temp.right: temp.right, cur = cur, cur.left continue temp.right = None print(cur.val) cur = cur.right s = Solution() root = deserialize('[5,2,6,null,3,null,7]') # drawtree(root) print(s.traverse(root)) s.inorderMorris(root) drawtree(root)
leaves(node.left) if node != root and not node.left and not node.right: boundary.append(node.val) leaves(node.right) def rightBoundary(node): if not node or not node.left and not node.right: return if node.right: rightBoundary(node.right) else: rightBoundary(node.left) boundary.append(node.val) if not root: return [] boundary = [root.val] leftBoundary(root.left) leaves(root) rightBoundary(root.right) return boundary import sys, os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree, deserialize, serialize # root = deserialize('[1,2,3,4,5,6,null,null,null,7,8,9,10]') root = deserialize('[[1,null,4,3,null,2,null,5]') # drawtree(root) # serialize(root) s = Solution() ans = s.boundaryOfBinaryTree(root) print(ans)
def decrypt(c1, c2, c3, n1, n2, n3): """ Decrypt by executing a Low Public Exponent Attack based on the Chinese Remainder Theorem. For a good explanation: http://crypto.stackexchange.com/questions/6713/low-public-exponent-attack-for-rsa """ t1 = c1 * (n2 * n3) * util.modinv(n2 * n3, n1) t2 = c2 * (n1 * n3) * util.modinv(n1 * n3, n2) t3 = c3 * (n1 * n2) * util.modinv(n1 * n2, n3) cubed = (t1 + t2 + t3) % (n1 * n2 * n3) return util.iroot(cubed, 3) if __name__ == '__main__': # TODO(Badguy's public exponent) e = # TODO(Badguy's three public moduli) n1 = n2 = n3 = # TODO(Three ciphertexts of the same message, extracted from the server) c1 = c2 = c3 = # Decrypt using the Low Public Exponent Attack print util.deserialize(decrypt(c1, c2, c3, n1, n2, n3))
def findDuplicateSubtrees(self, root: TreeNode) -> List[TreeNode]: trees = collections.defaultdict() trees.default_factory = trees.__len__ count = collections.Counter() ans = [] def lookup(node): if node: key = node.val, lookup(node.left), lookup(node.right) uid = trees[key] print(f'{key} => {uid}') count[uid] += 1 if count[uid] == 2: ans.append(node) return uid lookup(root) return ans import sys, os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree, deserialize root = deserialize('[1,2,3,4,null,2,4,null,null,4,null]') # drawtree(root) s = Solution() a = s.findDuplicateSubtrees(root) print(f'ans = {a}')
from collections import defaultdict class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class Solution: def pathSum(self, root: TreeNode, sum: int) -> int: def helper(node,cur_sum): nonlocal cnt if not node : return cur_sum += node.val if cur_sum == sum : cnt += 1 cnt += h[cur_sum - sum] h[cur_sum] += 1 helper(node.left,cur_sum) helper(node.right,cur_sum) h, cur_sum , cnt = defaultdict(int),0 , 0 helper(root,sum) return cnt ip = '[10,5,-3,3,2,null,11,3,-2,null,1]' root = deserialize(ip) s = Solution() ans = s.pathSum(root,8) print(ans)
def proc_wraper(c_key, c_key_len, c_value, c_value_len, op): key = util.deserialize(ctypes.cast(c_key, ctypes.c_void_p), c_key_len, key_type) value = util.deserialize(ctypes.cast(c_value, ctypes.c_void_p), c_value_len, value_type) return proc(key, value, ctypes.cast(op, ctypes.c_char_p).value)
# Definition for a binary tree node. class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class Solution: def lcaDeepestLeaves(self, root: TreeNode) -> TreeNode: def helper(root): if not root: return 0, None hl, lca = helper(root.left) hr, rca = helper(root.right) if hl > hr: return hl + 1, lca if hr > hl: return hr + 1, rca return hl + 1, root return helper(root)[1] import sys, os sys.path.append(os.path.abspath('../TreeUtil')) from util import drawtree, deserialize, serialize root = deserialize('[3,5,1,6,2,0,8,null,null,7,4]') # drawtree(root) s = Solution() ans = s.lcaDeepestLeaves(root) drawtree(ans)