def tests(): letters = ['a', 'c', 'd', 'f', 'g'] output = contains(letters, 'a') assert_(expected=True, actual=output) output = contains(letters, 'b') assert_(expected=False, actual=output)
def tests(): test_string = 'fedRTSersUXJ' output = case_specific_sorting(test_string) assert_(expected="deeJRSfrsTUX", actual=output) test_string = "defRTSersUXI" output = case_specific_sorting(test_string) assert_(expected="deeIRSfrsTUX", actual=output)
def tests(): array = [0, 1, 3, -1, 2] merge(array, 0, 2, 3, 4) assert_(expected=[-1, 0, 1, 2, 3], actual=array) array = [0, 1, 3, -1, 2] merge_sort(array) assert_(expected=[-1, 0, 1, 2, 3], actual=array)
def test_binary_search(binary_search): array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] key = 6 expected_index = 6 actual = binary_search(array, key) assert_(expected_index, actual) array = [0, 1] key = 1 expected_index = 1 actual = binary_search(array, key) assert_(expected_index, actual)
def test(): trie = Trie() trie.add("hello") trie.add("hey") trie.add("add") assert_(True, trie.exists("hello")) assert_(True, trie.exists("hey")) assert_(True, trie.exists("add")) assert_(False, trie.exists("RR")) node = trie.find("h") actual = node.suffixes() assert_(expected=["ello", "ey"], actual=actual)
def tests(): node_u = GraphNode('U') node_d = GraphNode('D') node_a = GraphNode('A') node_c = GraphNode('C') node_i = GraphNode('I') node_t = GraphNode('T') node_y = GraphNode('Y') graph = Graph([node_u, node_d, node_a, node_c, node_i, node_t, node_y]) graph.add_edge(node_u, node_a, 4) graph.add_edge(node_u, node_c, 6) graph.add_edge(node_u, node_d, 3) graph.add_edge(node_d, node_c, 4) graph.add_edge(node_a, node_i, 7) graph.add_edge(node_c, node_i, 4) graph.add_edge(node_c, node_t, 5) graph.add_edge(node_i, node_y, 4) graph.add_edge(node_t, node_y, 5) # Test-1 start_node = node_u end_node = node_y output = dijkstra(start_node, end_node) end_node_value = None if end_node is not None: end_node_value = end_node.value print('Shortest Distance of ({} --> {}) is {} and path is {}'.format( start_node.value, end_node_value, output[1], output[0])) assert_(expected=(['U', 'C', 'I', 'Y'], 14), actual=output) # Test-2 start_node = node_u end_node = None output = dijkstra(start_node, end_node) end_node_value = None if end_node is not None: end_node_value = end_node.value print('Shortest Distance of ({} --> {}) is {} and path is {}'.format( start_node.value, end_node_value, output[1], output[0])) assert_(expected=(['U', 'C', 'I', 'Y'], 14), actual=output)
def tests(first_and_last_index): array = [0, 1, 2, 3, 3, 3, 3, 4, 5, 6] key = 3 assert_(expected=[3, 6], actual=first_and_last_index(array, key)) array = [1] key = 1 assert_(expected=[0, 0], actual=first_and_last_index(array, key)) array = [0, 1, 2, 3, 4, 5] key = 5 assert_(expected=[5, 5], actual=first_and_last_index(array, key)) key = 6 assert_(expected=[-1, -1], actual=first_and_last_index(array, key))
def tests(): array = [4, 3, 1, 4, 3, 3, 2, 4] quick_sort(array) assert_(expected=[1, 2, 3, 3, 3, 4, 4, 4], actual=array) array = [8, 3, 1, 7, 0, 10, 2] quick_sort(array) assert_(expected=[0, 1, 2, 3, 7, 8, 10], actual=array) array = [1, 0] quick_sort(array) assert_(expected=[0, 1], actual=array) array = [96, 97, 98] quick_sort(array) assert_(expected=[96, 97, 98], actual=array)
def test_evaluate_post_fix(): test_case = (["3", "1", "+", "4", "*"], 16) assert_(test_case[1], evaluate_post_fix(test_case[0])) test_case = (["4", "13", "5", "/", "+"], 6) assert_(test_case[1], evaluate_post_fix(test_case[0])) test_case = (["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"], 22) assert_(test_case[1], evaluate_post_fix(test_case[0]))
def tests(): array = [3, 1, 2, 0, 2, -1] heap_sort(array) assert_(expected=[-1, 0, 1, 2, 2, 3], actual=array) array = [3, 7, 4, 6, 1, 0, 9, 8, 9, 4, 3, 5] solution = [0, 1, 3, 3, 4, 4, 5, 6, 7, 8, 9, 9] heap_sort(array) assert_(expected=solution, actual=array) array = [5, 5, 5, 3, 3, 3, 4, 4, 4, 4] solution = [3, 3, 3, 4, 4, 4, 4, 5, 5, 5] heap_sort(array) assert_(expected=solution, actual=array) array = [99] solution = [99] heap_sort(array) assert_(expected=solution, actual=array) array = [0, 1, 2, 5, 12, 21, 0] solution = [0, 0, 1, 2, 5, 12, 21] heap_sort(array) assert_(expected=solution, actual=array)
def tests(): min_heap = MinHeap(2) min_heap.insert(1) min_heap.insert(3) min_heap.insert(2) assert_(expected=4, actual=min_heap.capacity) assert_(expected=[1, 3, 2], actual=min_heap.to_list()) min_heap.remove() assert_(expected=[2, 3], actual=min_heap.to_list())
def tests(): input_list = [2, 7, 11, 15] target = 9 solution = [2, 7] assert_(expected=solution, actual=pair_sum(input_list, target)) input_list = [0, 8, 5, 7, 9] target = 9 solution = [0, 9] assert_(expected=solution, actual=pair_sum(input_list, target)) input_list = [110, 9, 89] target = 9 solution = [None, None] assert_(expected=solution, actual=pair_sum(input_list, target))
def tests(): test_case = [0, 0, 2, 2, 2, 1, 1, 1, 2, 0, 2] sort_0s_1s_2s(test_case) assert_(expected=sorted(test_case), actual=test_case) test_case = [ 2, 1, 2, 0, 0, 2, 1, 0, 1, 0, 0, 2, 2, 2, 1, 2, 0, 0, 0, 2, 1, 0, 2, 0, 0, 1 ] sort_0s_1s_2s(test_case) assert_(expected=sorted(test_case), actual=test_case) test_case = [2, 2, 0, 0, 2, 1, 0, 2, 2, 1, 1, 1, 0, 1, 2, 0, 2, 0, 1] sort_0s_1s_2s(test_case) assert_(expected=sorted(test_case), actual=test_case)
def test_hash_map(): hash_map = HashMap(2) # Test HashMap get and put key = "abcde" value = "ramiz" hash_map.put(key, value) output = hash_map.get(key) assert_(value, output) # Test size assert_(1, hash_map.size()) # delete hash_map.delete("abcde") assert_(0, hash_map.size()) # Test Rehash hash_map.put("mine", "mine") # this should trigger rehashing hash_map.put("hi", "hi") assert_(2, hash_map.size()) print("All Tests Passed!")
def test(): assert_(2, minimum_bracket_reversals("}}}}")) assert_(2, minimum_bracket_reversals("}}{{")) assert_(-1, minimum_bracket_reversals("}{{")) assert_(2, minimum_bracket_reversals("}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{")) assert_(1, minimum_bracket_reversals("}}{}{}{}{}{}{}{}{}{}{}{}{}{}{}"))
def test_function(test_case): arrival = test_case[0] departure = test_case[1] solution = test_case[2] output = min_platforms(arrival, departure) assert_(expected=solution, actual=output)
def test_function(test_case): num_islands = test_case[0] bridge_config = test_case[1] solution = test_case[2] output = get_minimum_cost_of_connecting(num_islands, bridge_config) assert_(expected=solution, actual=output)
def tests(): graph = Graph() nodeA = GraphNode('A') nodeB = GraphNode("B") nodeC = GraphNode("C") nodeAA = GraphNode("AA") graph.add_node(nodeA) graph.add_node(nodeAA) graph.add_node(nodeB) graph.add_node(nodeC) graph.add_edge(nodeA, nodeC) graph.add_edge(nodeA, nodeAA) graph.add_edge(nodeC, nodeB) assert_(expected=['A', 'C', "AA", 'B'], actual=graph.BFS_traversal()) assert_(expected=nodeB, actual=graph.BFS_search('B')) assert_(expected=["A", "C", "B", "AA"], actual=graph.DFS_traversal_iterative()) assert_(expected=["A", "C", "B", "AA"], actual=graph.DFS_traversal_recursive()) assert_(expected=nodeB, actual=graph.DFS_search_iterative('B')) assert_(expected=nodeB, actual=graph.DFS_search_recursive('B'))
def tests(): array = [2, 1] inversions = count_inversions(array) assert_(expected=1, actual=inversions) array = [3, 1, 2, 4] inversions = count_inversions(array) assert_(expected=2, actual=inversions) array = [7, 5, 3, 1] inversions = count_inversions(array) assert_(expected=6, actual=inversions) array = [2, 5, 1, 3, 4] inversions = count_inversions(array) assert_(expected=4, actual=inversions) array = [54, 99, 49, 22, 37, 18, 22, 90, 86, 33] inversions = count_inversions(array) assert_(expected=26, actual=inversions) array = [1, 2, 4, 2, 3, 11, 22, 99, 108, 389] inversions = count_inversions(array) assert_(expected=2, actual=inversions)
def test_is_operator(): assert_(True, is_operator("-")) assert_(False, is_operator("8"))
def test_evaluate_operator(): assert_(3, evaluate_operator('2', '1', '+')) assert_(3, evaluate_operator('2', '-1', '-')) assert_(1, evaluate_operator('2', '1', '-')) assert_(2, evaluate_operator('2', '1', '*')) assert_(2, evaluate_operator('2', '1', '/'))
the first element will represent a list of comma-separated numbers sorted in ascending order, the second element will represent a second list of comma-separated numbers (also sorted). Your goal is to return a comma-separated string containing the numbers that occur in elements of strArr in sorted order. If there is no intersection, return the string false. Examples Input: ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"] Output: 1,4,13 Input: ["1, 3, 9, 10, 17, 18", "1, 4, 9, 10"] Output: 1,9,10 """ from asserts.asserts import assert_ def find_intersection(string): str1 = string[0] str2 = string[1] set1 = set([int(i) for i in str1.split(", ")]) set2 = set([int(i) for i in str2.split(", ")]) intersection = sorted(set2.intersection(set1)) if len(intersection) == 0: return "false" return ",".join(map(str, intersection)) input1 = ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"] output = find_intersection(input1) assert_("1,4,13", output)
def tests(): trie_node = TrieNode() trie_node.add("a") actual = "a" in trie_node assert_(expected=True, actual=actual)
def tests(): tree = RedBlackTree() # Test insert tree.insert(2) tree.insert(3) tree.insert(1) tree.insert(0) in_order_expected = [0, 1, 2, 3] in_order_actual = tree.in_order_traversal() assert_(in_order_expected, in_order_actual) tree = RedBlackTree() tree.insert(9) tree.insert(6) tree.insert(19) tree.insert(13) tree.insert(16) # print(tree) in_order_expected = [6, 9, 13, 16, 19] in_order_actual = tree.in_order_traversal() assert_(expected=in_order_expected, actual=in_order_actual) assert_(expected=True, actual=tree.search(16)) assert_(expected=True, actual=tree.search(19)) assert_(expected=True, actual=tree.search(6)) assert_(expected=False, actual=tree.search(31))