import unittest
import utils
class TestMain(unittest.TestCase):
def setUp(self):
'''before each test function'''
pass
def tearDown(self):
'''after each test function'''
pass
def do(self, func):
n = [1, 1, 2]
self.assertEqual(func(n), 2)
self.assertEqual(n[0:2], [1, 2])
n = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
self.assertEqual(func(n), 5)
self.assertEqual(n[0:5], [0, 1, 2, 3, 4])
def test_func(self):
self.do(removeDuplicates)
if __name__ == "__main__":
count = 10000
nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
utils.print_func_run_time(count, removeDuplicates, nums=nums)
unittest.main()
def do(self, func):
self.assertTrue(func(121))
self.assertTrue(func(0))
self.assertTrue(func(6))
self.assertTrue(func(11))
def test_func1(self):
self.do(isPalindrome1)
def test_func2(self):
self.do(isPalindrome2)
if __name__ == "__main__":
count = 100000
utils.print_func_run_time(count, isPalindrome1, x = 123454321)
utils.print_func_run_time(count, isPalindrome2, x = 123454321)
unittest.main()
# ..
# ----------------------------------------------------------------------
# Ran 2 tests in 0.000s
#
# OK
# isPalindrome1 run 100000 times used 0.142989s
# isPalindrome2 run 100000 times used 0.143997s
# ..
# ----------------------------------------------------------------------
# Ran 2 tests in 0.000s
#
self.assertEqual(func(nums), -1)
nums = [1, 2]
self.assertEqual(func(nums), 3)
nums = [1, 1, -2]
self.assertEqual(func(nums), 2)
nums = [3, 1, -3, -3, 2, -1]
self.assertEqual(func(nums), 4)
nums = [8, -19, 5, -4, 20]
self.assertEqual(func(nums), 21)
nums = [2, 0, -3, 2, 1, 0, 1, -2]
self.assertEqual(func(nums), 4)
# for nums in TEST_LISTS:
# self.assertEqual(s.maxSubArray2(nums), func(nums))
def test_func(self):
s = Solution()
self.do(s.maxSubArray4)
self.do(s.maxSubArray3)
self.do(s.maxSubArray2)
self.do(s.maxSubArray1)
if __name__ == "__main__":
count = 100
tm = TestMain()
utils.print_func_run_time(count, s.maxSubArray2, nums=NUMS_FOR53)
utils.print_func_run_time(count, s.maxSubArray3, nums=NUMS_FOR53)
utils.print_func_run_time(count, s.maxSubArray4, nums=NUMS_FOR53)
# utils.print_func_run_time1(count, tm.do, s.maxSubArray3)
unittest.main()
pass
def do(self, func):
nums = [1, 8, 6, 2, 5, 4, 8, 3, 7]
self.assertEqual(func(nums), 49)
nums = [1]
self.assertEqual(func(nums), 0)
nums = [1, 2]
self.assertEqual(func(nums), 1)
nums = [1, 2, 3]
self.assertEqual(func(nums), 2)
nums = [1, 8, 3, 4]
self.assertEqual(func(nums), 8)
nums = [1, 1, 1, 4]
self.assertEqual(func(nums), 3)
def test_func(self):
self.do(s.maxArea2)
self.do(s.maxArea1)
self.do(s.maxArea)
if __name__ == "__main__":
count = 10000
nums = [1, 8, 6, 2, 5, 4, 8, 3, 7]
utils.print_func_run_time(count, s.maxArea1, height=nums)
utils.print_func_run_time(count, s.maxArea2, height=nums)
utils.print_func_run_time(count, s.maxArea, height=nums)
unittest.main()
res = []
while i < n:
res.append(i)
return res
import utils
import unittest
class TestMain(unittest.TestCase):
def setUp(self):
'''before each test function'''
pass
def tearDown(self):
'''after each test function'''
pass
def test_func(self):
n = 100
self.assertEqual(loop_for(n), loop_while(n))
if __name__ == "__main__":
count = 1000
n = 1000
utils.print_func_run_time(count, loop_for, n=n)
utils.print_func_run_time(count, loop_while, n=n)
unittest.main()
def setUp(self):
'''before each test function'''
pass
def tearDown(self):
'''after each test function'''
pass
def do(self, func):
self.assertEqual(func("adbabcbb"), 3)
self.assertEqual(func("bbbbb"), 1)
self.assertEqual(func("pwwkew"), 3)
self.assertEqual(func(" "), 1)
self.assertEqual(func("aab"), 2)
self.assertEqual(func("dvdf"), 3)
self.assertEqual(func("aabaab!bb"), 3)
def test_func1(self):
self.do(lengthOfLongestSubstring1)
def test_func2(self):
self.do(lengthOfLongestSubstring2)
if __name__ == "__main__":
count = 10000
utils.print_func_run_time(count, lengthOfLongestSubstring1, s = "aabaab!bb")
utils.print_func_run_time(count, lengthOfLongestSubstring2, s = "aabaab!bb")
unittest.main()
def loop_list_compre(n):
res = [abs(i) for i in range(n)]
return res
def loop_map(n):
return map(abs, range(n))
import utils
if __name__ == "__main__":
count = 1000
n = 1000
gen_res = loop_generator(10)
map_res = loop_map(10)
list_res = loop_list_compre(10)
# print(isinstance(loop_list_compre(10), Iterable))
# print(isinstance(map_res, Generator))
# print(isinstance(map_res, Iterator))
# print(isinstance(list_res, Iterator))
utils.print_func_run_time(count, loop_list_compre, n=n)
utils.print_func_run_time(count, loop_map, n=n)
utils.print_func_run_time(count, loop_generator, n=n)
# loop_list_compre run 1000 times used 0.08865494900237536s
# loop_map run 1000 times used 0.0007684140000492334s
# loop_generator run 1000 times used 0.0009459810025873594s
import unittest
class TestMain(unittest.TestCase):
def setUp(self):
'''before each test function'''
pass
def tearDown(self):
'''after each test function'''
pass
def do(self, func):
'''todo'''
res = [1, 4, 6, 4, 1]
self.assertEqual(func(4), res)
pass
def test_func(self):
self.do(s.generate)
# self.do(s.generate1)
if __name__ == "__main__":
import utils
count = 100
utils.print_func_run_time(count, s.generate, numRows=100)
# utils.print_func_run_time(count, s.generate1, numRows = 100)
unittest.main()
'''before each test function'''
pass
def tearDown(self):
'''after each test function'''
pass
def do(self, func):
self.assertFalse(func("[)"))
self.assertTrue(func("[]"))
self.assertTrue(func(""))
self.assertTrue(func("()[]{}"))
self.assertFalse(func("[()"))
self.assertFalse(func("(])"))
self.assertFalse(func("([)])"))
self.assertFalse(func("(()("))
self.assertFalse(func("([)]"))
self.assertFalse(func("]"))
self.assertFalse(func("()]"))
self.assertTrue(func("{[]}"))
self.assertTrue(func("(([]){})"))
def test_func1(self):
self.do(isValid)
if __name__ == "__main__":
import utils
count = 10000
utils.print_func_run_time(count, isValid, s = "(([]){})")
unittest.main()
listNodeToArray(func(makeListNode([]), makeListNode([]))), [])
self.assertEqual(
listNodeToArray(func(makeListNode([2]), makeListNode([1]))),
[1, 2])
def test_func(self):
self.do(mergeTwoLists)
self.do(mergeTwoLists1)
self.do(mergeTwoLists2)
self.do(mergeTwoLists3)
if __name__ == "__main__":
count = 10000
utils.print_func_run_time(count,
mergeTwoLists,
l1=makeListNode([2, 3, 4, 7, 8, 9]),
l2=makeListNode([4, 5]))
utils.print_func_run_time(count,
mergeTwoLists1,
l1=makeListNode([2, 3, 4, 7, 8, 9]),
l2=makeListNode([4, 5]))
utils.print_func_run_time(count,
mergeTwoLists2,
l1=makeListNode([2, 3, 4, 7, 8, 9]),
l2=makeListNode([4, 5]))
utils.print_func_run_time(count,
mergeTwoLists3,
l1=makeListNode([2, 3, 4, 7, 8, 9]),
l2=makeListNode([4, 5]))
unittest.main()
'''before each test function'''
pass
def tearDown(self):
'''after each test function'''
pass
def test_func(self):
items = make_data(10)
flag = (loop_list_compre(items) == loop_map(items))
self.assertTrue(flag)
if __name__ == "__main__":
count = 1000
n = 1000
items = make_data(1000)
utils.print_func_run_time(count, loop_list_compre, items = items)
utils.print_func_run_time(count, loop_map, items = items)
unittest.main()
# .
# ----------------------------------------------------------------------
# Ran 1 test in 0.000s
#
# OK
# loop_for run 1000 times used 0.14018906400087872s
# loop_while run 1000 times used 0.21399457900042762s
# loop_generator run 1000 times used 0.12857274799898732s
# loop_list_compre run 1000 times used 0.08585307099929196s
# loop_map run 1000 times used 0.043123570998432115s
class TestMain(unittest.TestCase):
def setUp(self):
'''before each test function'''
pass
def tearDown(self):
'''after each test function'''
pass
def do(self, func):
self.assertEqual(func(1), 1)
self.assertEqual(func(2), 2)
self.assertEqual(func(3), 3)
self.assertEqual(func(4), 5)
def test_func(self):
self.do(s.climbStairs)
self.do(s.climbStairs1)
self.do(s.climbStairs2)
if __name__ == "__main__":
count = 1
# utils.print_func_run_time(count, s.climbStairs, n = 38)
utils.print_func_run_time(count, s.climbStairs1, n=10000)
utils.print_func_run_time(count, s.climbStairs2, n=10000)
unittest.main()
def tearDown(self):
'''after each test function'''
pass
def do(self, func):
n = [3,2,2,3]
self.assertEqual(func(n, 3), 2)
# self.assertEqual(n[0:2], [2, 2])
n = [0,1,2,2,3,0,4,2]
self.assertEqual(func(n, 2), 5)
# self.assertEqual(n[0:5], [0, 1, 3, 0, 4])
n = [2]
self.assertEqual(func(n, 3), 1)
# self.assertEqual(n[0:1], [2])
n = [3, 3]
self.assertEqual(func(n, 5), 2)
# self.assertEqual(n[0:2], [3, 3])
def test_func(self):
self.do(removeElement)
self.do(removeElement1)
self.do(removeElement2)
if __name__ == "__main__":
count = 10000
nums = [0,1,2,2,3,0,4,2]
utils.print_func_run_time(count, removeElement, nums = nums, val = 2)
utils.print_func_run_time(count, removeElement1, nums = nums, val = 2)
utils.print_func_run_time(count, removeElement2, nums = nums, val = 2)
unittest.main()
def tearDown(self):
'''after each test function'''
pass
def do(self, func):
'''todo'''
self.assertEqual(func("hello", "ll"), 2)
self.assertEqual(func("aaaaa", "bba"), -1)
self.assertEqual(func("aaaac", "aac"), 2)
pass
def test_func(self):
self.do(s.strStr)
self.assertEqual(s.make_prefix("abc"), [-1, 0, 0])
self.assertEqual(s.make_prefix("aac"), [-1, 0, 1])
self.assertEqual(s.make_prefix("ababc"), [-1, 0, 0, 1, 2])
if __name__ == "__main__":
count = 100000
t = "ababcabcde"
p = "abcd"
utils.print_func_run_time(count, s.strStr, t = t, p = p)
b = timeit.default_timer()
for i in range(count):
t.index(p)
print(timeit.default_timer() - b)
unittest.main()
# # print(name, func.)
# funcs = (bubble_sort, selection_sort, insertion_sort, quick_sort,
# quick_sort_3partition, heap_sort, merge_sort, merge_sort_fastest,
# counting_sort, bucket_sort, bucket_sort_array, radix_sort)
times = []
# for f in funcs:
# n, t = utils.print_func_run_time(length, f, utils.generate_random(int(n))[0])
# # times.append((n, t))
# # times.sort(key = lambda x: x[1])
# # for n, t in times:
# # print(n, t)
times.append(
utils.print_func_run_time(length, bubble_sort,
utils.generate_random(n)[0]))
times.append(
utils.print_func_run_time(length, selection_sort,
utils.generate_random(n)[0]))
times.append(
utils.print_func_run_time(length, insertion_sort,
utils.generate_random(n)[0]))
times.append(
utils.print_func_run_time(length, quick_sort,
utils.generate_random(n)[0]))
times.append(
utils.print_func_run_time(length, quick_sort_3partition,
utils.generate_random(n)[0]))
times.append(
utils.print_func_run_time(length, heap_sort,
utils.generate_random(n)[0]))
pass
def do(self, func):
self.assertEqual(func("42"), 42)
self.assertEqual(func(" -42"), -42)
self.assertEqual(func("4193 with words"), 4193)
self.assertEqual(func("words and 987"), 0)
self.assertEqual(func(" +0 123"), 0)
self.assertEqual(func("+-2"), 0)
self.assertEqual(func("0-1"), 0)
self.assertEqual(func("-91283472332"), MIN)
self.assertEqual(func("912834723320"), MAX)
self.assertEqual(func(" 0000000000012345678"), 12345678)
self.assertEqual(func("-000000000000001"), -1)
self.assertEqual(func(" -0012a42"), -12)
self.assertEqual(func("- 234"), 0)
self.assertEqual(func(" -88827 5655 U"), -88827)
def test_func(self):
self.do(myAtoi1)
self.do(myAtoi2)
if __name__ == "__main__":
import utils
count = 1000
utils.print_func_run_time(count, myAtoi1, s="4193 with words")
utils.print_func_run_time(count, myAtoi2, s="4193 with words")
unittest.main()
