r = ''
for i in range(0, n2):
r += words[i] + ' ' * (n1 + 1)
for i in range(n2, len(words) - 1):
r += words[i] + ' ' * n1
r += words[-1]
return r
return ' '.join(words)
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().fullJustify,
((
[
"This", "is", "an", "example", "of", "text", "justification.",
'aaa', 'bbb'
],
16,
[
'This is an',
'example of text',
'justification. ',
'aaa bbb ',
],
), ),
)
else:
words.extend(v)
for w in words:
ret[w] = [w]
return ret
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().wordsAbbreviation,
(
(
['internal', 'interval'],
['internal', 'interval'],
),
(
['intension', 'intrusion'],
['inte4n', 'intr4n'],
),
([
"like", "god", "internal", "me", "internet", "interval",
"intension", "face", "intrusion"
], [
"l2e", "god", "internal", "me", "i6t", "interval", "inte4n", "f2e",
"intr4n"
]),
),
)
s = list(s)
while i < len(s):
if i + k < len(s):
self._reverse(s, i, i + k)
else:
self._reverse(s, i, len(s))
i += 2 * k
return ''.join(s)
def _reverse(self, s, start, end):
end -= 1
while start < end:
s[start], s[end] = s[end], s[start]
start += 1
end -= 1
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().reverseStr,
(
('1234567890', 2, '2134657809'),
('1234567890', 3, '3214569870'),
('1234567890', 4, '4321567809'),
('1234567890', 9, '9876543210'),
('1234567890', 10, '0987654321'),
('1234567890', 11, '0987654321'),
),
)
ret = 0
for row, v1 in black_map.iteritems():
for column, v in v1.iteritems():
if v[0] == 1 and v[1] == 1:
ret += 1
return ret
from my_algorithm.common_test import run_test_cases, print_matrix
run_test_cases(
Solution().findLonelyPixel,
(
(
[['W', 'W', 'B'],
['W', 'B', 'W'],
['B', 'W', 'W']],
3,
),
(
[['W', 'W', 'B'],
['W', 'B', 'W'],
['B', 'W', 'B'],
['W', 'W', 'B']],
1,
),
),
print_funcs=[print_matrix, None],
)
num_count = {}
for num in nums:
num_count[num] = num_count.get(num, 0) + 1
results = set()
for num in num_count.keys():
if k == 0:
if num_count[num] > 1:
results.add('{}_{}'.format(num, num))
else:
pair_nums = [num - k, num + k]
for pair_num in pair_nums:
if pair_num in num_count:
a = min(num, pair_num)
b = max(num, pair_num)
results.add('{}_{}'.format(a, b))
return len(results)
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().findPairs,
(
([3, 1, 4, 1, 5], 2, 2),
([1, 2, 3, 4, 5], 1, 4),
([1, 3, 1, 5, 4], 0, 1),
),
)
while True:
start1, end1 = self._find_next_value_range(boxes, start1, boxes[0])
if start1 >= len(boxes):
break
r1 = self._process(boxes[end0:start1], cached) + self._process(
boxes[0:end0] + boxes[start1:], cached)
r = max(r, r1)
start1 = end1
cached[key] = r
return r
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().removeBoxes,
(
([1, 1], 4),
([1, 3, 2, 2, 2, 3, 4, 3, 1], 23),
([1, 2, 1, 2, 1, 2, 1, 2, 1], 29),
([
3, 8, 8, 5, 5, 3, 9, 2, 4, 4, 6, 5, 8, 4, 8, 6, 9, 6, 2, 8, 6, 4,
1, 9, 5, 3, 10, 5, 3, 3, 9, 8, 8, 6, 5, 3, 7, 4, 9, 6, 3, 9, 4, 3,
5, 10, 7, 6, 10, 7
], 136),
),
)
class Solution(object):
def reversePairs(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
ret = 0
for i in range(len(nums)):
for j in range(i, len(nums)):
if nums[i] > 2 * nums[j]:
ret += 1
return ret
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().reversePairs,
(
([1, 3, 2, 3, 1], 2),
([2, 4, 3, 5, 1], 3),
(list(range(1000)), 0),
(list(range(2000)), 0),
(list(range(5000)), 0),
),
print_time=True,
)
run_test_cases(
[Solution().isMatch1, Solution().isMatch2, Solution().isMatch, Solution().isMatch3],
(
("", "*", True),
("", "**", True),
("a", "a*", True),
("aa", "a", False),
("aa", "aa", True),
("aaa", "aa", False),
("aa", "*", True),
("aa", "a*", True),
("ab", "?*", True),
("aab", "c*a*b", False),
("babaaababaabababbbbbbaabaabbabababbaababbaaabbbaaab", "***bba**a*bbba**aab**b", False),
(
"bbaaaabaaaaabbabbabbabbababaabababaabbabaaabbaababababbabaabbabbbbbbaaaaaabaabbbbbabbbbabbabababaaaaa",
"******aa*bbb*aa*a*bb*ab***bbba*a*babaab*b*aa*a****",
False
),
(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*",
False
),
(
"bbbbabbbaabaaaaaaabbabbaaaaabbaaabaabbbbbbbabbaaabbabaababbbabaabababababaababbaaaababbaaabaababbbbaaabbabaaababbbababbaabaaaabaaaaaabbababbbbababaaaaaabaabbbbbbabbbaaaabaaaabbbbbabaaaabababaabbbbabba",
"*bababa*b*ba*abab****a**b**baa****a*aabb**b****ab**a***a*bb*b*b**bb*b**b*aab**babaaa**ab*babbba***baba",
False,
),
(
"bbbbaaaaabaabbbbaabaaabaabbababbbaaabbababbbabaabaabaabababaaabaaaabbaabbaabbaaaaabbabbbbaaaababbaaaabbabbbaabaaabbaabaabaaababbabbaababaababbbbbaabbabbabbbbaabbaaababbabaaabbbbbbbbaababbbbbbabbaabaaa",
"b*a**b***abaabaaaba*abaaaaabaabb*bbb*aa*ab*a**b**b*a**a**a*abbb***bb*b*****baababaa**ab*aa*bbaba**bb*b*",
False,
),
),
print_time=True,
)
if x < len(board) - 1:
if y > 0:
rounds.append([x + 1, y - 1])
rounds.append([x + 1, y])
if y < len(board[0]) - 1:
rounds.append([x + 1, y + 1])
return rounds
def _find_round_mine_count(self, board, rounds):
return sum(map(lambda x: self._count_mine(board, x[0], x[1]), rounds))
def _count_mine(self, board, x, y):
return 1 if board[x][y] == 'M' else 0
from my_algorithm.common_test import run_test_cases, is_matrix_equal, print_matrix
run_test_cases(
Solution().updateBoard,
(([['E', 'E', 'E', 'E', 'E'], ['E', 'E', 'M', 'E', 'E'],
['E', 'E', 'E', 'E', 'E'], ['E', 'E', 'E', 'E', 'E']
], [3, 0], [['B', '1', 'E', '1', 'B'], ['B', '1', 'M', '1', 'B'],
['B', '1', '1', '1', 'B'], ['B', 'B', 'B', 'B', 'B']]),
([['B', '1', 'E', '1', 'B'], ['B', '1', 'M', '1', 'B'],
['B', '1', '1', '1', 'B'], ['B', 'B', 'B', 'B', 'B']
], [1, 2], [['B', '1', 'E', '1', 'B'], ['B', '1', 'X', '1', 'B'],
['B', '1', '1', '1', 'B'], ['B', 'B', 'B', 'B', 'B']])),
equal_func=is_matrix_equal,
print_funcs=[print_matrix, None, print_matrix],
)
while cur_words_count_map[cur_word] > words_count_map[cur_word]:
first_index = cur_index - len_word * (cur_words_count - 1)
first_word = s[first_index:first_index + len_word]
cur_words_count -= 1
cur_words_count_map[first_word] -= 1
if cur_words_count == word_count:
results.append(cur_index - len_word *
(cur_words_count - 1))
return results
def _pop_first_word(self, s, len_word, cur_index, cur_words_count,
cur_words_count_map):
first_index = cur_index - len_word * (cur_words_count - 1)
first_word = s[first_index:first_index + len_word]
cur_words_count -= 1
cur_words_count_map[first_word] -= 1
return cur_words_count, cur_words_count_map
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().findSubstring,
(
('barfoothefoobarman', ["foo", "bar"], [0, 9]),
("wordgoodgoodgoodbestword", ["word", "good", "best", "good"], [8]),
),
)
times = map(self._str_time_to_int, timePoints)
times.sort()
ret = TOTAL_MINUTE_IN_ONE_DAY
for i in range(1, len(times)):
ret = min(ret, times[i] - times[i - 1])
ret = min(ret, self._get_time_diff(times[-1], times[0], TOTAL_MINUTE_IN_ONE_DAY))
return ret
def _str_time_to_int(self, s):
ns = s.split(':')
return int(ns[0]) * 60 + int(ns[1])
def _get_time_diff(self, t1, t2, total_minute_in_one_day):
t = t2 - t1
if t < 0:
t += total_minute_in_one_day
return t
from my_algorithm.common_test import run_test_cases
run_test_cases(
Solution().findMinDifference,
(
(["23:59", "00:00"], 1),
(["21:59", "00:00"], 121),
(["23:59", "00:20", "00:01"], 2),
(["23:59", "00:20", "01:01"], 21),
),
)
parent.right = child
from my_algorithm.common_test import run_test_cases
t = TreeNode(4)
t.left = TreeNode(2)
t.left.left = TreeNode(3)
t.left.right = TreeNode(1)
t.right = TreeNode(6)
t.right.left = TreeNode(5)
def equal_func(t1, t2):
if t1 is None:
return t2 is None
if t2 is None:
return False
if t1.val != t2.val:
return False
r1 = equal_func(t1.left, t2.left)
r2 = equal_func(t1.right, t2.right)
return r1 and r2
run_test_cases(
Solution().str2tree,
(('4(2(3)(1))(6(5))', t), ('4', TreeNode(4))),
equal_func=equal_func,
)
b = max(row, row1)
key = '{}_{}'.format(a, b)
if key not in row_equal_map:
row_equal_map[key] = (
picture[row] == picture[row1])
if not row_equal_map[key]:
is_all_equal = False
break
if is_all_equal:
ret += 1
return ret
from my_algorithm.common_test import run_test_cases, print_matrix
run_test_cases(
Solution().findBlackPixel,
(
([['W', 'B', 'W', 'B', 'B', 'W'], ['W', 'B', 'W', 'W', 'B', 'W'],
['W', 'B', 'W', 'B', 'B', 'W'], ['W', 'W', 'B', 'W', 'B', 'W'],
['W', 'W', 'W', 'B', 'B', 'W']], 3, 0),
([['W', 'B', 'W', 'B', 'B', 'W'], ['W', 'B', 'W', 'B', 'B', 'W'],
['W', 'B', 'W', 'B', 'B', 'W'], ['W', 'W', 'B', 'W', 'B', 'W']
], 3, 6),
([['W', 'B', 'W', 'B', 'W', 'W'], ['W', 'B', 'W', 'B', 'W', 'W'],
['W', 'B', 'W', 'B', 'B', 'W'], ['W', 'W', 'B', 'W', 'B', 'W']
], 2, 0),
),
print_funcs=(print_matrix, None, None),
)