def test_stress(self): enabled = True if not enabled: return # get two lists of string numbers max_len = 20 n_numbers = 100 numbers = list() for i in range(n_numbers): to_add = list() length = random.randint(0, max_len) for j in range(length): if j == 0: to_add.append(random.randint(1, 9)) else: to_add.append(random.randint(0, 9)) numbers.append(to_add) sol_long = main.Solution() sol_long.threshold = 1000 sol_kara = main.Solution() sol_kara.threshold = 2 for i in range(n_numbers): for j in range(i, n_numbers): self.assertEqual( sol_long.int_array_to_string( sol_long.long_mult(numbers[i], numbers[j])), sol_kara.int_array_to_string( sol_kara.k_mult(numbers[i], numbers[j])), str(numbers[i]) + ", " + str(numbers[j]))
def test_spiralOrder(self): sol = main.Solution() n = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] expected = [1, 2, 3, 6, 9, 8, 7, 4, 5] result = sol.spiralOrder(n) self.assertEqual(expected, result) n = [[1, 2, 3, 4]] expected = [1, 2, 3, 4] result = sol.spiralOrder(n) self.assertEqual(expected, result) n = [[1], [2], [3], [4]] expected = [1, 2, 3, 4] result = sol.spiralOrder(n) self.assertEqual(expected, result) n = [[1, 2], [3, 4], [5, 6]] expected = [1, 2, 4, 6, 5, 3] result = sol.spiralOrder(n) self.assertEqual(expected, result) n = [[1, 2, 3], [4, 5, 6]] expected = [1, 2, 3, 6, 5, 4] result = sol.spiralOrder(n) self.assertEqual(expected, result) n = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] expected = [1, 2, 3, 6, 9, 12, 11, 10, 7, 4, 5, 8] result = sol.spiralOrder(n) self.assertEqual(expected, result)
def test_solution(self): sol = main.Solution() heights = list() expected = 6 result = expected # example 1 heights = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1] expected = 6 result = sol.trap(heights) self.assertEqual(expected, result) # plataeu heights = [0, 0, 2, 2, 2, 2, 2, 0, 0, 0] expected = 0 result = sol.trap(heights) self.assertEqual(expected, result) # peak at end heights = [10, 0, 2, 2, 2, 2, 2, 0, 0, 0] expected = 2 result = sol.trap(heights) self.assertEqual(expected, result) # peak at end heights = [0, 0, 2, 2, 2, 2, 2, 0, 0, 10] expected = 4 result = sol.trap(heights) self.assertEqual(expected, result) # empty heights = [] expected = 0 result = sol.trap(heights) self.assertEqual(expected, result)
def test_string_to_int_array(self): sol = main.Solution() string_num = "123" expected = list((3, 2, 1)) result = sol.string_to_int_array(string_num) self.assertEqual(expected, result)
def test_groupAnagrams(self): sol = main.Solution() in_strings = ["eat", "tea", "tan", "ate", "nat", "bat"] expected = [["ate", "eat", "tea"], ["nat", "tan"], ["bat"]] result = sol.groupAnagrams(in_strings) self.assertTrue(self.check_list_list_anagram(expected, result))
def test_is_anagram(self): sol = main.Solution() string1 = "aana" string2 = "naaa" expected = True result = sol.is_anagram(string1, string2) self.assertEqual(expected, result) string1 = "aanab" string2 = "naaa" expected = False result = sol.is_anagram(string1, string2) self.assertEqual(expected, result) string1 = "" string2 = "" expected = True result = sol.is_anagram(string1, string2) self.assertEqual(expected, result) string1 = "" string2 = "naaa" expected = False result = sol.is_anagram(string1, string2) self.assertEqual(expected, result)
def test_trim_int_list(self): sol = main.Solution() num = [9, 8, 1, 0, 0] expected = [9, 8, 1] result = sol.trim_int_list(num) self.assertEqual(expected, result) num = list((0, 1, 8, 9, 0)) expected = list((0, 1, 8, 9)) result = sol.trim_int_list(num) self.assertEqual(expected, result) num = list((1, 8, 9)) expected = list((1, 8, 9)) result = sol.trim_int_list(num) self.assertEqual(expected, result) num = list((1, 0, 8, 9, 0)) expected = list((1, 0, 8, 9)) result = sol.trim_int_list(num) self.assertEqual(expected, result) num = [0] expected = [0] result = sol.trim_int_list(num) self.assertEqual(expected, result) num = list() expected = [0] result = sol.trim_int_list(num) self.assertEqual(expected, result)
def test_multiply(self): sol = main.Solution() num1 = "10" num2 = "5" expected = "50" result = sol.multiply(num1, num2) self.assertEqual(expected, result) num1 = "123" num2 = "456" expected = "56088" result = sol.multiply(num1, num2) self.assertEqual(expected, result) num1 = "0" num2 = "456" expected = "0" result = sol.multiply(num1, num2) self.assertEqual(expected, result) num1 = "4568" num2 = "456" expected = "2083008" result = sol.multiply(num1, num2) self.assertEqual(expected, result) num1 = "1000" num2 = "102" expected = "102000" result = sol.multiply(num1, num2) self.assertEqual(expected, result)
def test_sub_from(self): sol = main.Solution() base = [1, 7, 7, 0, 6] to_sub = [1, 8] shift = 1 expected = [1, 6, 9, 9, 5] sol.sub_from(base, to_sub, shift) self.assertEqual(expected, base)
def test_long_mult(self): sol = main.Solution() sol.threshold = 200 num1 = list((1, 2, 3)) num2 = list((3, 5)) expected = list((3, 1, 0, 7, 1)) result = sol.long_mult(num1, num2) self.assertEqual(expected, result)
def test_solution(self): sol = main.Solution() candidates = list() expected = list() result = list() target = 0 candidates = list([10, 1, 2, 7, 6, 1, 5]) target = 8 expected = list([ list([1, 7]), list([1, 2, 5]), list([2, 6]), list([1, 1, 6]), ]) result = sol.combinationSum(candidates, target) self.assertTrue(list_compare_no_order(expected, result)) candidates = list([2, 5, 2, 1, 2]) target = 5 expected = list([list([1, 2, 2]), list([5])]) result = sol.combinationSum(candidates, target) self.assertTrue(list_compare_no_order(expected, result)) candidates = list([2, 3, 5]) target = 1 expected = list() result = sol.combinationSum(candidates, target) self.assertTrue(list_compare_no_order(expected, result)) candidates = list([2, 3, 5]) target = 3 expected = list([ list([3]), ]) result = sol.combinationSum(candidates, target) self.assertTrue(list_compare_no_order(expected, result)) candidates = list([2, 3, 5]) target = 11 expected = list() result = sol.combinationSum(candidates, target) self.assertTrue(list_compare_no_order(expected, result)) candidates = list([2, 3, 5]) target = 4 expected = list() result = sol.combinationSum(candidates, target) self.assertTrue(list_compare_no_order(expected, result)) candidates = list([2, 2, 2, 2]) target = 6 expected = list([list([2, 2, 2])]) result = sol.combinationSum(candidates, target) self.assertTrue(list_compare_no_order(expected, result))
def test_k_mult(self): sol = main.Solution() sol.threshold = 2 # take all the way down to single digit num1 = [0, 1] num2 = [5] expected = [0, 5] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result) num1 = [0] num2 = [4, 5, 6] expected = [0] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result) num1 = [1, 2] num2 = [0, 1] expected = [0, 1, 2] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result) num1 = [1, 2, 3] num2 = [4, 5, 6] expected = [4, 3, 9, 9, 0, 2] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result) num1 = [0, 0, 0, 1] num2 = [1, 0, 2] expected = [0, 0, 0, 1, 0, 2] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result) num1 = [9, 6, 8] num2 = [9, 6] expected = [1, 6, 9, 9, 5] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result) num1 = [4, 5, 6, 8] num2 = [4, 5, 6] expected = [6, 1, 7, 9, 5, 6, 5] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result) num1 = [4, 5, 7, 4] num2 = [7, 5, 6, 4, 3, 0, 3, 3, 5, 2, 3, 8, 5, 1, 0, 8, 4, 0, 1, 2] expected = [ 8, 7, 3, 9, 5, 7, 6, 4, 0, 2, 6, 8, 7, 6, 2, 7, 6, 2, 2, 6, 0, 0, 0, 1 ] result = sol.trim_int_list(sol.k_mult(num1, num2)) self.assertEqual(expected, result)
def test_hash_string(self): sol = main.Solution() in_string = "a" expected = 2 result = sol.hash_string(in_string) self.assertEqual(expected, result) in_string = "zzzzz" expected = 41115325 result = sol.hash_string(in_string) self.assertEqual(expected, result)
def test_permute(self): sol = main.Solution() in_list = [1, 2, 3] expected = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] result = sol.permute(in_list) self.assertTrue(self.tool_check_result(in_list, result)) in_list = [48, 177, 98, 159, 136] result = sol.permute(in_list) self.assertTrue(self.tool_check_result(in_list, result))
def test_stress(self): enabled = True if not enabled: return sol = main.Solution() max_size = 8 letter_set = ['e', 'u', 'z'] n_checks = 1000 n_words = 30 test_set = list() # build test sets for i in range(n_checks): this_list = list() for j in range(n_words): this_size = random.randint(max_size - 2, max_size) this_word = "" for k in range(this_size): this_word += random.choice(letter_set) this_list.append(this_word) test_set.append(this_list) print("built " + str(len(test_set)) + " sets") print("sample: ") print(str(test_set[0])) print(str(sol.groupAnagrams(test_set[0]))) for i in range(n_checks): self.assertTrue( self.check_list_list_anagram( sol.groupAnagrams(test_set[i]), sol.groupAnagramsNaive(test_set[i]))) print("tested correct") print("time test") print("new:") start = time.time() for set_of_words in test_set: sol.groupAnagrams(set_of_words) end = time.time() print(str(end - start)) print("old:") start = time.time() for set_of_words in test_set: sol.groupAnagrams_old(set_of_words) end = time.time() print(str(end - start))
def test_stress(self): enabled = True if not enabled: return sol = main.Solution() max_size = 10 n_checks = 10000 max_val = 200 test_set = list() # build test sets for i in range(n_checks): this_size = random.randint(0, max_size) this_array = list() for j in range(this_size): this_row = list() for k in range(this_size): this_row.append(random.randint(0, max_val)) this_array.append(this_row) test_set.append(this_array) print("built " + str(len(test_set)) + " sets") copy_set = copy.deepcopy(test_set) # copy_two = copy.deepcopy(test_set) for i in range(n_checks): sol.rotate(test_set[i]) sol.naive_rotate(copy_set[i]) self.assertEqual(test_set[i], copy_set[i]) print("tested correct") print("time test") print("mine:") start = time.time() for matrix in test_set: sol.rotate(matrix) end = time.time() print(str(end - start)) print("naive:") start = time.time() for matrix in test_set: sol.naive_rotate(matrix) end = time.time() print(str(end - start))
def test_rotate(self): sol = main.Solution() in_matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] expected = [ [7, 4, 1], [8, 5, 2], [9, 6, 3] ] sol.rotate(in_matrix) self.assertEqual(in_matrix, expected) in_matrix = [ [1, 2, 3, 7], [4, 5, 6, 7], [7, 8, 9, 7], [10, 11, 12, 7] ] expected = [ [10, 7, 4, 1], [11, 8, 5, 2], [12, 9, 6, 3], [7, 7, 7, 7] ] sol.rotate(in_matrix) self.assertEqual(in_matrix, expected) in_matrix = [ [1] ] expected = [ [1] ] sol.rotate(in_matrix) self.assertEqual(in_matrix, expected) in_matrix = [ [] ] expected = [ [] ] sol.rotate(in_matrix) self.assertEqual(in_matrix, expected)
def test_stress(self): enabled = True if not enabled: return sol = main.Solution() # get two lists of positive numbers non-repeating source = [i for i in range(200)] max_size = 5 n_checks = 10 test_set = list() # build test sets for i in range(n_checks): random.shuffle(source) this_size = random.randint(0, max_size) test_set.append(source[:this_size]) print("built " + str(len(test_set)) + " sets") for nums in test_set: #print(str(nums)) result = sol.permute(nums) result_cheat = sol.permute_cheat(nums) self.assertTrue(self.tool_check_result(nums, result), str(nums)) self.assertTrue(self.tool_check_result(nums, result_cheat)) print("tested correct") print("time test") print("mine") start = time.time() for nums in test_set: sol.permute(nums) end = time.time() print(str(end - start)) print("python's:") start = time.time() for nums in test_set: sol.permute_cheat(nums) end = time.time() print(str(end - start))
def test_stress(self): enabled = True if not enabled: return sol = main.Solution() max_size = 8 n_checks = 100 max_val = 200 test_set = list() # build test sets for i in range(n_checks): this_size = random.randint(0, max_size) this_list = list() for j in range(this_size): this_list.append(random.randint(0, 200)) test_set.append(this_list) print("built " + str(len(test_set)) + " sets") for nums in test_set: #print(str(nums)) result = sol.permute(nums) result_cheat = sol.permute_cheat(nums) self.assertTrue(self.tool_check_result(result_cheat, result), str(nums)) print("tested correct") print("time test") print("mine") start = time.time() for nums in test_set: sol.permute(nums) end = time.time() print(str(end - start)) print("python's:") start = time.time() for nums in test_set: sol.permute_cheat(nums) end = time.time() print(str(end - start))
def test_stress(self): enabled = True if not enabled: return sol = main.Solution() min_x = -100 max_x = 100 min_n = pow(-2, 31) max_n = pow(2, 31) - 1 n_checks = 10000 test_set = list() # build test sets for i in range(n_checks): x = random.random() * (max_n - min_n) + min_n n = random.randint(min_n, max_n) test_set.append((x, n)) print("built " + str(len(test_set)) + " sets") for i in range(n_checks): r1 = sol.myPow(test_set[i][0], test_set[i][1]) r2 = sol.built_in_pow(test_set[i][0], test_set[i][1]) if r2: self.assertAlmostEqual(r1, r2) print("tested correct") print("time test") print("mine:") start = time.time() for pair in test_set: sol.myPow(pair[0], pair[1]) end = time.time() print(str(end - start)) print("built in:") start = time.time() for pair in test_set: sol.built_in_pow(pair[0], pair[1]) end = time.time() print(str(end - start))
def test_split_at_shift(self): sol = main.Solution() num = [1, 2, 3] shift = 1 high_expected = [2, 3] low_expected = [1] high_result, low_result = sol.split_at_shift(num, shift) self.assertEqual(high_expected, high_result) self.assertEqual(low_expected, low_result) num = [1, 2, 3] shift = 2 high_expected = [3] low_expected = [1, 2] high_result, low_result = sol.split_at_shift(num, shift) self.assertEqual(high_expected, high_result) self.assertEqual(low_expected, low_result)
def test_add_to(self): sol = main.Solution() base = [9] to_add = [6, 8] shift = 0 expected = [5, 9] sol.add_to(base, to_add, shift) self.assertEqual(expected, base) base = [1, 0, 0] to_add = [5] shift = 1 expected = [1, 5, 0] sol.add_to(base, to_add, shift) self.assertEqual(expected, base) base = [1, 9, 9] to_add = [2] shift = 0 expected = [3, 9, 9] sol.add_to(base, to_add, shift) self.assertEqual(expected, base) base = [1, 2, 3, 4] to_add = [3, 2] shift = 1 expected = [1, 5, 5, 4] sol.add_to(base, to_add, shift) self.assertEqual(expected, base) base = [1, 2] to_add = [3, 2] shift = 1 expected = [1, 5, 2] sol.add_to(base, to_add, shift) self.assertEqual(expected, base) base = [9, 9, 9, 9] to_add = [1] shift = 1 expected = [9, 0, 0, 0, 1] sol.add_to(base, to_add, shift) self.assertEqual(expected, base)
def test_spiralOrder(self): sol = main.Solution() n = [2, 3, 1, 1, 4] expected = True result = sol.canJump(n) self.assertEqual(expected, result) n = [3, 2, 1, 0, 4] expected = False result = sol.canJump(n) self.assertEqual(expected, result) n = [1, 0, 2, 3] expected = False result = sol.canJump(n) self.assertEqual(expected, result) n = [3, 0, 1, 2] expected = True result = sol.canJump(n) self.assertEqual(expected, result) n = [1, 1, 1, 1] expected = True result = sol.canJump(n) self.assertEqual(expected, result) n = [2, 1, 0, 1] expected = False result = sol.canJump(n) self.assertEqual(expected, result) n = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1, 0, 0] expected = False result = sol.canJump(n) self.assertEqual(expected, result) n = [2, 5, 0, 0] expected = True result = sol.canJump(n) self.assertEqual(expected, result)
def test_myPow(self): sol = main.Solution() x = 2 n = 10 expected = 1024 result = sol.myPow(x, n) self.assertAlmostEqual(expected, result) x = 2.1 n = 3 expected = 9.261 result = sol.myPow(x, n) self.assertAlmostEqual(expected, result) x = 2 n = -2 expected = 0.25 result = sol.myPow(x, n) self.assertAlmostEqual(expected, result)
def test_solution(self): sol = main.Solution() nums = list() expected = len(nums) result = expected # example 1 nums = list([1, 2, 0]) expected = 3 result = sol.firstMissingPositive(nums) self.assertEqual(expected, result) # example 2 nums = list([3, 4, -1, 1]) expected = 2 result = sol.firstMissingPositive(nums) self.assertEqual(expected, result) # example 3 nums = list([7, 8, 9, 11, 12]) expected = 1 result = sol.firstMissingPositive(nums) self.assertEqual(expected, result) # all neg nums = list([-4, -8, -1, 0]) expected = 1 result = sol.firstMissingPositive(nums) self.assertEqual(expected, result) # repeats nums = list([1, 1, 1, 1]) expected = 2 result = sol.firstMissingPositive(nums) self.assertEqual(expected, result) # repeats nums = list([1, 1, 2, 1, 4]) expected = 3 result = sol.firstMissingPositive(nums) self.assertEqual(expected, result)
def place_random(data, window_width, window_height): """ Testing method, places rectangles in random places :param data: :param window_width: :param window_height: :return: """ rectangles = data.data placed_rectangles = [] for rect in rectangles: width = rect[1] height = rect[2] x_pos = randint(0, window_width - width) y_pos = randint(0, window_height - height) id = rect[0] placed_rectangles.append((id, x_pos, y_pos, width, height)) return main.Solution(placed_rectangles)
def test_int_array_to_string(self): sol = main.Solution() array = list([3, 1, 0, 0]) expected = "13" result = sol.int_array_to_string(array) self.assertEqual(expected, result) array = list([0]) expected = "0" result = sol.int_array_to_string(array) self.assertEqual(expected, result) array = list([3]) expected = "3" result = sol.int_array_to_string(array) self.assertEqual(expected, result) array = list([1, 0, 1, 3]) expected = "3101" result = sol.int_array_to_string(array) self.assertEqual(expected, result)
def test_spiralOrder(self): sol = main.Solution() n = [[1, 3], [2, 6], [8, 10], [15, 18]] expected = [[1, 6], [8, 10], [15, 18]] result = sol.merge(n) self.assertEqual(expected, result) n = [[1, 4], [4, 5]] expected = [[1, 5]] result = sol.merge(n) self.assertEqual(expected, result) n = [[1, 20], [2, 3], [5, 6]] expected = [[1, 20]] result = sol.merge(n) self.assertEqual(expected, result) n = [[1, 20], [2, 3], [5, 6], [22, 23]] expected = [[1, 20], [22, 23]] result = sol.merge(n) self.assertEqual(expected, result)
def bottom_left_fill(data, width, upperbound, debug_mode=False, buffer=0): """ Bottom left fill, places data inside the dimensions defined by width and upperbound :param data: :param width: :param upperbound: :param debug_mode: :param buffer: :return: """ free_area = _create_rectangle(0, 0, width, upperbound) # set available area total_area = _create_rectangle(0, 0, width, upperbound) solns = [] for i in data.data: i_id = i[0] i_w = i[1] + buffer i_h = i[2] + buffer poly_rep = Polygon.Shapes.Rectangle(i_w, i_h) # polygon representation of this shape, floating in space if debug_mode: #debugging method, step through placing one rectangle at a time x, y, triangles = no_fill_polygon(total_area, free_area, poly_rep, debug_mode=debug_mode) free_area = free_area - _create_rectangle(x, y, i_w, i_h) # calculate new free area free_area.simplify() filled_area = total_area - free_area view.view_debug(solns, triangles, filled_area, width, upperbound) else: x, y = no_fill_polygon(total_area, free_area, poly_rep, debug_mode=debug_mode) # calculate position of polygon free_area = free_area - _create_rectangle(x, y, i_w, i_h) # calculate new free area free_area.simplify() filled_area = total_area - free_area solns.append((i_id, x, y, i_w - buffer, i_h - buffer)) # add soln return main.Solution(solns)
def test_solution(self): sol = main.Solution() candidates = list() expected = list() result = list() target = 0 candidates = list([6, 3, 2, 7]) target = 7 expected = list([ list([2, 2, 3]), list([7]) ]) result = sol.combinationSum(candidates, target) self.assertEqual(expected, result) candidates = list([2, 3, 5]) target = 8 expected = list([ list([2, 2, 2, 2]), list([2, 3, 3]), list([3, 5]) ]) result = sol.combinationSum(candidates, target) self.assertEqual(expected, result) candidates = list([2, 3, 5]) target = 1 expected = list() result = sol.combinationSum(candidates, target) self.assertEqual(expected, result) candidates = list([2, 3, 5]) target = 3 expected = list([ list([3]), ]) result = sol.combinationSum(candidates, target) self.assertEqual(expected, result)