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 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 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 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 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 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 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)
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)
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 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 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)
