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)