def test_handles_bad_tree_right():
bad_tree = Node(8)
bad_tree.left = Node(10)
tree = Node(7)
tree.right = bad_tree
assert (check_binary_search_tree_(tree) == False)
def test_inorder():
root = Node(4)
root.left = Node(2)
root.right = Node(5)
root.left.left = Node(1)
root.left.right = Node(3)
res = inorder(root)
assert res == [1, 2, 3, 4, 5]
def test_deepest(self):
root = Node('a')
root.left = Node('b')
root.left.left = Node('d')
root.right = Node('c')
n, d = deepest(root)
self.assertEqual('d', n.val)
self.assertEqual(3, d)
def test_solution():
from solution import Node, linkedList
items = linkedList()
items.head = Node(20)
items.head.next = Node(30)
items.head.next.next = Node(40)
assert items.search(30) == True
assert items.search(10) == False
def test_intersection(self):
a = Node(1)
a.next = Node(2)
a.next.next = Node(3)
a.next.next.next = Node(4)
b = Node(6)
b.next = a.next.next
self.assertEqual([3, 4], intersection(a, b).toList())
def test_solution():
from solution import Node, linkedList
items = linkedList()
items.head = Node(20)
items.head.next = Node(30)
items.head.next.next = Node(50)
items.insert_after_item(30, 0)
assert items.head.data == 20
assert items.head.next.data == 30
assert items.head.next.next.data == 0
def test_solution():
from solution import Node, linkedList
items = linkedList()
items.head = Node(20)
items.head.next = Node(30)
items.head.next.next = Node(40)
items.reverse()
assert items.head.data == 40
assert items.head.next.data == 30
def test_solution():
from solution import Node, linkedList
items = linkedList()
items.head = Node(20)
items.head.next = Node(30)
items.head.next.next = Node(40)
items.insert_at_index(2, 2)
assert items.head.data == 20
assert items.head.next.data == 2
def test_solution():
from solution import Node, Preorder
items = Node(5)
items.left = Node(6)
items.right = Node(7)
items.left.left = Node(8)
items.left.right = Node(9)
result_value_1 = Preorder(items)
result = [5, 6, 8, 9, 7]
assert result_value_1 == result
def test_solution():
from solution import Node, linkedlist
items = linkedlist()
items.head = Node(20)
items.head.next = Node(30)
items.head.next.next = Node(50)
print(items.head, items.head.next, items.head.next.next)
items.delete_at_end()
assert items.head.data == 20
assert items.head.next.data == 30
assert items.head.next.next == None
def test_solution():
from solution import Node, linkedList
items = linkedList()
items.head = Node(20)
items.head.next = Node(30)
items.head.next.next = Node(40)
items.head.next.next.next = Node(50)
items.delete_item_by_value(40)
assert items.head.data == 20
assert items.head.next.data == 30
assert items.head.next.next.data == 50
def test_solution():
from solution import Node, NthInorder
items = Node(5)
items.left = Node(6)
items.right = Node(7)
items.left.left = Node(8)
items.left.right = Node(9)
[8, 6, 9, 5, 7]
assert NthInorder(items, 4) == 5
assert NthInorder(items, 1) == 8
assert NthInorder(items, 6) == "no 6-th element"
def test_remove_kth_from_linked_list(self):
self.assertEqual(None, remove_kth_from_linked_list(Node(1), 1))
self.assertEqual([2, 3, 4, 5], remove_kth_from_linked_list(buildLinkedList(), 5).toList())
self.assertEqual([1, 2, 4, 5], remove_kth_from_linked_list(buildLinkedList(), 3).toList())
self.assertEqual([1, 2, 3, 4], remove_kth_from_linked_list(buildLinkedList(), 1).toList())
def convert_list_to_binary_search_tree(raw_list: Optional[list[int]]) -> Optional[Node]:
if not raw_list:
return None
root = Node(raw_list[0])
root.right = convert_list_to_binary_search_tree(raw_list[1:])
root.left = convert_list_to_binary_search_tree(raw_list[2:])
return root
def process_file(f):
nodes = {}
for line in f:
num, neighbors = line.strip().split(' <-> ')
num = int(num)
nodes[num] = Node(num)
nodes[num].neighbors = set(int(n) for n in neighbors.split(', '))
return nodes
def test_solution():
from solution import Node, closest_value
root = Node(8)
root.left = Node(5)
root.right = Node(14)
root.left.left = Node(4)
root.left.right = Node(6)
root.left.right.left = Node(8)
root.left.right.right = Node(7)
root.right.right = Node(24)
root.right.right.left = Node(22)
result = closest_value(root, 9)
assert result == 8
def test_solution(monkeypatch):
ret_val = []
def g(num):
ret_val.append(num)
monkeypatch.setattr("builtins.print", g)
from solution import Node, linkedList
items = linkedList()
items.head = Node(1)
e2 = Node(2)
items.head.next = e2
items.traverse()
assert ret_val[0] == 1
assert ret_val[1] == 2
def test_solution():
from solution import Node, linkedList
items = linkedList()
items.head = Node(20)
items.insert_at_start(40)
items.insert_at_start(50)
assert items.head.data == 50
assert items.head.next.data == 40
assert items.head.next.next.data == 20
def test_handles_failing_example():
candidate_tree = Node(3)
candidate_tree.left = Node(2)
candidate_tree.left.left = Node(1)
candidate_tree.left.right = Node(4)
candidate_tree.right = Node(6)
candidate_tree.right.left = Node(5)
candidate_tree.right.right = Node(7)
assert (check_binary_search_tree_(candidate_tree) == False)
def process_file(f):
programs = {}
parents = {} # maps child to parent
for line in f:
match = pattern.match(line.strip())
name, weight, children = match.group('name'), match.group(
'weight'), match.group('children')
programs[name] = Node(name, int(weight))
if children:
programs[name].children = set(children.split(', '))
for child_name, parent_name in parents.items():
programs[child_name].parent_name = parent_name
return programs
def test_handles_valid_nested_tree():
candidate_tree = Node(4)
candidate_tree.left = Node(2)
candidate_tree.left.left = Node(1)
candidate_tree.left.right = Node(3)
candidate_tree.right = Node(6)
candidate_tree.right.left = Node(5)
assert (check_binary_search_tree_(candidate_tree) == True)
def test_solution():
from solution import Node, search
items = Node(5)
items.left = Node(6)
items.right = Node(7)
items.left.left = Node(8)
items.left.right = Node(9)
items.right.left = Node(10)
items.right.right = Node(11)
result_value = search(items, 11)
result_value_2 = search(items, 99)
assert result_value == True
assert result_value_2 == False
def test_solution():
from solution import Node, NthPreorder
items = Node(25)
items.left = Node(20)
items.right = Node(30)
items.left.left = Node(18)
items.left.right = Node(22)
items.right.left = Node(24)
items.right.right = Node(32)
assert NthPreorder(items, 6) == 24
assert NthPreorder(items, 4) == 22
assert NthPreorder(items, 8) == "no 8-th element"
def test_solution():
from solution import Node, height
left_child = Node(6, None, None)
right_child = Node(7, None, None)
items = Node(5, left_child, right_child)
items.left.left = Node(8)
items.left.right = Node(9)
items.right.left = Node(10)
result = height(items)
assert result == 3
def test_solution():
from solution import Node
items = Node(10)
items.left = Node(11)
items.left.left = Node(7)
items.right = Node(9)
items.right.left = Node(15)
items.right.right = Node(8)
val = 12
items.insert(val)
assert items.left.right.key == 12
def test_evaluate(self):
# *
# / \
# + +
# / \ / \
# - 2 4 5
# \
# -3
tree = Node('*')
tree.left = Node('+')
tree.left.left = Node('-')
tree.left.left.right = Node(-3)
tree.left.right = Node(2)
tree.right = Node('+')
tree.right.left = Node(4)
tree.right.right = Node(5)
self.assertEqual(45, evaluate(tree))
def test_serialize(self):
# 1
# / \
# 3 4
# / \ \
# 2 5 7
tree = Node(1)
tree.left = Node(3)
tree.left.left = Node(2)
tree.left.right = Node(5)
tree.right = Node(4)
tree.right.right = Node(7)
self.assertEqual('1 3 2 # # 5 # # 4 # 7 # #', serialize(tree))
def test_romanToInt(self):
# Given this tree:
# 1
# / \
# 2 3
# / / \
# 0 9 4
# We want a tree like:
# 1
# / \
# 0 3
# / \
# 9 4
tree = Node(1)
tree.left = Node(2)
tree.right = Node(3)
tree.right.right = Node(4)
tree.right.left = Node(9)
tree.left.left = Node(0)
self.assertEqual('1\n03\n94', fullBinaryTree(tree).__str__())
def test_merge(self):
a = Node(1, Node(3, Node(5)))
b = Node(2, Node(4, Node(6)))
self.assertEqual('123456', merge([a, b]).__str__())
from solution import Node, Solution
def traverse(node, ar):
ar.append(node.val)
for child_node in node.children:
traverse(child_node, ar)
return ar
s = Solution()
left = Node(val=3,
children=[Node(val=5, children=[]),
Node(val=6, children=[])])
center = Node(val=2, children=[])
right = Node(val=4, children=[])
root = Node(val=1, children=[left, center, right])
assert s.preorder(root) == traverse(root, [])
assert s.preorder(None) == []
