def test():
solution = Solution()
for case, ans in [
([
"bbbbbabbbbabaababaaaabbababbaaabbabbaaabaaaaababbbababbbbbabbbbababbabaabababbbaabababababbbaaababaa",
"babaaaabbababbbabbbbaabaabbaabbbbaabaaabaababaaaabaaabbaaabaaaabaabaabbbbbbbbbbbabaaabbababbabbabaab",
"babbbabbbaaabbababbbbababaabbabaabaaabbbbabbbaaabbbaaaaabbbbaabbaaabababbaaaaaabababbababaababbababbbababbbbaaaabaabbabbaaaaabbabbaaaabbbaabaaabaababaababbaaabbbbbabbbbaabbabaabbbbabaaabbababbabbabbab"
], False),
(['ef', 'gh', 'ehgf'], False),
(['', '', ''], True),
(['', 'a', 'a'], True),
(['a', '', 'a'], True),
(['a', '', 'b'], False),
(['xyz', '', 'xyz'], True),
(['xyz', 'xyz', 'xyz' * 2], True),
(['xyz', 'xyz', 'xxyzyz'], True),
(['xyaaaaaz', 'xaaaaayz', 'xxyaaaaazaaaaayz'], True),
(['aabcc', 'dbbca', 'aadbbcbcac'], True),
(['aabcc', 'dbbca', 'aadbbbaccc'], False),
(['a' * 100000, 'a' * 100000, 'a' * 200000], True),
(['a' * 100000, 'b' * 100000, 'a' * 100000 + 'b' * 100000], True),
([
'a' * 100000, 'b' * 100000,
''.join(random.sample('a' * 100000 + 'b' * 100000, 200000))
], True),
]:
res = solution.isInterleave(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
for case, ans in [
]:
res = function(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
words = ['apple']
obj = WordFilter(words)
for case, ans in [
(('a', 'e'), 0),
(('b', ''), -1),
]:
res = obj.f(*case)
assert res == ans, fail_string(res=res, ans=ans)
def test_long():
words = ['apple', 'ape', 'ae', '']
obj = WordFilter(words)
for case, ans in [
(('a', 'e'), 2),
(('', ''), 3),
]:
res = obj.f(*case)
assert res == ans, fail_string(res=res, ans=ans)
def test():
solution = Solution()
for case in [100, 1000, 10000]:
print case
res = solution.countPrimes(case)
ans = len(filter(is_a_prime, range(case)))
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
for case in range(1, 1000):
for bad in range(1, case):
solution = Solution(bad)
ans = bad
res = solution.firstBadVersion(case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
for case, ans in [
([[3, 6, 1, 0]], 1),
([[1, 2, 3, 4]], -1),
([[0, 0, 3, 2]], -1),
]:
res = twice(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test_leet():
null = 'null'
for input2, output in [[[[["pop"]], ["", ""], ["", "p"], ["", "op"],
["", "pop"], ["p", ""], ["p", "p"], ["p", "op"],
["p", "pop"], ["po", ""], ["po", "p"],
["po", "op"], ["po", "pop"], ["pop", ""],
["pop", "p"], ["pop", "op"], ["pop", "pop"],
["", ""], ["", "p"], ["", "gp"], ["", "pgp"],
["p", ""], ["p", "p"], ["p", "gp"], ["p", "pgp"],
["pg", ""], ["pg", "p"], ["pg", "gp"],
["pg", "pgp"], ["pgp", ""], ["pgp", "p"],
["pgp", "gp"], ["pgp", "pgp"]],
[
null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, -1, -1, 0, 0, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1
]],
[[[[
"abbbababbb", "baaabbabbb", "abababbaaa",
"abbbbbbbba", "bbbaabbbaa", "ababbaabaa",
"baaaaabbbb", "babbabbabb", "ababaababb",
"bbabbababa"
]], ["", "abaa"], ["babbab", ""], ["ab", "baaa"],
["baaabba", "b"], ["abab", "abbaabaa"],
["", "aa"], ["", "bba"], ["", "baaaaabbbb"],
["ba", "aabbbb"], ["baaa", "aabbabbb"]],
[null, 5, 7, 2, 1, 5, 5, 3, 6, 6, 1]]]:
obj = WordFilter(input2[0][0])
prefix_suffix = input2[1:]
ans_array = output[1:]
for case, ans in zip(prefix_suffix, ans_array):
res = obj.f(*case)
try:
assert res == ans
except AssertionError as e:
print case
print fail_string(res=res, ans=ans)
sys.exit(0)
def test():
for case, ans in [
([["0201","0101","0102","1212","2002"], "0202"], 6),
([["8888"], "0009"], 1),
([["8887","8889","8878","8898","8788","8988","7888","9888"], "8888"], -1),
([["1002","1220","0122","0112","0121"], "1200"], 3),
]:
res = turn(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test1():
solution = Solution()
for case, ans in [
(['', ''], 0),
(['a', 'aaa'], 3),
(['aA', 'aAAbbbb'], 3),
(['z', 'ZZ'], 0),
]:
res = solution.numJewelsInStones(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
([1, 1, 3, 5], True),
([1, 1, 2, 2], False),
([1, 1, 1, 1], True),
([1, 2, 39, 17], True),
]:
res = solution.reachingPoints(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test_exhausted():
solution = Solution()
n = 10**5
ans_array = brute_force_array(n)
for k in range(1, n + 1):
res = solution.findKthNumber(n, k)
ans = ans_array[k - 1].strip()
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=(n, k))
sys.exit(status)
print 'Test {}: n={:<8} k={:<8} ans={:<8} passed!'.format(k, n, k, ans)
def test():
for case, ans in [
(['(()(()(()'], 2),
(['(()'], 2),
(["))))())()()(()"], 4),
(["()(()"], 2),
(["(()"], 2),
([')()())'], 4),
]:
res = longest_parentheses(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test3():
solution = Solution()
for c in range(1000):
case = generate_random_nk(random.randint(1, 10**5 + 1))
res = solution.findKthNumber(*case)
ans = str(brute_force(*case))
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
print 'Test {}: n={:<8} k={:<8} ans={:<8} passed!'.format(
c, case[0], case[1], ans)
def test():
solution = Solution()
for case, ans in [
('0P', False),
('', True),
('1', True),
("A man, a plan, a canal: Panama", True),
('race a car', False),
]:
res = solution.isPalindrome(case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
([[9, 5, 6, 2, 4, 3, 6, 2],
[5, 7, 6, 2, 2, 1, 3, 0, 2, 8, 9, 7, 7, 3, 2, 2, 9, 4, 5, 1], 28], [
9, 5, 7, 6, 5, 6, 2, 4, 3, 6, 2, 2, 2, 1, 3, 0, 2, 8, 9, 7, 7, 3,
2, 2, 9, 4, 5, 1
]),
([[
4, 6, 9, 1, 0, 6, 3, 1, 5, 2, 8, 3, 8, 8, 4, 7, 2, 0, 7, 1, 9, 9,
0, 1, 5, 9, 3, 9, 3, 9, 7, 3, 0, 8, 1, 0, 9, 1, 6, 8, 8, 4, 4, 5,
7, 5, 2, 8, 2, 7, 7, 7, 4, 8, 5, 0, 9, 6, 9, 2
],
[
9, 9, 4, 5, 1, 2, 0, 9, 3, 4, 6, 3, 0, 9, 2, 8, 8, 2, 4, 8, 6, 5,
4, 4, 2, 9, 5, 0, 7, 3, 7, 5, 9, 6, 6, 8, 8, 0, 2, 4, 2, 2, 1, 6,
6, 5, 3, 6, 2, 9, 6, 4, 5, 9, 7, 8, 0, 7, 2, 3
], 60], [
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 6, 8, 8, 4, 4, 5, 7,
5, 2, 8, 2, 7, 7, 7, 4, 8, 5, 0, 9, 6, 9, 2, 0, 2, 4, 2, 2, 1, 6,
6, 5, 3, 6, 2, 9, 6, 4, 5, 9, 7, 8, 0, 7, 2, 3
]),
([[8, 9], [3, 9], 3], [9, 8, 9]),
([[1, 6, 5, 4, 7, 3, 9, 5, 3, 7, 8, 4, 1, 1, 4], [4, 3, 1, 3, 5, 9],
21], [4, 3, 1, 6, 5, 4, 7, 3, 9, 5, 3, 7, 8, 4, 1, 3, 5, 9, 1, 1,
4]),
([[8, 9, 3, 9, 8, 9, 3, 9], [3, 9, 8, 9, 3, 9, 8, 9],
9], [9, 9, 9, 9, 9, 9, 9, 8, 9]),
([[1, 1, 9], [1, 1, 9], 3], [9, 1, 9]),
([
random.sample(range(100000), 100000),
random.sample(range(100000), 100000), 20
], True),
# ([random.sample(range(100000), 100000), random.sample(range(100000), 100000), 100000], True),
([[1, 2, 9, 3], [1, 2, 9, 3], 2], [9, 9]),
([[1, 2, 9, 3], [], 2], [9, 3]),
([[], [1, 2, 9, 3], 2], [9, 3]),
([[3, 4, 6, 5], [9, 1, 2, 5, 8, 3], 5], [9, 8, 6, 5, 3]),
([[6, 7], [6, 0, 4], 5], [6, 7, 6, 0, 4]),
([[8, 8, 8], [8, 8, 8, 8], 7], [8, 8, 8, 8, 8, 8, 8]),
]:
res = solution.maxNumber(*case)
if ans is not True:
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in []:
res = solution.solve(*case)
if ans is True:
# we just want to test the algorithm on random inputs
print res
continue
if ans is None:
# we have a bruteforce algorithm to test against
ans = bruteforce
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
([[1, 2, 5, 6], [3, 4]], 3.5),
([[472, 490, 503, 515, 532, 539, 544, 548, 549, 555],
[482, 500, 510, 531, 537, 538, 550, 565, 579, 590]], -1),
([[
20, 34, 36, 37, 40, 42, 52, 61, 90, 98, 99, 109, 156, 165, 173,
174, 196, 199, 213, 238, 247, 279, 286, 292, 306, 309, 313, 321,
322, 331, 337, 342, 346, 357, 365, 385, 403, 414, 444, 446, 447,
454, 461, 464, 467, 472, 490, 503, 515, 532, 539, 544, 548, 549,
555, 567, 577, 591, 594, 599, 609, 624, 629, 641, 661, 663, 670,
672, 674, 711, 716, 725, 783, 786, 789, 804, 807, 823, 831, 840,
842, 850, 857, 859, 865, 872, 873, 898, 906, 943, 947, 953, 954,
964, 971, 972, 987, 989, 990, 993
],
[
25, 45, 51, 58, 59, 60, 65, 75, 82, 102, 105, 133, 166, 171, 179,
183, 209, 237, 240, 241, 244, 250, 251, 267, 289, 290, 299, 316,
325, 353, 363, 373, 376, 384, 387, 404, 407, 409, 414, 416, 421,
448, 455, 459, 465, 482, 500, 510, 531, 537, 538, 550, 565, 579,
590, 591, 599, 608, 615, 623, 636, 637, 638, 644, 661, 662, 667,
675, 677, 687, 700, 704, 731, 745, 787, 799, 802, 818, 837, 845,
862, 875, 877, 883, 899, 905, 912, 922, 923, 928, 931, 947, 954,
956, 959, 964, 979, 992, 998, 999
]], -1),
([sample_nums(10000), sample_nums(10000)], -1),
([sample_nums(10), sample_nums(3)], -1),
# ([sample_nums(10000), sample_nums(1)], -1),
([[1, 3], [2]], 2),
([[1, 2], [3, 4]], 2.5),
([[4, 6, 8, 10, 12], [9]], 8.5),
([[4, 6, 8, 10, 12], [13]], 9),
([[4, 6, 8, 10, 12], [5, 7, 9, 11, 13]], 8.5),
([[4, 6, 8], [5, 7, 9]], 6.5),
([[4, 6, 8, 10], [5, 7, 9]], 7),
]:
res = solution.findMedianSortedArrays(*case)
try:
if ans == -1:
ans = brute_median_of_2(*case)
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
for case, ans in [
([1000], 'One Thousand'),
([20], 'Twenty'),
([0], "Zero"),
([100], "One Hundred"),
([123], "One Hundred Twenty Three"),
([12345], "Twelve Thousand Three Hundred Forty Five"),
([1234567],
"One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
),
]:
res = int_to_words(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
(["aabba"], "abbaabba"),
(['aea'], 'aea'),
(['a'], 'a'),
([''], ''),
(['aacecaaa'], 'aaacecaaa'),
(['abcd'], 'dcbabcd'),
(['xxx'*1000 + 'y' + 'xxx'*1000], 'xxx'*1000 + 'y' + 'xxx'*1000),
(['xxx'*1000], 'xxx'*1000),
]:
res = solution.shortestPalindrome(*case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
for case, ans in [
# (['a' * 23, 'a.' * 23 + 'a' * 23], False),
# (["abcde", "*.*.*.*."], True),
# (['c', '.*'], True),
# (['c', '*.'], True),
# (['c', '*.*'], True),
# (['', '.'], False),
# (['', ''], True),
# ([' ', ''], False),
# (["a","a"], True),
# (["bbbb","bbbb"], True),
# (["askdhfpasiudyfhkjshbdkljfhiushdf","askdhfpasiudyfhkjshbdkljfhiushdf"], True),
# (["b","."], True),
# (["skjdfhaskjdhflkjhj","."*len('skjdfhaskjdhflkjhj')], True),
# (["c","*"], True),
# (["","*"], True),
# (["kjsadhflkujhdslfkj","*"], True),
# (['', '**'], True),
# (['a', 'a*'], True),
# (['zl', 'z.*'], True),
# (['zld', 'z.*'], True),
# (['zlahsdklfjh', 'z.*'], True),
(["aa", "a"], False),
(["aa", "aa"], True),
(["aaa", "aa"], False),
(["aa", "a*"], True),
(["aa", ".*"], True),
(["ab", ".*"], True),
(["aab", "c*a*b"], True),
# (["aaaabaaaabbbbaabbbaabbaababbabbaaaababaaabbbbbbaabbbabababbaaabaabaaaaaabbaabbbbaababbababaabbbaababbbba", "*****b*aba***babaa*bbaba***a*aaba*b*aa**a*b**ba***a*a*"], True),
# (["abbabaaabbabbaababbabbbbbabbbabbbabaaaaababababbbabababaabbababaabbbbbbaaaabababbbaabbbbaabbbbababababbaabbaababaabbbababababbbbaaabbbbbabaaaabbababbbbaababaabbababbbbbababbbabaaaaaaaabbbbbaabaaababaaaabb",
# "**aa*****ba*a*bb**aa*ab****a*aaaaaa***a*aaaa**bbabb*b*b**aaaaaaaaa*a********ba*bbb***a*ba*bb*bb**a*b*bb"], False),
# (["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
# "*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*"], False)
]:
string, pattern = case
solution = Solution()
res = solution.isMatch(string, pattern)
try:
assert res == ans
except AssertionError as e:
sys.exit(fail_string(res=res, ans=ans, case=case))
def test():
solution = Solution()
for case, ans in [
(1, 'A'),
(3, 'C'),
(26, 'Z'),
(27, 'AA'),
(28, 'AB'),
(12356630, 'ZZZZZ'),
(5646683826134, 'ZZZZZZZZZ'),
(random.randint(1, BASE_26[-1]), True),
]:
res = solution.convertBaseTheStandardWay(case)
if ans is not True:
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
else:
print 'Convert {} into {}'.format(case, res)
def test():
for case, ans in [
([[1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 1],
[1, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 1]], 15),
([[0, 0], [0, 0]], 0),
([[0]], 0),
([[1, 1, -1], [1, -1, 1], [-1, 1, 1]], 0),
([[0, 1, -1], [1, 0, -1], [1, 1, 1]], 5),
([[1, 1, 1, 0], [1, 0, 0, 1], [0, 1, 0, 1], [1, 1, 1, 0]], 9),
([[1, 1, 1], [1, 0, 1], [1, 1, 0]], 7),
# ([[random.randint(-1, 1) for i in range(100)] for j in range(100)], 100),
]:
# res = pick_cherry(case) # single thread, wrong results
res = pick_2_cherries(case) # dual thread, dual possibilities
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
([[3, 1, 4, 1, 5], 2], 2),
([[1, 2, 3, 4, 5], 1], 4),
([[1, 3, 1, 5, 4], 0], 1),
]:
res = solution.findPairs(*case)
if ans is True:
# we just want to test the algorithm on random inputs
print res
continue
if ans is None:
# we have a bruteforce algorithm to test against
ans = bruteforce
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
for case, ans in [
([[1, -4, 5, -99], [2, -2, -2, -1]], 3),
([[1, 2, 1], [-2, -3, -3], [3, 2, -2]], 1),
([[3, -20, 30], [-3, 4, 0]], 1),
([[-1, 1], [1, 2]], 2),
([[0, -3], [-10, 0]], 4),
([
[-2, -3, 3],
[-5, -10, 1],
[10, 30, -5],
], 7),
([[]], 1),
([[2], [1]], 1),
([[-3, 5]], 4),
]:
res = hp(case)
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
for case, ans in [
(["apjesgpsxoeiokmqmfgvjslcjukbqxpsobyhjpbgdfruqdkeiszrlmtwgfxyfostpqczidfljwfbbrflkgdvtytbgqalguewnhvvmcgxboycffopmtmhtfizxkmeftcucxpobxmelmjtuzigsxnncxpaibgpuijwhankxbplpyejxmrrjgeoevqozwdtgospohznkoyzocjlracchjqnggbfeebmuvbicbvmpuleywrpzwsihivnrwtxcukwplgtobhgxukwrdlszfaiqxwjvrgxnsveedxseeyeykarqnjrtlaliyudpacctzizcftjlunlgnfwcqqxcqikocqffsjyurzwysfjmswvhbrmshjuzsgpwyubtfbnwajuvrfhlccvfwhxfqthkcwhatktymgxostjlztwdxritygbrbibdgkezvzajizxasjnrcjwzdfvdnwwqeyumkamhzoqhnqjfzwzbixclcxqrtniznemxeahfozp"], 452),
(["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], 1),
(['ab'], 1),
([''], 0),
(['aab'], 1),
(['abcdeffedcbaabcdeffedcbbabcdeffedcbaabcdeffedcbeabcdeffedcbaabcdeffedcbbabcdeffedcbaabcdeffedcbeabcdeffedcbaabcdeffedcbbabcdeffedcbaabcdeffedcbe'], 17),
(['abcdeffedcbaabcdeffedcbbabcdeffedcbaabcdeffedcbe'], 5),
(['abcdeffedcbaabcdeffedcbb'], 2),
(['abcdeffedcba'], 0),
(['aabbccbbdedeioie'], 3),
([''.join([random.choice('abcdefghijklmn') for i in range(100)])], True),
([''.join([random.choice('xyz') for i in range(100)])], True),
]:
res = min_cut(*case)
if ans is not True:
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
("aaaaabbbb1234567890ABA", 3),
("aaaabbaaabbaaa123456A", 3),
("AAAAA", 2),
("...", 3),
("..................!!!", 7),
('129dK8l8jjj129dk8l8jl', 1),
('StrongPass0', 0),
('aaaa', 2),
('', 6),
('aaa', 3),
('aaaaaa', 2),
("aaa111", 2),
("ABABABABABABABABABAB1", 2),
("aaaaaaaaaaaaaaaaaaaaa", 7),
("1234567890123456Baaaaa", 3),
]:
res = solution.strongPasswordChecker(case)
assert res == ans, fail_string(res, ans)
def test():
solution = Solution()
for case, ans in [
([
'wordsandmeanings',
['words', 'and', 'meanings', 'wo', 'rds', 'mean', 'ings']
], [
'wo rds and mean ings', 'wo rds and meanings',
'words and mean ings', 'words and meanings'
]),
(["catsanddog", ["cat", "cats", "and", "sand",
"dog"]], ["cats and dog", "cat sand dog"]),
(["catsanddog", ["catsand", "cats", "d", "d",
"og"]], ["catsand d og"]),
(["aaaabbbbccfw", ["a", "b", "c", "w",
"f"]], ["a a a a b b b b c c f w"]),
]:
res = solution.wordBreak(*case)
try:
assert sorted(res) == sorted(ans)
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
([[1, 2, 2]], 4),
([[]], 0),
([[1e6]], 1),
([[1, 100]], 3),
([[1000, 100]], 3),
([[0, 1, 0, 2, 0, 3, 0, 4]], 12),
([[1, 10, 2]], 4),
([[1, 3, 2, 4]], 6),
([[1, 10, 11, 1]], 7),
([[10, 8, 1, 2, 4, 5, 4, 1, 0, -1, -2]], 32),
# ([random.sample(range(100000), 100000)], True),
]:
# print case
res = solution.candy(*case)
if ans is not True:
try:
assert res == ans
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
def test():
solution = Solution()
for case, ans in [
([[["a", "b"], ["a", "a"]],
["aba", "baa", "bab", "aaab", "aaa", "aaaa",
"aaba"]], ["aaa", "aaab", "aaba", "aba", "baa"]),
([[["a", "a"]], ["aaa"]], []),
([["a"], ["a"]], ["a"]),
([[['o', 'a', 'a', 'n'], ['e', 't', 'a', 'e'], ['i', 'h', 'k', 'r'],
['i', 'f', 'l', 'v']], ["aaa", "a", "aa",
"aaakl"]], ['a', 'aa', 'aaakl', 'aaa']),
([[['o', 'a', 'a', 'n'], ['e', 't', 'a', 'e'], ['i', 'h', 'k', 'r'],
['i', 'f', 'l', 'v']], ["aaa", "a", "aa", "aaaao",
"aaaaoe"]], ['a', 'aa', 'aaa']),
([[['o', 'a', 'a', 'n'], ['e', 't', 'a', 'e'], ['i', 'h', 'k', 'r'],
['i', 'f', 'l', 'v']], ["aaa", "aat", "ahk", "erv", "eee",
"eakl"]], ['aat', 'erv', 'eakl', 'aaa']),
([[['o', 'a', 'a', 'n'], ['e', 't', 'a', 'e'], ['i', 'h', 'k', 'r'],
['i', 'f', 'l', 'v']],
["oaan", "oaaa", "oateihkaa", "vlkr",
"vrkl"]], ['vrkl', 'oaaa', 'oaan', 'oateihkaa', 'vlkr']),
([[['o', 'a', 'a', 'n'], ['e', 't', 'a', 'e'], ['i', 'h', 'k', 'r'],
['i', 'f', 'l', 'v']], ["oath", "pea", "eat",
"rain"]], ['oath', 'eat']),
([[['o', 'a', 'a', 'n'], ['e', 't', 'a', 'e'], ['i', 'h', 'k', 'r'],
['i', 'f', 'l', 'v']],
["oath", "oate", "teoa", "rain", "if", "oei", "oaanervlfiie"]],
['oaanervlfiie', 'teoa', 'oate', 'oei', 'oath', 'if']),
]:
print matrix_str(case[0])
res = solution.findWords(*case)
try:
assert sorted(res) == sorted(ans)
except AssertionError as e:
status = fail_string(res=res, ans=ans, case=case)
sys.exit(status)
