class Solution:
def maxChunksToSorted(self, arr: List[int]) -> int:
if not arr:
return 0
sorted_arr = arr.copy()
sorted_arr.sort()
max_l = [None] * len(arr)
max_l[0] = arr[0]
for i in range(1, len(arr)):
max_l[i] = max(max_l[i - 1], arr[i])
cnt = 0
min_r = max_l[-1] + 1
for i in range(len(arr)):
if max_l[~i] == sorted_arr[~i]:
if sorted_arr[~i] > min_r:
continue
cnt += 1
min_r = arr[~i]
return cnt
assert_value(1, Solution().maxChunksToSorted, arr=[5, 4, 3, 2, 1])
assert_value(4, Solution().maxChunksToSorted, arr=[2, 1, 3, 4, 4])
assert_value(4, Solution().maxChunksToSorted, arr=[2, 1, 4, 4, 3, 5, 7, 6])
from test_tool import assert_value
class Solution(object):
def longestCommonSubsequence(self, text1: str, text2: str) -> str:
if len(text1) == 0 or len(text2) == 0:
return ''
c = []
for i in range(len(text1) + 1):
c_inner = [0] * (len(text2) + 1)
c.append(c_inner)
for m in range(1, len(text1) + 1):
for n in range(1, len(text2) + 1):
if text1[m - 1] == text2[n - 1]:
c[m][n] = c[m - 1][n - 1] + 1
else:
c[m][n] = max(c[m - 1][n], c[m][n - 1])
return c[m][n]
assert_value(4,
Solution().longestCommonSubsequence,
text1="ABCBDAB",
text2="BDCABA")
assert_value(3,
Solution().longestCommonSubsequence,
text1="abcde",
text2="ace")
from typing import List
from collections import defaultdict
from test_tool import assert_value
class Solution:
def bestEvenOddSubsequence(self, arr: List[int]) -> int:
sum_odd = []
sum_even = []
for i in arr:
if self.is_odd(i):
prev_sum = 0 if len(sum_even) == 0 else max(sum_even)
sum_odd.append(prev_sum + i)
else:
prev_sum = 0 if len(sum_odd) == 0 else max(sum_odd)
sum_even.append(prev_sum + i)
return max(sum_odd[-1:] + sum_even[-1:])
def is_odd(self, i: int) -> bool:
return bool(i & 1)
assert_value(15, Solution().bestEvenOddSubsequence, arr=[1, 2, 3, 4, 5])
assert_value(5, Solution().bestEvenOddSubsequence, arr=[2, -2, 1, 3])
options = [i for i in range(1, maxChoosableInteger + 1)]
options = tuple(options)
if sum(options) < desiredTotal:
return False
return self.check_case(options, desiredTotal, 0, {})
def check_case(self, options: tuple, desiredTotal: int, currentTotal: int,
cache: dict):
if options in cache:
return cache[options]
else:
cache[options] = False
if max(options) + currentTotal >= desiredTotal:
cache[options] = True
elif options:
for i, opt in enumerate(options):
options_new = (*options[:i], *options[i + 1:])
if not self.check_case(options_new, desiredTotal,
currentTotal + opt, cache):
cache[options] = True
break
return cache[options]
assert_value(False,
Solution().canIWin,
maxChoosableInteger=10,
desiredTotal=11)
assert_value(True, Solution().canIWin, maxChoosableInteger=10, desiredTotal=0)
assert_value(True, Solution().canIWin, maxChoosableInteger=10, desiredTotal=1)
if dp[-1] < nums[idx]:
dp.append(nums[idx])
continue
l, r = 0, len(dp) - 1
loc = r
while l <= r:
m = (l + r) // 2
if dp[m] >= nums[idx]:
loc = m
r = m - 1
else:
l = m + 1
dp[loc] = nums[idx]
return len(dp)
def lengthOfLIS_DP(self, nums: List[int]) -> int:
dp = [0] * len(nums)
for idx in range(len(nums)):
dp[idx] = 1
for i in range(idx):
if nums[idx] > nums[i]:
dp[idx] = max(dp[idx], dp[i] + 1)
return max(dp)
assert_value(4, Solution().lengthOfLIS, nums=[10, 9, 2, 5, 3, 7, 101])
assert_value(3, Solution().lengthOfLIS, nums=[4, 10, 4, 3, 8, 9])
'''
165. Compare Version Numbers
https://leetcode.com/problems/compare-version-numbers/
'''
from typing import List
from test_tool import assert_value
class Solution:
def compareVersion(self, version1: str, version2: str) -> int:
slot1 = version1.split('.')
slot2 = version2.split('.')
for i in range(max(len(slot1), len(slot2))):
v1 = 0 if i >= len(slot1) else int(slot1[i])
v2 = 0 if i >= len(slot2) else int(slot2[i])
if v1 > v2:
return 1
if v1 < v2:
return -1
return 0
assert_value(0, Solution().compareVersion, version1="1.01", version2="1.001")
assert_value(0, Solution().compareVersion, version1="1.0", version2="1.0.0")
assert_value(-1, Solution().compareVersion, version1="0.1", version2="1.1")
assert_value(1, Solution().compareVersion, version1="1.0.1", version2="1")
assert_value(-1, Solution().compareVersion, version1="7.5.2.4", version2="7.5.3")
else:
r = m
left = l
# Find the tail
l, r = mid, len(nums)
while l < r:
m = (l + r) >> 1
if nums[m] <= target:
l = m + 1
else:
r = m
return [left, l - 1]
assert_value([3, 4],
Solution().searchRange,
nums=[5, 7, 7, 8, 8, 10],
target=8)
assert_value([-1, -1],
Solution().searchRange,
nums=[5, 7, 7, 8, 8, 10],
target=6)
assert_value([-1, -1], Solution().searchRange, nums=[], target=0)
assert_value([0, 0], Solution().searchRange, nums=[1], target=1)
assert_value([0, 0], Solution().searchRange, nums=[1, 3], target=1)
assert_value([2, 5],
Solution().searchRange,
nums=[1, 2, 3, 3, 3, 3, 4, 5, 9],
target=3)
def build_nodes(nodes: List[int]) -> ListNode:
if len(nodes) == 0:
return []
if len(nodes) == 1:
return ListNode(nodes[0])
return ListNode(nodes[0], build_nodes(nodes[1:]))
def to_array(node: ListNode):
nodes = []
while node:
nodes.append(node.val)
node = node.next
return nodes
def test_wrapper(func):
def func_wrapper(**kwargs):
res = func(**kwargs)
return to_array(res)
return func_wrapper
assert_value([1, 2, 3, 4], test_wrapper(Solution().sortList), head=build_nodes([4, 2, 1, 3]))
assert_value([-1, 0, 3, 4, 5], test_wrapper(Solution().sortList), head=build_nodes([-1, 5, 3, 4, 0]))
assert_value([], test_wrapper(Solution().sortList), head=build_nodes([]))
assert_value([0, 1, 1, 2, 2, 3, 4], test_wrapper(Solution().sortList), head=build_nodes([4, 2, 1, 3, 2, 1, 0]))
'''
65. Valid Number
https://leetcode.com/problems/valid-number/
'''
import re
from typing import List
from test_tool import assert_value
class Solution:
def __init__(self):
pattern = r"^[+-]?((\d+\.?\d*)|(\.\d+))([eE][+-]?\d+)?$"
self._prog = re.compile(pattern)
def isNumber(self, s: str) -> bool:
return bool(self._prog.search(s))
for case in ["0", ".1", "2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93",
"-123.456e789"]:
print(f"{case}:{Solution().isNumber(case)}")
assert_value(True, Solution().isNumber, s=case)
for case in ["e", ".", "abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]:
print(f"{case}:{Solution().isNumber(case)}")
assert_value(False, Solution().isNumber, s=case)
class Solution:
def smallestDistancePair(self, nums: List[int], k: int) -> int:
nums = sorted(nums)
lo = 0
hi = nums[-1] - nums[0]
while lo < hi:
guess = (lo + hi) // 2
if self.shift_right(nums, guess, k):
lo = guess + 1
else:
hi = guess
return hi
def shift_right(self, nums, guess, k):
i = 0
j = 1
cnt = 0
while i < len(nums):
while j < len(nums) and nums[j] - nums[i] <= guess:
j += 1
cnt += j - i - 1
i += 1
return cnt < k
assert_value(0, Solution().smallestDistancePair, nums=[1, 3, 1], k=1)
assert_value(5, Solution().smallestDistancePair, nums=[1, 6, 1], k=3)
assert_value(2, Solution().smallestDistancePair, nums=[9, 10, 7, 10, 6, 1, 5, 4, 9, 8], k=18)
if 'start' == opt_2:
stack.append((idx_2, t_2))
else:
idx_1, t_1 = stack.pop()
time_cost = t_2 - t_1 + 1
res[idx_1] += time_cost
if stack:
idx_recursion = stack[-1][0]
res[idx_recursion] -= time_cost
idx += 1
return res
assert_value([3, 4],
Solution().exclusiveTime,
n=2,
logs=["0:start:0", "1:start:2", "1:end:5", "0:end:6"])
assert_value([8],
Solution().exclusiveTime,
n=1,
logs=[
"0:start:0", "0:start:2", "0:end:5", "0:start:6", "0:end:6",
"0:end:7"
])
assert_value([7, 1],
Solution().exclusiveTime,
n=2,
logs=[
"0:start:0", "0:start:2", "0:end:5", "1:start:6", "1:end:6",
"0:end:7"
])
class Solution:
def minCut(self, s: str) -> int:
dp = [0] * len(s)
for i in range(1, len(s)):
dp[i] = self.check(s[:i + 1])
for j in range(i):
dp[i] = min(dp[i], dp[j] + 1 + self.check(s[j + 1:i + 1]))
return dp[-1]
def check(self, s):
if s == s[::-1]:
return 0
else:
return len(s) - 1
return 0
assert_value(1, Solution().minCut, s="aab")
assert_value(0, Solution().minCut, s="a")
assert_value(1, Solution().minCut, s="ab")
assert_value(0, Solution().minCut, s="bb")
assert_value(1, Solution().minCut, s="abbab")
assert_value(
1,
Solution().minCut,
s="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
)
class Solution:
def quickSort(self, target: List[int]) -> List[int]:
if len(target) == 1:
return target
i = 1
j = len(target) - 1
while i < j:
while target[j] > target[0] and j > 0:
j -= 1
while target[i] < target[0] and i < j:
i += 1
if i < j:
target[i], target[j] = target[j], target[i]
idx = min(i, j)
if target[0] > target[idx]:
target[0], target[idx] = target[idx], target[0]
return self.quickSort(target[:i]) + self.quickSort(target[i:])
assert_value([1, 2, 3, 4, 5, 123],
Solution().quickSort,
target=[1, 2, 3, 4, 5, 123])
assert_value([5, 123], Solution().quickSort, target=[5, 123])
assert_value([0, 1, 2, 3, 10, 50],
Solution().quickSort,
target=[3, 10, 50, 2, 1, 0])
https://leetcode.com/problems/maximum-subarray/
'''
from typing import List
from test_tool import assert_value
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
m = int(len(nums) / 2)
if len(nums) == 1:
return nums[0]
left = self.maxSubArray(nums[:m])
right = self.maxSubArray(nums[m:])
mid_left_arr = nums[:m]
mid_right_arr = nums[m:]
for idx in reversed(range(len(mid_left_arr) - 1)):
mid_left_arr[idx] += mid_left_arr[idx + 1]
for idx in range(1, len(mid_right_arr)):
mid_right_arr[idx] += mid_right_arr[idx - 1]
mid = max(mid_left_arr) + max(mid_right_arr)
return max(left, right, mid)
assert_value(4, Solution().maxSubArray, nums=[-2, 1, -3, 4])
assert_value(6, Solution().maxSubArray, nums=[-2, 1, -3, 4, -1, 2, 1, -5, 4])
for l in [left_max, left_min]:
for r in [right_max, right_min]:
mid = max(mid, l * r)
return max(left, right, mid)
def __maxProduct(self, nums: List[int]) -> int:
dp = [nums[0]]
for num in nums[1:]:
dp.append(max(num, dp[-1] * num))
return max(dp)
def maxProduct(self, nums: List[int]) -> int:
maxi, mini, res = 1, 1, -math.inf
for num in nums:
acc_maxi = maxi * num
acc_mini = mini * num
maxi = max(num, acc_maxi, acc_mini)
mini = min(num, acc_maxi, acc_mini)
res = max(res, maxi)
return res
assert_value(6, Solution().maxProduct, nums=[2, 3, -2, 4])
assert_value(0, Solution().maxProduct, nums=[-2, 0, -1])
assert_value(24, Solution().maxProduct, nums=[-2, 3, -4])
return sorted(scc_map, key=lambda item: len(item[0]), reverse=True)[0][1][0]
def dfs(self, graph: List[List[int]], i, scc, accessed):
scc.append(i)
for j in range(len(graph)):
if accessed[j]:
continue
if not graph[i][j]:
continue
accessed[j] = True
self.dfs(graph, j, scc, accessed)
assert_value(0, Solution().minMalwareSpread, graph=[
[1, 1, 0],
[1, 1, 0],
[0, 0, 1]
], initial=[0, 1])
assert_value(0, Solution().minMalwareSpread, graph=[
[1, 0, 0],
[0, 1, 0],
[0, 0, 1]
], initial=[0, 2])
assert_value(1, Solution().minMalwareSpread, graph=[
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]
], initial=[1, 2])
assert_value(2, Solution().minMalwareSpread, graph=[
[1, 1, 0],
[1, 1, 0],
def maxPoints(self, points: List[List[int]]) -> int:
if len(points) == 1:
return 1
slope_cache = defaultdict(set)
for a in range(len(points) - 1):
for b in range(a + 1, len(points)):
p1 = tuple(points[a])
p2 = tuple(points[b])
slope = float('inf') if p1[0] == p2[0] else (p1[1] - p2[1]) / (p1[0] - p2[0])
intercept = p1[0] if p1[0] == p2[0] else p1[1] - slope * p1[0]
slope_cache[(slope, intercept)] |= set([p1, p2])
return len(sorted(slope_cache.items(), key=lambda item: len(item[1]), reverse=True)[0][1])
assert_value(1, Solution().maxPoints, points=[[0, 0]])
assert_value(3, Solution().maxPoints, points=[[1, 1], [2, 2], [3, 3]])
assert_value(4, Solution().maxPoints, points=[[1, 1], [3, 2], [5, 3], [4, 1], [2, 3], [1, 4]])
assert_value(6, Solution().maxPoints,
points=[[7, 3], [19, 19], [-16, 3], [13, 17], [-18, 1], [-18, -17], [13, -3], [3, 7], [-11, 12], [7, 19],
[19, -12], [20, -18], [-16, -15], [-10, -15], [-16, -18], [-14, -1], [18, 10], [-13, 8], [7, -5],
[-4, -9], [-11, 2], [-9, -9], [-5, -16], [10, 14], [-3, 4], [1, -20], [2, 16], [0, 14], [-14, 5],
[15, -11], [3, 11], [11, -10], [-1, -7], [16, 7], [1, -11], [-8, -3], [1, -6], [19, 7], [3, 6],
[-1, -2], [7, -3], [-6, -8], [7, 1], [-15, 12], [-17, 9], [19, -9], [1, 0], [9, -10], [6, 20],
[-12, -4], [-16, -17], [14, 3], [0, -1], [-18, 9], [-15, 15], [-3, -15], [-5, 20], [15, -14],
[9, -17], [10, -14], [-7, -11], [14, 9], [1, -1], [15, 12], [-5, -1], [-17, -5], [15, -2],
[-12, 11], [19, -18], [8, 7], [-5, -3], [-17, -1], [-18, 13], [15, -3], [4, 18], [-14, -15],
[15, 8], [-18, -12], [-15, 19], [-9, 16], [-9, 14], [-12, -14], [-2, -20], [-3, -13], [10, -7],
[-2, -10], [9, 10], [-1, 7], [-17, -6], [-15, 20], [5, -17], [6, -6], [-11, -8]])
def dfs(self, grid, accessed, i, j):
accessed[i][j] = True
if i + 1 < len(grid) and not accessed[i + 1][j] and '1' == grid[i +
1][j]:
self.dfs(grid, accessed, i + 1, j)
if j + 1 < len(
grid[0]) and not accessed[i][j + 1] and '1' == grid[i][j + 1]:
self.dfs(grid, accessed, i, j + 1)
if i > 0 and not accessed[i - 1][j] and '1' == grid[i - 1][j]:
self.dfs(grid, accessed, i - 1, j)
if j > 0 and not accessed[i][j - 1] and '1' == grid[i][j - 1]:
self.dfs(grid, accessed, i, j - 1)
assert_value(1,
Solution().numIslands,
grid=[["1", "1", "1", "1", "0"], ["1", "1", "0", "1", "0"],
["1", "1", "0", "0", "0"], ["0", "0", "0", "0", "0"]])
assert_value(3,
Solution().numIslands,
grid=[["1", "1", "0", "0", "0"], ["1", "1", "0", "0", "0"],
["0", "0", "1", "0", "0"], ["0", "0", "0", "1", "1"]])
assert_value(1,
Solution().numIslands,
grid=[["1", "1", "1"], ["0", "1", "0"], ["1", "1", "1"]])
assert_value(3,
Solution().numIslands,
grid=[["1", "0", "1", "1", "0", "1", "1"]])
return self.size == self.limit
def rebalance(self):
"""
Rebalances the first and the second half of the storage
:return:
"""
while len(self.front_queue) > len(self.back_queue):
self.back_queue.insert(0, self.front_queue.pop())
while len(self.front_queue) + 1 < len(self.back_queue):
self.front_queue.append(self.back_queue.pop(0))
circularDeque = MyCircularDeque(3)
assert_value(True, circularDeque.insertLast, value=1)
assert_value(True, circularDeque.insertLast, value=2)
assert_value(True, circularDeque.insertFront, value=3)
assert_value(False, circularDeque.insertFront, value=4)
assert_value(2, circularDeque.getRear)
assert_value(True, circularDeque.isFull)
assert_value(True, circularDeque.deleteLast)
assert_value(True, circularDeque.insertFront, value=4)
assert_value(4, circularDeque.getFront)
circularDeque = MyCircularDeque(8)
assert_value(True, circularDeque.insertFront, value=5)
assert_value(5, circularDeque.getFront)
assert_value(False, circularDeque.isEmpty)
assert_value(True, circularDeque.deleteFront)
assert_value(True, circularDeque.insertLast, value=3)
'''
8. String to Integer (atoi)
https://leetcode.com/problems/string-to-integer-atoi/
'''
import re
from typing import List
from test_tool import assert_value
class Solution:
def myAtoi(self, s: str) -> int:
matcher = re.match(r'^\s*([+|-]?\d+)', s)
digit = 0
if matcher:
digit = int(matcher.group())
if digit < 0:
return max(-(1 << 31), digit)
return min((1 << 31) - 1, digit)
assert_value(42, Solution().myAtoi, s="42")
assert_value(-42, Solution().myAtoi, s=" -42")
assert_value(4193, Solution().myAtoi, s="4193 with words")
assert_value(0, Solution().myAtoi, s="words and 987")
assert_value(-2147483648, Solution().myAtoi, s="-91283472332")
assert_value(0, Solution().myAtoi, s=".1")
curr.next = None
return head
def build_nodes(nodes: List[int]) -> ListNode:
if len(nodes) == 0:
return []
if len(nodes) == 1:
return ListNode(nodes[0])
return ListNode(nodes[0], build_nodes(nodes[1:]))
def to_array(node: ListNode):
nodes = []
while node:
nodes.append(node.val)
node = node.next
return nodes
def test_wrapper(func):
def func_wrapper(**kwargs):
res = func(**kwargs)
return to_array(res)
return func_wrapper
assert_value([5, 4, 3, 2, 1], test_wrapper(Solution().reverseList), head=build_nodes([1, 2, 3, 4, 5]))
self._list_cache[self._idx_cache[val]] = self._list_cache[-1]
self._idx_cache[self._list_cache[-1]] = self._idx_cache[val]
del self._list_cache[-1]
del self._idx_cache[val]
return True
def getRandom(self) -> int:
"""
Get a random element from the set.
"""
return random.choice(self._list_cache)
# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# assert_value(True, obj.insert, val=1)
# assert_value(False, obj.remove, val=2)
# assert_value(True, obj.insert, val=2)
# assert obj.getRandom() in [1, 2]
# assert_value(True, obj.remove, val=1)
# assert_value(False, obj.insert, val=2)
# assert_value(2, obj.getRandom)
obj = RandomizedSet()
assert_value(True, obj.insert, val=0)
assert_value(True, obj.insert, val=1)
assert_value(True, obj.remove, val=0)
assert_value(True, obj.insert, val=2)
assert_value(True, obj.remove, val=1)
assert_value(2, obj.getRandom)
class Solution:
def rob(self, nums: List[int]) -> int:
if not nums:
return 0
if len(nums) == 1:
return nums[0]
elif len(nums) == 2:
return max(nums[0], nums[1])
# 1 ~ (n - 1)
dp1 = [None] * (len(nums) - 1)
dp1[0] = nums[0]
dp1[1] = max(nums[0], nums[1])
for i in range(2, len(nums) - 1):
dp1[i] = max(dp1[i - 1], dp1[i - 2] + nums[i])
# 2 ~ (n)
dp2 = [None] * (len(nums) - 1)
dp2[0] = nums[1]
dp2[1] = max(nums[1], nums[2])
for i in range(2, len(nums) - 1):
dp2[i] = max(dp2[i - 1], dp2[i - 2] + nums[i + 1])
return max(dp1[len(dp1) - 1], dp2[len(dp2) - 1])
assert_value(3, Solution().rob, nums=[2, 3, 2])
assert_value(4, Solution().rob, nums=[1, 2, 3, 1])
prev_stack = []
curr_stack = []
cnt = 0
prev = s[0]
for curr in s:
if curr != prev:
curr_stack, prev_stack = prev_stack, curr_stack
curr_stack.clear()
prev = curr
curr_stack.append(curr)
if len(prev_stack) > 0:
prev_stack.pop()
cnt += 1
return cnt
assert_value(6, Solution().countBinarySubstrings, s='00110011')
assert_value(4, Solution().countBinarySubstrings, s='10101')
assert_value(4, Solution().countBinarySubstrings, s="11110110000")
assert_value(
27,
Solution().countBinarySubstrings,
s="11001111101101100111111111111100110010111111111001101111111111")
assert_value(
5718,
Solution().countBinarySubstrings,
s="1100111110110110011111111111110011001011111111100110111111111101010010011110001111110111101111110101110100001111001110011101011000111011101011111110101100101111110101101101111111001111111000011110110101111111111010101001111100010000001001101001100101111110110111110111111010011001110111101110001011100110011010001011100000001101000011100111111010110101110110000011110110111101010110010101111101011111111111110100110101111101111001101011101111111111100111011011010010110111111101110011011111111110001110110000101111111111101110011111011100010111110011110111111110111000110101011101101011101011011100011101101111110111000111110101100110111111001111110111111101101110011101110111110111111101001111100111010111011110011011100101100101010110001011100110111101111110111111111110010101100100111110101011111010101101101111110111111011011001001111001111000111010111100100110011111111100100111100011111011100001001101111011011110010101110001111010000001111110001011000110110111111000110001110101100111111100011100101000111011101110011111111111011111101111110011110111101110011111101110111110111111101111101011010111110110011011101101111100001000101010110110111011111110111111100110111011001111011100011011100101010111111111101110010101101001111011110111011110011000000110111111111101111010110010010111111100111110111000101111010111011111111111000001011111011110111111111111100100100001101101111110010000111101001111111101011010011110011011111000111010000010110011011011011111111110011111101100010111011010111011111111110101110101001101100010111111001101011011111001000101011111011111011110110101111111011011110101111001010110001101011000110110011111101100111110100101111011001000111111110100111101100101111111010110110011110010010111010111111101111101111101001110011101111110001110111010011011101111100011111111101010101101011111111100110111100111101110110010110111100011111010110011111101101101000110110001010001111011100100111111111011111011111111100101111001111110011010010010111111110110001001101111110011111010110011101111110110010000001111111000110111101101111010111110001011100011111011100100000111111011011010010100110101011001111111101111010111111000101110001011111010110110111111111111101101011100000110101001111010110111100011011110100110111111111111111100011011011110011010011100111111111110110111001110100110111010010110111111111111111110001101111011111110111010001101110111110100111110111111110110111111111011111000000101101101111011011111111111111011111000101111111101111111111111111111111100100111000011010001000110110110111111110101111000110100100001111011100111111010100101101010100000111001111101011001111110111011111011010111111011111011010100111011110001000010111110110111110111011011010001010101101111111101111100010010111101100000110100101111010100111101110111011101001101101111001110111101101111101000110110110111101111011011101010001111010011111110111011011100001111111111111000111010101001110010100011011011101111010111110011111010101101010101111110010101111010111001110000011110100011110110111101001110011101110110101111111000101111010111110111110001111110100100001101010001011111110010110110000101111110110111101000101111011111011001100000111111111101010010100111100111110111100011111101111011111100111110000101111011101001001111001101110100100101101111001111111111000110111111101010110011010010011001000111100010100111111001101111110011111000111101011101111110101111101111010110111111101111011111111111100001101100110110011111111101111111101011010010110110011101000111101111110111111011111111110110011100001111110001111011100111111101011111110100110000110011001011111001001110111011110101101101011011011010011110111011100101011011001110001001101011010111000001101011111111101011001111001001100001111110101001111111011100000111100110101010010111101110111011111010110101111101100111111110011011101011101111110011000110111010110011111111111100111011101111011111101111110011101011100101100100111111111111011011100111111111100101111111001111010100011011111001000010111101111111011111100111110111010101111111011111011010000110010111011011000111111011010000111001010101111101011111010111100011001011110111011101110001000111111111100101100110011011011110111111000100010111111011110100111010111111111001011111111111001111110110010011001111100111011110011111000101101111100110011000010100110111101100111110111101111011111100110011011111011001101010111111111010111111100101101011111111011100001111011011111111011111110010100110000000011000010111011101111101111111101101111001011111010110110101011100001110100101001111001111011101101010011010110111101111110101101111100110111101111111101010000101010010001110111000110101101100101111101101011100101111011111101111011110100001011110110111111111011000111111001111010111011010111000101110011010110010111111101111111110111011111010110111111001010111001110110101011000111110000010001101111111000011010110111100010111110010001110011111001110101001000100111011110000100111101101111010011101011010101101000011111111011101111111101111101101110111011111001110111101010111000101010111010111110110010110110111111110111111110011101111011111011111111001111110100110100010110001111101111000111100111101101010110100110110110111001111111111010011011001111111111111010111011101101010100111111011111000110111111011111010111110101110100011110110100100100101111111111111111011110001100011101011101111010111111000000011100111001011110111110110110101100011100101110010001111110011110110101011001101101110001001111110110111111110110011101100111011111011010110011010100011111101101000100010001111110110101000010110111111111111101111001011101011000000101011011101111001010110011111101100110011100101101110111100011011111100110111111111011111001110110000010010111001111110010111111010110010100011101111100111011111011110110101110101101100000001011101001111111000001110010110111011111111011110110111011001111111101000101110111110111001110001001011011010111111011000111111111101111111100000110110011110011010110101101111101000101101011110111001100110111111100111101001000001001110101110111111110011101001011111011010110111100001110110011111010111111011111110111010101110011010100100110111111111011011011010100001001100010111101110110111001110011011111101111001001111111111100110101111011110111111111010101101011110111111101001111001011011110011111110111011110101100011111111011110111101011111011011110111100100101101101111110111110011110100011010111001100011111110101111101100011111111010111011100011110110111101110001111111110011011101111111010010110010100111111111111111010101111111101111010001010001001101110001100101101101001000101111110110110011010101100101101100110011111010011000010111001011110110110101101010011110011101101100011110110011100010111100111101001000011101110111100111010101111011111001100111011010111001101101110000011011000111101111010111001101111111101110111010110111110111011111101101001001110110011111011101111010001111011111100110011100111011111111001111111111010010001111111111001011010010101110111101111111001011110010111101011111111111111000001111100101111111011101101110011110111101110110111101001100000110000111110001010010111111111011011011011111110111101101011011111101101011100111111101001111011110011101101111010111011011100111100101111111011100111101101010101000111111111101101101111111101110011111111101011101011111111010110110101111001111010011100011111011111100001101011010110101100011111101100111110011011110100110001111011110100111010111111010110111111111011001011111111011111100110110111100111110010011110110011011110110001111011100111101101110011101001101100110110111101000011110011010110101111111111011101110110100101110100011110101010101110111011111101111001011011100101011011010111111010111100000011010011111010110101001111111011101000001010011101111100101111011111111111010110111111011100110111001011001011111111101110111011001111111111111110010101101011011010011101110111000011111010111001011111111111101011111011110100011111010010101110111100110111011010000111001001001111110010110011101110101101011011110001001011100000100101111111100101111011010111111101011100011100111011100100101100111101001011110011001100110001000111110110110001110110111100110111111100111111111101110111111111000001110110101110110010011101110100111001001110110110101101111001001111111100101101101101011101111111010011011101011110111010000011101111001101011111011011110111101010101110101100111110011001111101111111011101001101111111111010001011011010110110001110111111110011111111001110100101111011111110100111110111110011111110011111101111110101100100001110110111110101110011100101111100110111111011111100101111110100001010011110010110101111110010010011100001011001011010101110111011111010101101001101010101111110111011110111101111111111110111011111010101011000110001110111111110111010110110111111110101101111001101111010111010110101110011101111011111111010111111111101010011001101111111011011101110011100101110001111011111010110111111110101011111010111111110111110011111110111001011100111111110111110101101110011011110011110101111111111011011101111110110001001111101100100000111110101010000110011111101011111101111100110011111011010011011011010000001101111111011010111100100111100101101011010101010010111110010010111010001011101011111110000011111010110111101011101101101010010011100111011010110011111110010010111111101011111111111101111111110101100101111111110000110011000101011110111010110011001011000011000001000100110011100111111110011011111111001010011110011101101110011011110010101011101011111010101011001111110010111011111001100100110011010011100110111101010111101110101011111111111111000101111111011010111111010010000101111010101001111111001111010000111111010011111111010001010011011100111111001110011111011101010001111111011001001101111111010111101000111001010111001011111111011110001001111111110111111011100110101111010111101011111111100010000111011111011000111111111111100111011001001111001111110000101110100011101111111101110111111111111111110110001101010101110111110111101111110011010111011101111110111111011101111111001111111011110111111"
)
'''
1680. Concatenation of Consecutive Binary Numbers
https://leetcode.com/problems/concatenation-of-consecutive-binary-numbers/
'''
from typing import List
from test_tool import assert_value
class Solution:
def concatenatedBinary(self, n: int) -> int:
l, ans = 0, 0
for i in range(1, n + 1):
if i & (i - 1) == 0:
l += 1
ans = ((ans << l) | i) % (10 ** 9 + 7)
return (ans)
assert_value(1, Solution().concatenatedBinary, n=1)
assert_value(27, Solution().concatenatedBinary, n=3)
assert_value(505379714, Solution().concatenatedBinary, n=12)
class Solution:
def isIsomorphic(self, s: str, t: str) -> bool:
if len(s) != len(t):
return False
cache_s = {}
cache_t = {}
for i in range(len(s)):
si = s[i]
ti = t[i]
if si not in cache_s and ti not in cache_t:
cache_s[si] = i
cache_t[ti] = i
continue
if si not in cache_s or ti not in cache_t:
return False
if cache_s[si] != cache_t[ti]:
return False
return True
assert_value(True, Solution().isIsomorphic, s="egg", t="add")
assert_value(False, Solution().isIsomorphic, s="foo", t="bar")
assert_value(True, Solution().isIsomorphic, s="paper", t="title")
if len(nums) == 2:
if nums[0] == nums[1]:
return [nums]
return [nums, nums[::-1]]
num = nums[0]
res = []
ps = self.permuteUnique(nums[1:])
for p in ps:
for i in range(len(nums)):
res.append(p[:i] + [num] + p[i:])
if i < len(p) and p[i] == num:
break
return sorted(res)
assert_value([[]], Solution().permuteUnique, nums=[])
assert_value([[1]], Solution().permuteUnique, nums=[1])
assert_value([[1, 1, 2], [1, 2, 1], [2, 1, 1]],
Solution().permuteUnique,
nums=[1, 1, 2])
assert_value(
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]],
Solution().permuteUnique,
nums=[1, 2, 3])
'''
from typing import List
from test_tool import assert_value
class Solution:
def nextGreatestLetter(self, letters: List[str], target: str) -> str:
target = ord(target)
if target < ord(letters[0]) or target >= ord(letters[-1]):
return letters[0]
l, r = 0, len(letters)
while l < r:
m = (l + r) >> 1
if ord(letters[m]) <= target:
l = m + 1
else:
r = m
return letters[l]
assert_value("c", Solution().nextGreatestLetter, letters=["c", "f", "j"], target="a")
assert_value("f", Solution().nextGreatestLetter, letters=["c", "f", "j"], target="c")
assert_value("f", Solution().nextGreatestLetter, letters=["c", "f", "j"], target="d")
assert_value("j", Solution().nextGreatestLetter, letters=["c", "f", "j"], target="g")
assert_value("c", Solution().nextGreatestLetter, letters=["c", "f", "j"], target="j")
assert_value("c", Solution().nextGreatestLetter, letters=["c", "f", "j"], target="k")
assert_value("v", Solution().nextGreatestLetter, letters=["e", "e", "e", "k", "q", "q", "q", "v", "v", "y"], target="q")
left = self.maximumSwap(num_str[:mid])
right = self.maximumSwap(num_str[mid:])
left = str(left) + num_str[mid:]
right = num_str[:mid] + str(right)
left_swap = 0
for i in reversed(range(10)[1:]):
for j in reversed(range(mid, len(num_str))):
if i == int(num_str[j]):
left_swap = j
break
else:
continue
break
right_swap = 0
while num_str[right_swap] >= num_str[left_swap] and right_swap < left_swap:
right_swap += 1
if left_swap == right_swap:
return int(max(left, right))
edge = [c for c in num_str]
edge[left_swap], edge[right_swap] = edge[right_swap], edge[left_swap]
edge = ''.join(edge)
return int(max(max(left, right), edge))
assert_value(7236, Solution().maximumSwap, num=2736)
assert_value(9973, Solution().maximumSwap, num=9973)
assert_value(98863, Solution().maximumSwap, num=98368)
assert_value(91000000, Solution().maximumSwap, num=90000001)
line_str = line[0]
for i in range(space_res):
line_str += ' ' * (space_even + 1) + line[i + 1]
for i in range(len(line) - 1 - space_res):
line_str += ' ' * space_even + line[i + 1 + space_res]
else:
line_str = ' '.join(line)
line_str += ' ' * (cnt_left + 1)
res.append(line_str)
line.clear()
assert_value(
["This is an", "example of text", "justification. "],
Solution().fullJustify,
words=["This", "is", "an", "example", "of", "text", "justification."],
maxWidth=16)
assert_value(["What must be", "acknowledgment ", "shall be "],
Solution().fullJustify,
words=["What", "must", "be", "acknowledgment", "shall", "be"],
maxWidth=16)
assert_value([
"Science is what we", "understand well", "enough to explain to",
"a computer. Art is", "everything else we", "do "
],
Solution().fullJustify,
words=[
"Science", "is", "what", "we", "understand", "well", "enough",
