├── .idea ├── .gitignore ├── vcs.xml ├── modules.xml ├── misc.xml ├── LeetCode.iml └── inspectionProfiles │ └── Project_Default.xml ├── 21-30 ├── 27. Remove_Element.py ├── 26. Remove_Duplicates_from_Sorted_Array.py ├── 28. Implement_strStr().py ├── 23. Merge_k_Sorted_Lists.py ├── 22. Generate_Parentheses.py ├── 21. Merge_Two_Sorted_Lists.py ├── 29. Divide_Two_Integers.py ├── 24. Swap_Nodes_in_Pairs.py ├── 25. Reverse_Nodes_in_k-Group.py └── 30. Substring with Concatenation of All Words.py ├── 1-10 ├── 9.Palindrome_Number.py ├── 7.Reverse_Integer.py ├── 8.String_to_Integer_(atoi).py ├── 1.Two_Sum.py ├── 6.ZigZag_Conversion.py ├── 4.Median_of_Two_Sorted_Arrays.py ├── 5.Longest_Palindromic_Substring.py ├── 3.Longest_Substring_Without_Repeating_Characters.py ├── 2.Add_Two_Numbers.py └── 10.Regular Expression Matching.py ├── 31-40 ├── 31. Next Permutation.py ├── 35. Search Insert Position.py ├── 38. Count and Say.py ├── 36. Valid Sudoku.py ├── 33. Search in Rotated Sorted Array.py ├── 34. Find First and Last Position of Element in Sorted Array.py ├── 37. Sudoku Solver.py └── 32. Longest Valid Parentheses.py ├── 11-20 ├── 20.Valid_Parentheses.py ├── 12.Integer to Roman.py ├── 14.Longest_Common_Prefix.py ├── 17.Letter_Combinations_of_a_Phone_Number.py ├── 19.Remove_Nth_Node_From_End_of_List.py ├── 13.Roman_to_Integer.py ├── 18.4Sum.py ├── 11.Container_With_Most_Water.py ├── 16.3Sum_Closest.py └── 15.3Sum.py └── README.md /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /workspace.xml 3 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | -------------------------------------------------------------------------------- /.idea/LeetCode.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | -------------------------------------------------------------------------------- /21-30/27. Remove_Element.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def removeElement(self, nums, val): 3 | """ 4 | :type nums: List[int] 5 | :type val: int 6 | :rtype: int 7 | """ 8 | # if len(nums) == 0: return 0 9 | 10 | 11 | point = 0 12 | for i in range(len(nums)): 13 | if nums[i] == val: continue 14 | nums[point] = nums[i] 15 | point += 1 16 | return point 17 | 18 | 19 | 20 | if __name__ == '__main__': 21 | print(Solution().removeElement([], 3)) -------------------------------------------------------------------------------- /1-10/9.Palindrome_Number.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isPalindrome(self, x): 3 | """ 4 | :type x: int 5 | :rtype: bool 6 | """ 7 | if x < 0: return False 8 | if x == 0: return True 9 | 10 | ori_num = x 11 | pali_num = 0 12 | while x != 0: 13 | pali_num = pali_num * 10 + x % 10 14 | x //= 10 15 | if ori_num == pali_num: return True 16 | return False 17 | 18 | 19 | if __name__ == '__main__': 20 | s = Solution() 21 | result = s.isPalindrome(121) 22 | print(result) -------------------------------------------------------------------------------- /.idea/inspectionProfiles/Project_Default.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 14 | -------------------------------------------------------------------------------- /21-30/26. Remove_Duplicates_from_Sorted_Array.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def removeDuplicates(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | point = 0 8 | cur_index = 1 9 | while cur_index < len(nums): 10 | if nums[cur_index] == nums[point]: 11 | cur_index += 1 12 | continue 13 | point += 1 14 | nums[point] = nums[cur_index] 15 | return point + 1 16 | 17 | if __name__ == '__main__': 18 | result = Solution().removeDuplicates([0,0,1,1,1,2,2,3,3,4]) 19 | print(result) -------------------------------------------------------------------------------- /21-30/28. Implement_strStr().py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def strStr(self, haystack, needle): 3 | """ 4 | :type haystack: str 5 | :type needle: str 6 | :rtype: int 7 | """ 8 | if len(needle) == 0: return 0 9 | if len(needle) > len(haystack): return -1 10 | if len(needle) == len(haystack) and needle != haystack: return -1 11 | 12 | for i in range(len(haystack) - len(needle) + 1): 13 | if haystack[i:i + len(needle)] == needle: 14 | return i 15 | return -1 16 | 17 | 18 | 19 | if __name__ == '__main__': 20 | print(Solution().strStr("hello", "ll")) -------------------------------------------------------------------------------- /31-40/31. Next Permutation.py: -------------------------------------------------------------------------------- 1 | # 这不是我的code... 思路错了累坏了不想写了 2 | class Solution(object): 3 | def nextPermutation(self, nums): 4 | n = len(nums) 5 | if n<2: return nums 6 | i = n-1 7 | while i>0 and nums[i-1]>=nums[i]: 8 | i -= 1 9 | if i==0 and nums[i]==max(nums): 10 | return nums.reverse() 11 | else: 12 | j = n-1 13 | while j>i-1 and nums[j]<=nums[i-1]: 14 | j -= 1 15 | temp = nums[i-1] 16 | nums[i-1] = nums[j] 17 | nums[j] = temp 18 | re = nums[i:] 19 | for h in range (len(re)): 20 | nums[n-1-h] = re[h] 21 | return nums -------------------------------------------------------------------------------- /1-10/7.Reverse_Integer.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def reverse(self, x): 3 | """ 4 | :type x: int 5 | :rtype: int 6 | """ 7 | if x == 0: return x 8 | 9 | neg = False 10 | if x < 0: 11 | neg = True 12 | x = -x 13 | 14 | result = 0 15 | while x != 0: 16 | x_remain = x % 10 17 | result = result * 10 + x_remain 18 | x = x // 10 19 | 20 | if neg == True: result = -result 21 | 22 | if result < -(2**31) or result > 2**31 - 1: return 0 23 | 24 | return result 25 | 26 | 27 | 28 | 29 | 30 | 31 | if __name__ == '__main__': 32 | s = Solution() 33 | result = s.reverse(120) 34 | print(result) -------------------------------------------------------------------------------- /21-30/23. Merge_k_Sorted_Lists.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | class ListNode(object): 3 | def __init__(self, val=0, next=None): 4 | self.val = val 5 | self.next = next 6 | class Solution(object): 7 | def mergeKLists(self, lists): 8 | """ 9 | :type lists: List[ListNode] 10 | :rtype: ListNode 11 | """ 12 | nums = [] 13 | for List in lists: 14 | while List != None: 15 | nums.append(List.val) 16 | List = List.next 17 | nums = sorted(nums) 18 | head = point = ListNode(0) 19 | for i in range(len(nums)): 20 | point.next = ListNode(nums[i]) 21 | point = point.next 22 | return head.next 23 | 24 | 25 | 26 | if __name__ == '__main__': 27 | pass -------------------------------------------------------------------------------- /31-40/35. Search Insert Position.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def searchInsert(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: int 7 | """ 8 | if len(nums) == 0: return 0 9 | if target < nums[0]: return 0 10 | if target > nums[-1]: return len(nums) 11 | 12 | left, right = 0, len(nums) - 1 13 | while left < right: 14 | mid = (left + right) // 2 15 | if nums[mid] < target: left = mid + 1 16 | elif nums[mid] > target: right = mid - 1 17 | else: return mid 18 | 19 | if nums[left] == target: return left 20 | if nums[left] < target: return left + 1 21 | if nums[left] > target: return left 22 | 23 | 24 | if __name__ == '__main__': 25 | print(Solution().searchInsert([1,3,5,6], 0)) -------------------------------------------------------------------------------- /21-30/22. Generate_Parentheses.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def generateParenthesis(self, n): 3 | """ 4 | :type n: int 5 | :rtype: List[str] 6 | """ 7 | stack = [['', 0, 0, n, n]] 8 | ans = [] 9 | while len(stack) != 0: 10 | [cur_path, l, r, remain_l, remain_r] = stack.pop() 11 | if remain_l == 0 and remain_r == 0: 12 | ans.append(cur_path) 13 | elif remain_l == 0: 14 | ans.append(cur_path + ')' * remain_r) 15 | elif remain_l > 0 and remain_r > 0: 16 | if l > r: 17 | stack.append([cur_path + ')', l, r + 1, remain_l, remain_r - 1]) 18 | stack.append([cur_path + '(', l + 1, r, remain_l - 1, remain_r]) 19 | return ans 20 | 21 | 22 | 23 | if __name__ == '__main__': 24 | s = Solution() 25 | result = s.generateParenthesis(3) 26 | print(result) -------------------------------------------------------------------------------- /1-10/8.String_to_Integer_(atoi).py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def myAtoi(self, str): 3 | """ 4 | :type str: str 5 | :rtype: int 6 | """ 7 | if len(str) == 0: return 0 8 | 9 | str = str.strip() 10 | if len(str) == 0: return 0 11 | 12 | neg = False 13 | if str[0] == '+': str = str[1:] 14 | elif str[0] == '-': 15 | neg = True 16 | str = str[1:] 17 | 18 | num = 0 19 | for index in range(len(str)): 20 | if 48 <= ord(str[index]) <= 57: 21 | num = num * 10 + int(str[index]) 22 | else: 23 | break 24 | 25 | if neg: num = -num 26 | 27 | if num < -(2**31): return -(2**31) 28 | if num > 2**31 - 1: return 2**31 - 1 29 | 30 | return num 31 | 32 | 33 | 34 | if __name__ == '__main__': 35 | s = Solution() 36 | result = s.myAtoi("-91283472332") 37 | print(result) -------------------------------------------------------------------------------- /31-40/38. Count and Say.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def countAndSay(self, n): 3 | """ 4 | :type n: int 5 | :rtype: str 6 | """ 7 | if n == 0: return '' 8 | if n == 1: return '1' 9 | 10 | cur_str = '1' 11 | new_str = '' 12 | for i in range(1, n): 13 | cur_cnt = 1 14 | j = 0 15 | while j < len(cur_str) - 1: 16 | if cur_str[j + 1] == cur_str[j]: 17 | cur_cnt += 1 18 | else: 19 | new_str += str(cur_cnt) + cur_str[j] 20 | cur_cnt = 1 21 | j += 1 22 | new_str += str(cur_cnt) + cur_str[-1] 23 | cur_str = new_str 24 | new_str = '' 25 | return cur_str 26 | 27 | 28 | 29 | 30 | if __name__ == '__main__': 31 | print(Solution().countAndSay(3)) 32 | print(Solution().countAndSay(4)) 33 | print(Solution().countAndSay(5)) -------------------------------------------------------------------------------- /11-20/20.Valid_Parentheses.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isValid(self, s): 3 | """ 4 | :type s: str 5 | :rtype: bool 6 | """ 7 | match = { 8 | "}" : "{", 9 | ")" : "(", 10 | "]" : "[" 11 | } 12 | 13 | stack = [] 14 | for i in range(len(s)): 15 | if len(stack) == 0: 16 | if s[i] in match.keys(): return False 17 | stack.append(s[i]) 18 | else: 19 | if s[i] in match.keys(): 20 | if stack[-1] == match[s[i]]: 21 | stack.pop() 22 | else: 23 | return False 24 | else: 25 | stack.append(s[i]) 26 | if len(stack) != 0: return False 27 | return True 28 | 29 | 30 | 31 | 32 | if __name__ == '__main__': 33 | s = Solution() 34 | result = s.isValid("{[]}") 35 | print(result) -------------------------------------------------------------------------------- /11-20/12.Integer to Roman.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def intToRoman(self, num): 3 | """ 4 | :type num: int 5 | :rtype: str 6 | """ 7 | thousand = ['M', 'MM', 'MMM'] 8 | hundred = ['C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'] 9 | ten = ['X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'] 10 | units = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'] 11 | 12 | romanStr = '' 13 | n = num // 1000 14 | num = num % 1000 15 | if n != 0:romanStr += thousand[n - 1] 16 | 17 | n = num // 100 18 | num = num % 100 19 | if n != 0:romanStr += hundred[n - 1] 20 | 21 | n = num // 10 22 | num = num % 10 23 | if n != 0:romanStr += ten[n - 1] 24 | 25 | n = num 26 | if n != 0:romanStr += units[n - 1] 27 | 28 | return romanStr 29 | 30 | 31 | 32 | if __name__ == '__main__': 33 | s = Solution() 34 | result = s.intToRoman(58) 35 | print(result) -------------------------------------------------------------------------------- /11-20/14.Longest_Common_Prefix.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def longestCommonPrefix(self, strs): 3 | """ 4 | :type strs: List[str] 5 | :rtype: str 6 | """ 7 | if len(strs) == 0: return "" 8 | if len(strs) == 1: return strs[0] 9 | 10 | point = 0 11 | longest_common = "" 12 | while True: 13 | if point < len(strs[0]): 14 | cur_char = strs[0][point] 15 | else: return longest_common 16 | all_same = True 17 | for i in range(1, len(strs)): 18 | if point < len(strs[i]) and strs[i][point] == cur_char: continue 19 | else: 20 | all_same = False 21 | break 22 | if all_same == True: 23 | longest_common += cur_char 24 | point += 1 25 | else: return longest_common 26 | 27 | 28 | 29 | 30 | 31 | 32 | if __name__ == '__main__': 33 | s = Solution() 34 | result = s.longestCommonPrefix(["flower","flow","flight"]) 35 | print(result) -------------------------------------------------------------------------------- /1-10/1.Two_Sum.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def twoSum(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: List[int] 7 | """ 8 | sort_nums = sorted(nums) 9 | left, right = 0, len(sort_nums) - 1 10 | # while sort_nums[right] > target: right -= 1 11 | while left < right: 12 | num_sum = sort_nums[left] + sort_nums[right] 13 | if num_sum > target: right -= 1 14 | elif num_sum < target: left += 1 15 | elif num_sum == target: 16 | if sort_nums[left] == sort_nums[right]: 17 | index1 = nums.index(sort_nums[left]) 18 | del nums[index1] 19 | index2 = nums.index(sort_nums[right]) + 1 20 | return [index1, index2] 21 | else: 22 | return [nums.index(sort_nums[left]), nums.index(sort_nums[right])] 23 | 24 | if __name__ == '__main__': 25 | # nums = [2, 7, 11, 15] 26 | nums = [3, 2, 4] 27 | target = 6 28 | 29 | s = Solution() 30 | result = s.twoSum(nums, target) 31 | print(result) 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /1-10/6.ZigZag_Conversion.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def convert(self, s, numRows): 3 | """ 4 | :type s: str 5 | :type numRows: int 6 | :rtype: str 7 | """ 8 | if len(s) <= 0: return "" 9 | if numRows == 1 or numRows >= len(s): return s 10 | if numRows > len(s): return s 11 | 12 | 13 | result = "" 14 | for i in range(numRows): 15 | if (i == 0) or (i == numRows - 1): 16 | x = 0 17 | while i + (numRows + (numRows - 2)) * x < len(s): 18 | result += s[(numRows + (numRows - 2)) * x + i] 19 | x += 1 20 | else: 21 | x = 0 22 | while True: 23 | if i + (numRows + (numRows - 2)) * x < len(s): 24 | result += s[i + (numRows + (numRows - 2)) * x] 25 | else: 26 | break 27 | if i + (numRows + (numRows - 2)) * (x + 1) - i * 2 < len(s): 28 | result += s[i + (numRows + (numRows - 2)) * (x + 1) - i * 2] 29 | x += 1 30 | return result 31 | 32 | 33 | 34 | if __name__ == '__main__': 35 | s = Solution() 36 | result = s.convert("AB",1) 37 | print(result) -------------------------------------------------------------------------------- /11-20/17.Letter_Combinations_of_a_Phone_Number.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def __init__(self): 3 | self.dict = { 4 | "2": ['a', 'b', 'c'], 5 | "3": ['d', 'e', 'f'], 6 | "4": ['g', 'h', 'i'], 7 | "5": ['j', 'k', 'l'], 8 | "6": ['m', 'n', 'o'], 9 | "7": ['p', 'q', 'r', 's'], 10 | "8": ['t', 'u', 'v'], 11 | "9": ['w', 'x', 'y', 'z'] 12 | } 13 | 14 | def get_string(self, num_str): 15 | if len(num_str) == 0: return [""] 16 | if len(num_str) == 1: return self.dict[num_str[0]] 17 | 18 | final_result = [] 19 | cur_str_cand = self.dict[num_str[0]] 20 | for i in range(len(cur_str_cand)): 21 | result = self.get_string(num_str[1:]) 22 | for j in range(len(result)): 23 | final_result.append(cur_str_cand[i] + result[j]) 24 | return final_result 25 | 26 | def letterCombinations(self, digits): 27 | """ 28 | :type digits: str 29 | :rtype: List[str] 30 | """ 31 | if len(digits) == 0: return [] 32 | 33 | return self.get_string(digits) 34 | 35 | 36 | 37 | 38 | 39 | if __name__ == '__main__': 40 | s = Solution() 41 | result = s.letterCombinations("23") 42 | print(result) -------------------------------------------------------------------------------- /1-10/4.Median_of_Two_Sorted_Arrays.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findMedianSortedArrays(self, nums1, nums2): 3 | def getKthElement(k): 4 | index1, index2 = 0, 0 5 | while True: 6 | # 特殊情况 7 | if index1 == m: 8 | return nums2[index2 + k - 1] 9 | if index2 == n: 10 | return nums1[index1 + k - 1] 11 | if k == 1: 12 | return min(nums1[index1], nums2[index2]) 13 | 14 | # 正常情况 15 | newIndex1 = min(index1 + k // 2 - 1, m - 1) 16 | newIndex2 = min(index2 + k // 2 - 1, n - 1) 17 | pivot1, pivot2 = nums1[newIndex1], nums2[newIndex2] 18 | if pivot1 <= pivot2: 19 | k -= newIndex1 - index1 + 1 20 | index1 = newIndex1 + 1 21 | else: 22 | k -= newIndex2 - index2 + 1 23 | index2 = newIndex2 + 1 24 | 25 | m, n = len(nums1), len(nums2) 26 | totalLength = m + n 27 | if totalLength % 2 == 1: 28 | return getKthElement((totalLength + 1) // 2) 29 | else: 30 | return (getKthElement(totalLength // 2) + getKthElement(totalLength // 2 + 1)) / 2 31 | 32 | 33 | 34 | if __name__ == '__main__': 35 | s = Solution() 36 | result = s.findMedianSortedArrays([1, 3], [2]) 37 | print(result) -------------------------------------------------------------------------------- /1-10/5.Longest_Palindromic_Substring.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def longestPalindrome(self, s): 3 | """ 4 | :type s: str 5 | :rtype: str 6 | """ 7 | if len(s) == 0: return "" 8 | if len(s) == 1: return s 9 | 10 | max_length = 0 11 | max_sub_string = "" 12 | 13 | i = 0 14 | while i < len(s) - 1: 15 | if i % 1 == 0.5: 16 | left, right = int(i - 0.5), int(i + 0.5) 17 | else: 18 | left, right = int(i), int(i) 19 | cnt = 0 20 | while left >= 0 and right <= len(s) - 1: 21 | if s[left] == s[right]: 22 | left -= 1 23 | right += 1 24 | cnt += 1 25 | else: 26 | break 27 | 28 | if i % 1 == 0.5 and cnt * 2 > max_length: 29 | max_length = cnt * 2 30 | max_sub_string = s[left + 1: right] 31 | if i % 1 == 0 and cnt * 2 - 1 > max_length: 32 | max_length = cnt * 2 - 1 33 | max_sub_string = s[left + 1: right] 34 | 35 | if (len(s) - 1 - i) * 2 + 1 < max_length: return max_sub_string 36 | i += 0.5 37 | 38 | return max_sub_string 39 | 40 | 41 | 42 | 43 | 44 | 45 | if __name__ == '__main__': 46 | a = ['a' for _ in range(1000)] 47 | s = Solution() 48 | result = s.longestPalindrome(a) 49 | print(len(result)) -------------------------------------------------------------------------------- /11-20/19.Remove_Nth_Node_From_End_of_List.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | class ListNode(object): 3 | def __init__(self, val=0, next=None): 4 | self.val = val 5 | self.next = next 6 | 7 | def create_link(nums): 8 | head = ListNode(None) 9 | cur_node = head 10 | 11 | for i in range(len(nums)): 12 | cur_node.next = ListNode(nums[i]) 13 | cur_node = cur_node.next 14 | 15 | return head.next 16 | 17 | def check_link(link): 18 | while link != None: 19 | print(link.val, end=' ') 20 | link = link.next 21 | print() 22 | 23 | class Solution(object): 24 | def removeNthFromEnd(self, head, n): 25 | """ 26 | :type head: ListNode 27 | :type n: int 28 | :rtype: ListNode 29 | """ 30 | 31 | front = head 32 | for i in range(1, n + 1): 33 | front = front.next 34 | if front == None: return head.next 35 | # if front.next == None: return head.next 36 | 37 | rear = head 38 | while front.next != None: 39 | front = front.next 40 | rear = rear.next 41 | if rear.next != None: 42 | rear.next = rear.next.next 43 | else: 44 | rear.next = None 45 | 46 | return head 47 | 48 | 49 | 50 | if __name__ == '__main__': 51 | s = Solution() 52 | linked_list = create_link([1, 2]) 53 | check_link(linked_list) 54 | result = s.removeNthFromEnd(linked_list, 2) 55 | check_link(result) -------------------------------------------------------------------------------- /1-10/3.Longest_Substring_Without_Repeating_Characters.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def lengthOfLongestSubstring(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | if len(s) == 0: return 0 8 | if len(s) == 1: return 1 9 | 10 | repeat_word_dict = {} 11 | max_cnt = 0 12 | 13 | cur_left = 0 14 | cur_pos = 0 15 | cur_cnt = 0 16 | while cur_left < len(s): 17 | if s[cur_pos] not in repeat_word_dict.keys(): 18 | repeat_word_dict[s[cur_pos]] = cur_pos 19 | else: 20 | if repeat_word_dict[s[cur_pos]] < cur_left: 21 | repeat_word_dict[s[cur_pos]] = cur_pos 22 | else: 23 | cur_cnt = cur_pos - cur_left 24 | if cur_cnt > max_cnt: max_cnt = cur_cnt 25 | cur_left = repeat_word_dict[s[cur_pos]] + 1 26 | cur_cnt = cur_pos - cur_left + 1 27 | repeat_word_dict[s[cur_pos]] = cur_pos 28 | cur_pos += 1 29 | if cur_pos == len(s): 30 | cur_cnt = cur_pos - cur_left 31 | if cur_cnt > max_cnt: max_cnt = cur_cnt 32 | return max_cnt 33 | 34 | if cur_left == len(s): 35 | if cur_cnt > max_cnt: max_cnt = cur_cnt 36 | 37 | return max_cnt 38 | 39 | 40 | 41 | 42 | if __name__ == '__main__': 43 | s = Solution() 44 | result = s.lengthOfLongestSubstring("pwwkew") 45 | print(result) -------------------------------------------------------------------------------- /11-20/13.Roman_to_Integer.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def romanToInt(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | thousand = ['M', 'MM', 'MMM'] 8 | hundred = ['C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'] 9 | ten = ['X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'] 10 | units = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'] 11 | 12 | intNum = 0 13 | roman = s 14 | for i in range(len(thousand) - 1, -1, -1): 15 | if roman.startswith(thousand[i]): 16 | intNum += 1000 * (i + 1) 17 | ln = len(thousand[i]) 18 | roman = roman[ln:] 19 | break 20 | 21 | for i in range(len(hundred) - 1, -1, -1): 22 | if roman.startswith(hundred[i]): 23 | intNum += 100 * (i + 1) 24 | ln = len(hundred[i]) 25 | roman = roman[ln:] 26 | break 27 | 28 | for i in range(len(ten) - 1, -1, -1): 29 | if roman.startswith(ten[i]): 30 | intNum += 10 * (i + 1) 31 | ln = len(ten[i]) 32 | roman = roman[ln:] 33 | break 34 | 35 | for i in range(len(units) - 1, -1, -1): 36 | if roman.startswith(units[i]): 37 | intNum += 1 * (i + 1) 38 | ln = len(units[i]) 39 | roman = roman[ln:] 40 | break 41 | 42 | return intNum 43 | 44 | if __name__ == '__main__': 45 | s = Solution() 46 | result = s.romanToInt("III") 47 | print(result) 48 | -------------------------------------------------------------------------------- /21-30/21. Merge_Two_Sorted_Lists.py: -------------------------------------------------------------------------------- 1 | #Definition for singly-linked list. 2 | class ListNode(object): 3 | def __init__(self, val=0, next=None): 4 | self.val = val 5 | self.next = next 6 | 7 | def create_link(nums): 8 | head = ListNode(None) 9 | cur_node = head 10 | 11 | for i in range(len(nums)): 12 | cur_node.next = ListNode(nums[i]) 13 | cur_node = cur_node.next 14 | 15 | return head.next 16 | 17 | def check_link(link): 18 | while link != None: 19 | print(link.val, end=' ') 20 | link = link.next 21 | print() 22 | 23 | class Solution(object): 24 | def mergeTwoLists(self, l1, l2): 25 | """ 26 | :type l1: ListNode 27 | :type l2: ListNode 28 | :rtype: ListNode 29 | """ 30 | 31 | head = ListNode(0) 32 | cur_point = head 33 | while l1 != None and l2 != None: 34 | if l1.val < l2.val: 35 | cur_point.next = l1 36 | cur_point = cur_point.next 37 | l1 = l1.next 38 | else: 39 | cur_point.next = l2 40 | cur_point = cur_point.next 41 | l2 = l2.next 42 | while l1 != None: 43 | cur_point.next = l1 44 | cur_point = cur_point.next 45 | l1 = l1.next 46 | while l2 != None: 47 | cur_point.next = l2 48 | cur_point = cur_point.next 49 | l2 = l2.next 50 | cur_point.next = None 51 | return head.next 52 | 53 | 54 | 55 | if __name__ == '__main__': 56 | l1 = create_link([1, 2, 4]) 57 | l2 = create_link([1, 3, 4]) 58 | check_link(l1) 59 | check_link(l2) 60 | s = Solution() 61 | result = s.mergeTwoLists(l1, l2) 62 | check_link(result) -------------------------------------------------------------------------------- /21-30/29. Divide_Two_Integers.py: -------------------------------------------------------------------------------- 1 | import math 2 | class Solution(object): 3 | def divide(self, dividend, divisor): 4 | """ 5 | :type dividend: int 6 | :type divisor: int 7 | :rtype: int 8 | """ 9 | if dividend == 0: return 0 10 | 11 | result_neg = False 12 | if dividend < 0 and divisor > 0 or dividend > 0 and divisor < 0: result_neg = True 13 | dividend, divisor = math.fabs(dividend), math.fabs(divisor) 14 | 15 | cnt = 0 16 | cur_sum = 0 17 | cur_cnt = 0 18 | cur_sub_gap = dividend 19 | 20 | while True: 21 | if cur_sum == 0: 22 | if divisor > cur_sub_gap: 23 | cnt = cnt if result_neg == False else 0-cnt 24 | cnt = 2 ** 31 - 1 if cnt > 2 ** 31 - 1 else cnt 25 | return cnt 26 | cur_sum += divisor 27 | cur_cnt += 1 28 | cur_sub_gap -= divisor 29 | continue 30 | while cur_sum + cur_sum <= cur_sub_gap: 31 | cur_sub_gap -= cur_sum 32 | cur_sum += cur_sum 33 | cur_cnt += cur_cnt 34 | cnt += cur_cnt 35 | cur_cnt = 0 36 | cur_sum = 0 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | # while cur_sum < dividend: 46 | # if cur_sum + cur_sum <= dividend: 47 | # cur_sum += cur_sum 48 | # cnt += cnt 49 | # elif cur_sum + divisor <= dividend: 50 | # cur_sum += divisor 51 | # cnt += 1 52 | # else: break 53 | # if result_neg == True: cnt = 0 - cnt 54 | # return cnt 55 | 56 | 57 | 58 | 59 | if __name__ == '__main__': 60 | print(Solution().divide(10, 3)) -------------------------------------------------------------------------------- /1-10/2.Add_Two_Numbers.py: -------------------------------------------------------------------------------- 1 | import copy 2 | 3 | # Definition for singly-linked list. 4 | class ListNode: 5 | def __init__(self, x): 6 | self.val = x 7 | self.next = None 8 | 9 | def create_link(nums): 10 | head = ListNode(None) 11 | cur_node = head 12 | 13 | for i in range(len(nums)): 14 | cur_node.next = ListNode(nums[i]) 15 | cur_node = cur_node.next 16 | 17 | return head.next 18 | 19 | def check_link(link): 20 | while link != None: 21 | print(link.val, end=' ') 22 | link = link.next 23 | print() 24 | 25 | 26 | class Solution(object): 27 | def get_nums(self, link): 28 | result = 0 29 | multiple = 1 30 | while link != None: 31 | result += link.val * multiple 32 | multiple *= 10 33 | link = link.next 34 | return result 35 | 36 | def create_link(self, nums): 37 | link_nums = [] 38 | if nums == 0: link_nums.append(0) 39 | else: 40 | while nums != 0: 41 | link_nums.append(nums % 10) 42 | nums //= 10 43 | 44 | head = ListNode(None) 45 | cur_node = head 46 | for i in range(len(link_nums)): 47 | cur_node.next = ListNode(link_nums[i]) 48 | cur_node = cur_node.next 49 | return head.next 50 | 51 | def addTwoNumbers(self, l1, l2): 52 | """ 53 | :type l1: ListNode 54 | :type l2: ListNode 55 | :rtype: ListNode 56 | """ 57 | num1 = self.get_nums(l1) 58 | num2 = self.get_nums(l2) 59 | return self.create_link(num1 + num2) 60 | 61 | if __name__ == '__main__': 62 | l1 = create_link([2, 4, 3]) 63 | l2 = create_link([5, 6, 4]) 64 | 65 | s = Solution() 66 | result = s.addTwoNumbers(l1, l2) 67 | check_link(result) 68 | -------------------------------------------------------------------------------- /31-40/36. Valid Sudoku.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isValidSudoku(self, board): 3 | """ 4 | :type board: List[List[str]] 5 | :rtype: bool 6 | """ 7 | 8 | for i in range(9): 9 | num_dict = [0 for _ in range(10)] 10 | for j in range(9): 11 | if board[i][j] == '.': continue 12 | if num_dict[int(board[i][j])] == 1: return False 13 | num_dict[int(board[i][j])] += 1 14 | 15 | for j in range(9): 16 | num_dict = [0 for _ in range(10)] 17 | for i in range(9): 18 | if board[i][j] == '.': continue 19 | if num_dict[int(board[i][j])] == 1: return False 20 | num_dict[int(board[i][j])] += 1 21 | 22 | for i in [0, 3, 6]: 23 | for j in [0, 3, 6]: 24 | num_dict = [0 for _ in range(10)] 25 | for k in range(3): 26 | for v in range(3): 27 | if board[i + k][j + v] == '.': continue 28 | if num_dict[int(board[i + k][j + v])] == 1: return False 29 | num_dict[int(board[i + k][j + v])] += 1 30 | return True 31 | 32 | 33 | 34 | 35 | if __name__ == '__main__': 36 | result = Solution().isValidSudoku( 37 | [[".", ".", ".", ".", "5", ".", ".", "1", "."], 38 | [".", "4", ".", "3", ".", ".", ".", ".", "."], 39 | [".", ".", ".", ".", ".", "3", ".", ".", "1"], 40 | ["8", ".", ".", ".", ".", ".", ".", "2", "."], 41 | [".", ".", "2", ".", "7", ".", ".", ".", "."], 42 | [".", "1", "5", ".", ".", ".", ".", ".", "."], 43 | [".", ".", ".", ".", ".", "2", ".", ".", "."], 44 | [".", "2", ".", "9", ".", ".", ".", ".", "."], 45 | [".", ".", "4", ".", ".", ".", ".", ".", "."]] 46 | ) 47 | print(result) -------------------------------------------------------------------------------- /11-20/18.4Sum.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def fourSum(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: List[List[int]] 7 | """ 8 | if len(nums) < 4: return [] 9 | if len(nums) == 4: 10 | if sum(nums) == target: return [nums] 11 | return [] 12 | 13 | nums = sorted(nums) 14 | 15 | final_result = [] 16 | for i in range(len(nums) - 3): 17 | if i > 0 and nums[i] == nums[i - 1]: continue 18 | if sum(nums[i: i + 4]) > target: break 19 | if sum(nums[-4:]) < target: break 20 | 21 | three_target = target - nums[i] 22 | 23 | for j in range(i + 1, len(nums) - 2): 24 | if j > i + 1 and nums[j] == nums[j - 1]: continue 25 | if sum(nums[j:j + 3]) > three_target: break 26 | if sum(nums[-3:]) < three_target: break 27 | 28 | two_target = three_target - nums[j] 29 | 30 | left, right = j + 1, len(nums) - 1 31 | while left < right: 32 | if nums[left] + nums[right] == two_target: 33 | final_result.append([nums[i], nums[j], nums[left], nums[right]]) 34 | left += 1 35 | right -= 1 36 | while left < right and nums[left] == nums[left - 1]: left += 1 37 | while left < right and nums[right] == nums[right + 1]: right -= 1 38 | elif nums[left] + nums[right] < two_target: 39 | left += 1 40 | elif nums[left] + nums[right] > two_target: 41 | right -= 1 42 | return final_result 43 | 44 | if __name__ == '__main__': 45 | s = Solution() 46 | result = s.fourSum([1, 0, -1, 0, -2, 2], 0) 47 | print(result) 48 | -------------------------------------------------------------------------------- /31-40/33. Search in Rotated Sorted Array.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def sub_search(self, nums, left, right, target): 3 | if left > right: return -1 4 | if left == right: return left if nums[left] == target else -1 5 | 6 | if nums[left] <= nums[right]: 7 | while left <= right: 8 | mid = (left + right) // 2 9 | if nums[mid] < target: left = mid + 1 10 | elif nums[mid] > target: right = mid - 1 11 | else: return mid 12 | return -1 13 | else: 14 | if left + 1 == right: 15 | if target in nums[left: right + 1]: 16 | return left if nums[left] == target else right 17 | return -1 18 | mid = (left + right) // 2 19 | if nums[mid] == target: return mid 20 | if nums[mid] > nums[left]: 21 | if nums[left] <= target < nums[mid]: 22 | return self.sub_search(nums, left, mid - 1, target) 23 | else: 24 | return self.sub_search(nums, mid + 1, right, target) 25 | else: 26 | if target < nums[mid]: return self.sub_search(nums, left, mid - 1, target) 27 | else: 28 | if target > nums[right]: 29 | return self.sub_search(nums, left, mid - 1, target) 30 | return self.sub_search(nums, mid + 1, right, target) 31 | 32 | 33 | def search(self, nums, target): 34 | """ 35 | :type nums: List[int] 36 | :type target: int 37 | :rtype: int 38 | """ 39 | if len(nums) == 0: return -1 40 | if len(nums) == 1: return 0 if nums[0] == target else -1 41 | if len(nums) == 2: 42 | if target in nums: return nums.index(target) 43 | return -1 44 | return self.sub_search(nums, 0, len(nums) - 1, target) 45 | 46 | 47 | 48 | 49 | 50 | if __name__ == '__main__': 51 | print(Solution().search([5,1,2,3,4], 1)) -------------------------------------------------------------------------------- /21-30/24. Swap_Nodes_in_Pairs.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | class ListNode(object): 3 | def __init__(self, val=0, next=None): 4 | self.val = val 5 | self.next = next 6 | 7 | def create_link(nums): 8 | head = ListNode(None) 9 | cur_node = head 10 | 11 | for i in range(len(nums)): 12 | cur_node.next = ListNode(nums[i]) 13 | cur_node = cur_node.next 14 | 15 | return head.next 16 | 17 | def check_link(link): 18 | while link != None: 19 | print(link.val, end=' ') 20 | link = link.next 21 | print() 22 | 23 | class Solution(object): 24 | def swapPairs(self, head): 25 | """ 26 | :type head: ListNode 27 | :rtype: ListNode 28 | """ 29 | if head == None: return None 30 | if head.next == None: return head 31 | if head.next.next == None: 32 | new_head = head.next 33 | new_head.next = head 34 | new_head.next.next = None 35 | return new_head 36 | 37 | 38 | new_head = ListNode(0) 39 | new_head.next = head 40 | 41 | font_point = rear_point = new_head 42 | for i in range(3): font_point = font_point.next 43 | while font_point != None: 44 | tmp = rear_point.next 45 | rear_point.next = rear_point.next.next 46 | rear_point.next.next = tmp 47 | tmp.next = font_point 48 | 49 | rear_point = rear_point.next.next 50 | if font_point.next != None: 51 | if font_point.next.next != None: 52 | font_point = font_point.next.next 53 | else: 54 | rear_point.next = rear_point.next.next 55 | rear_point.next.next = font_point 56 | font_point.next = None 57 | return new_head.next 58 | else: 59 | return new_head.next 60 | 61 | 62 | 63 | 64 | if __name__ == '__main__': 65 | l = create_link([1, 2, 3, 4]) 66 | s = Solution() 67 | result = s.swapPairs(l) 68 | check_link(result) -------------------------------------------------------------------------------- /21-30/25. Reverse_Nodes_in_k-Group.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | class ListNode: 3 | def __init__(self, x): 4 | self.val = x 5 | self.next = None 6 | 7 | def create_link(nums): 8 | head = ListNode(None) 9 | cur_node = head 10 | 11 | for i in range(len(nums)): 12 | cur_node.next = ListNode(nums[i]) 13 | cur_node = cur_node.next 14 | 15 | return head.next 16 | 17 | def check_link(link): 18 | while link != None: 19 | print(link.val, end=' ') 20 | link = link.next 21 | print() 22 | 23 | 24 | class Solution(object): 25 | def reverse_linkList(self, head, rear): 26 | new_head = ListNode(0) 27 | new_rear = head 28 | 29 | while head != rear: 30 | tmp_point = head.next 31 | head.next = new_head.next 32 | new_head.next = head 33 | head = tmp_point 34 | head.next = new_head.next 35 | new_head.next = head 36 | return new_head.next, new_rear 37 | 38 | def reverseKGroup(self, head, k): 39 | """ 40 | :type head: ListNode 41 | :type k: int 42 | :rtype: ListNode 43 | """ 44 | if k <= 1: return head 45 | 46 | new_head = ListNode(0) 47 | new_head.next = head 48 | 49 | font = rear = new_head 50 | for i in range(k): 51 | if font != None: font = font.next 52 | else: return head 53 | 54 | while True: 55 | cur_font = font.next 56 | sub_font, sub_rear = self.reverse_linkList(rear.next, font) 57 | rear.next = sub_font 58 | sub_rear.next = cur_font 59 | font = sub_rear 60 | 61 | for i in range(k): 62 | if font.next != None: 63 | font = font.next 64 | rear = rear.next 65 | else: return new_head.next 66 | 67 | 68 | 69 | if __name__ == '__main__': 70 | l = create_link([1, 2, 3, 4, 5]) 71 | check_link(l) 72 | s = Solution() 73 | result = s.reverseKGroup(l, 3) 74 | check_link(result) 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /31-40/34. Find First and Last Position of Element in Sorted Array.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def searchRange(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: List[int] 7 | """ 8 | if len(nums) == 0: return [-1, -1] 9 | if len(nums) == 1: return [0, 0] if target == nums[0] else [-1, -1] 10 | 11 | left, right = 0, len(nums) - 1 12 | target_point = -1 13 | while left <= right: 14 | mid = (left + right) // 2 15 | if nums[mid] < target: 16 | left = mid + 1 17 | elif nums[mid] > target: 18 | right = mid - 1 19 | else: 20 | target_point = mid 21 | break 22 | if target_point == -1: return [-1, -1] 23 | 24 | target_left, target_right = target_point, target_point 25 | if target_point < len(nums) - 1 and nums[target_point + 1] == target: 26 | left = target_point + 1 27 | right = len(nums) - 1 28 | while left <= right: 29 | mid = (left + right) // 2 30 | if nums[mid] == target: 31 | if mid < len(nums) - 1 and nums[mid + 1] == target: 32 | left = mid + 1 33 | else: 34 | target_right = mid 35 | break 36 | else: 37 | right = mid - 1 38 | if target_point > 0 and nums[target_point - 1] == target: 39 | left = 0 40 | right = target_point - 1 41 | while left <= right: 42 | mid = (left + right) // 2 43 | if nums[mid] == target: 44 | if mid > 0 and nums[mid - 1] == target: 45 | right = mid - 1 46 | else: 47 | target_left = mid 48 | break 49 | else: 50 | left = mid + 1 51 | return [target_left, target_right] 52 | 53 | 54 | 55 | 56 | if __name__ == '__main__': 57 | print(Solution().searchRange([5,7], 9)) -------------------------------------------------------------------------------- /11-20/11.Container_With_Most_Water.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def maxArea(self, height): 3 | """ 4 | :type height: List[int] 5 | :rtype: int 6 | """ 7 | if len(height) <= 1: return 0 8 | if len(height) == 2: return min(height) 9 | 10 | cur_water = min(height[0], height[-1]) * (len(height) - 1) 11 | left, right = 0, len(height) - 1 12 | max_water = cur_water 13 | 14 | while left < right: 15 | if height[left] < height[right]: 16 | cur_left_height = height[left] 17 | while left < right and height[left] <= cur_left_height: 18 | left += 1 19 | if left >= right: break 20 | cur_water = min(height[left], height[right]) * (right - left) 21 | max_water = cur_water if cur_water > max_water else max_water 22 | elif height[left] > height[right]: 23 | cur_right_height = height[right] 24 | while left < right and height[right] <= cur_right_height: 25 | right -= 1 26 | if right <= left: break 27 | cur_water = min(height[left], height[right]) * (right - left) 28 | max_water = cur_water if cur_water > max_water else max_water 29 | else: 30 | cur_tmp_left, cur_tmp_right = left, right 31 | while cur_tmp_left < cur_tmp_right: 32 | if height[cur_tmp_left] > height[left]: break 33 | if height[cur_tmp_right] > height[right]: break 34 | cur_tmp_left += 1 35 | cur_tmp_right -= 1 36 | if cur_tmp_left >= cur_tmp_right: break 37 | if height[cur_tmp_left] > height[left]: left = cur_tmp_left 38 | elif height[cur_tmp_right] > height[right]: right = cur_tmp_right 39 | cur_water = min((height[left], height[right])) * (right - left) 40 | max_water = cur_water if cur_water > max_water else max_water 41 | return max_water 42 | 43 | 44 | 45 | 46 | if __name__ == '__main__': 47 | s = Solution() 48 | result = s.maxArea([1, 8, 6, 2, 5, 4, 8, 3, 7]) 49 | print(result) -------------------------------------------------------------------------------- /1-10/10.Regular Expression Matching.py: -------------------------------------------------------------------------------- 1 | # this code is worong!!! 2 | 3 | class Solution(object): 4 | def match(self, s, p): 5 | pass 6 | 7 | def isMatch(self, s, p): 8 | """ 9 | :type s: str 10 | :type p: str 11 | :rtype: bool 12 | """ 13 | pure_falg = True 14 | for i in range(len(p)): 15 | if p[i] in ['.','*']: pure_falg = False 16 | if pure_falg == True: 17 | if pure_falg == s: return True 18 | return False 19 | 20 | 21 | if len(s) == 0 or len(p) == 0: return False 22 | 23 | if len(p) == 1: 24 | if s[0] == p[0] or p[0] == '.': return True 25 | return False 26 | if len(p) > 1: 27 | if p[1] != '*': 28 | if s[0] == p[0] or p[0] == '.': 29 | return self.isMatch(s[1:], p[1:]) 30 | else: 31 | return False 32 | else: 33 | if s[0] != p[0] and p[0] != '.': 34 | if len(p) == 2: return True 35 | else: 36 | return self.isMatch(s, p[2:]) 37 | elif p[0] == '.': 38 | if len(p) == 2: return True 39 | for i in range(len(s)): 40 | result = self.isMatch(s[i:], p[2:]) 41 | if result == True: return True 42 | return False 43 | elif s[0] == p[0]: 44 | if len(p) == 2: return True 45 | left, right = 0,0 46 | for i in range(1, len(s)): 47 | if s[i] == s[0]: 48 | right = i 49 | continue 50 | else: 51 | break 52 | if right == len(s) - 1: return True 53 | 54 | for i in range(left, right + 2): 55 | result = self.isMatch(s[i:], p[2:]) 56 | if result == True: return True 57 | return False 58 | 59 | 60 | if __name__ == '__main__': 61 | s = Solution() 62 | result = s.isMatch("issippi", "is*p*.") 63 | print(result) -------------------------------------------------------------------------------- /11-20/16.3Sum_Closest.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | class Solution(object): 4 | def two_sum(self, nums, target): 5 | left, right = 0, len(nums) - 1 6 | 7 | closest_gap = 2**32 8 | closest_nums = [] 9 | while left < right: 10 | if nums[left] * 2 > target: 11 | cur_sum = nums[left] + nums[left + 1] 12 | cur_gap = math.fabs(cur_sum - target) 13 | if cur_gap < closest_gap: 14 | return [nums[left], nums[left + 1]] 15 | if nums[right] * 2 < target: 16 | cur_sum = nums[right] + nums[right - 1] 17 | cur_gap = math.fabs(cur_sum - target) 18 | if cur_gap < closest_gap: 19 | return [nums[right], nums[right - 1]] 20 | 21 | cur_sum = nums[left] + nums[right] 22 | cur_gap = math.fabs(cur_sum - target) 23 | if cur_gap < closest_gap: 24 | closest_gap = cur_gap 25 | closest_nums = [nums[left], nums[right]] 26 | 27 | if cur_sum < target: 28 | left += 1 29 | elif cur_sum > target: 30 | right -= 1 31 | else: 32 | return [nums[left], nums[right]] 33 | return closest_nums 34 | 35 | def threeSumClosest(self, nums, target): 36 | """ 37 | :type nums: List[int] 38 | :type target: int 39 | :rtype: int 40 | """ 41 | if len(nums) < 3: return None 42 | if len(nums) == 3: return sum(nums) 43 | nums = sorted(nums) 44 | 45 | closest_gap = 2**32 46 | closest_sum = 0 47 | for i in range(len(nums) - 2): 48 | if nums[i] * 3 > target: 49 | cur_sum = sum(nums[i: i + 3]) 50 | cur_gap = math.fabs(cur_sum - target) 51 | if cur_gap < closest_gap: 52 | closest_gap = cur_gap 53 | closest_sum = cur_sum 54 | break 55 | 56 | cur_sum = nums[i] + sum(self.two_sum(nums[i + 1:], target - nums[i])) 57 | cur_gap = math.fabs(cur_sum - target) 58 | if cur_gap < closest_gap: 59 | closest_sum = cur_sum 60 | closest_gap = cur_gap 61 | if cur_gap == 0: return closest_sum 62 | return closest_sum 63 | 64 | 65 | 66 | if __name__ == '__main__': 67 | s = Solution() 68 | result = s.threeSumClosest([1,2,5,10,11], 12) 69 | print(result) -------------------------------------------------------------------------------- /31-40/37. Sudoku Solver.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def _sub_solveSudoku(self, board, cur_fill_x, cur_fill_y, row_list, col_list, rect_list): 3 | 4 | all_filled = False 5 | next_x, next_y = cur_fill_x, cur_fill_y + 1 6 | while next_y < 9: 7 | if board[next_x][next_y] == '.': 8 | break 9 | next_y += 1 10 | if next_y >= 9: 11 | for x in range(cur_fill_x + 1, 9): 12 | for y in range(9): 13 | if board[x][y] == '.': 14 | next_x = x 15 | next_y = y 16 | break 17 | if next_y < 9: break 18 | if next_y >= 9: all_filled = True 19 | 20 | for i in range(1, 10): 21 | if row_list[cur_fill_x][i] != 1 and col_list[cur_fill_y][i] != 1 and rect_list[cur_fill_x // 3][cur_fill_y // 3][i] != 1: 22 | board[cur_fill_x][cur_fill_y] = str(i) 23 | row_list[cur_fill_x][i] = 1 24 | col_list[cur_fill_y][i] = 1 25 | rect_list[cur_fill_x // 3][cur_fill_y // 3][i] = 1 26 | 27 | if all_filled == True: return board 28 | result = self._sub_solveSudoku(board, next_x, next_y, row_list, col_list, rect_list) 29 | if result != None: return result 30 | 31 | board[cur_fill_x][cur_fill_y] = '.' 32 | row_list[cur_fill_x][i] = 0 33 | col_list[cur_fill_y][i] = 0 34 | rect_list[cur_fill_x // 3][cur_fill_y // 3][i] = 0 35 | return None 36 | 37 | def solveSudoku(self, board): 38 | """ 39 | :type board: List[List[str]] 40 | :rtype: None Do not return anything, modify board in-place instead. 41 | """ 42 | row_list = [[0 for __ in range(10)] for _ in range(9)] 43 | col_list = [[0 for __ in range(10)] for _ in range(9)] 44 | rect_list = [[[0 for ___ in range(10)] for __ in range(3)] for _ in range(3)] 45 | 46 | for i in range(9): 47 | for j in range(9): 48 | if board[i][j] != '.': 49 | row_list[i][int(board[i][j])] = 1 50 | col_list[j][int(board[i][j])] = 1 51 | rect_list[i // 3][j // 3][int(board[i][j])] = 1 52 | 53 | filled_x, filled_y = 0, 0 54 | for i in range(9): 55 | for j in range(9): 56 | if board[i][j] == '.': 57 | filled_x = i 58 | filled_y = j 59 | break 60 | if board[filled_x][filled_y] == '.': break 61 | 62 | return self._sub_solveSudoku(board, filled_x, filled_y, row_list, col_list, rect_list) 63 | 64 | 65 | if __name__ == '__main__': 66 | result = Solution().solveSudoku( 67 | [ 68 | ["5", "3", ".", ".", "7", ".", ".", ".", "."], 69 | ["6", ".", ".", "1", "9", "5", ".", ".", "."], 70 | [".", "9", "8", ".", ".", ".", ".", "6", "."], 71 | ["8", ".", ".", ".", "6", ".", ".", ".", "3"], 72 | ["4", ".", ".", "8", ".", "3", ".", ".", "1"], 73 | ["7", ".", ".", ".", "2", ".", ".", ".", "6"], 74 | [".", "6", ".", ".", ".", ".", "2", "8", "."], 75 | [".", ".", ".", "4", "1", "9", ".", ".", "5"], 76 | [".", ".", ".", ".", "8", ".", ".", "7", "9"] 77 | ] 78 | ) 79 | for i in range(len(result)): 80 | print(result[i]) -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | LeetCode Algorithm 2 | ======== 3 | 4 | | # | Title | Difficulty | pass | faster than | memory less than | 5 | |---| ----- | ---------- | ----- | ----------- | ---------------- | 6 | |1|[Two Sum](https://github.com/Dod-o/LeetCode/blob/master/1-10/1.Two_Sum.py) | Easy|100%| 94.29% | 97.01% | 7 | |2|[Add Two Numbers](https://github.com/Dod-o/LeetCode/blob/master/1-10/2.Add_Two_Numbers.py) | Medium|100%| 81.23% | 46.16% | 8 | |3|[Longest Substring Without Repeating Characters](https://github.com/Dod-o/LeetCode/blob/master/1-10/3.Longest_Substring_Without_Repeating_Characters.py) | Medium|100%| 27.85% | 65.74% | 9 | |4|[Median of Two Sorted Arrays ](https://github.com/Dod-o/LeetCode/blob/master/1-10/4.Median_of_Two_Sorted_Arrays.py) | Hard|100%| 49.62% | 13.81% | 10 | |5|[Longest_Palindromic_Substring](https://github.com/Dod-o/LeetCode/blob/master/1-10/5.Longest_Palindromic_Substring.py) | Medium|100%| 71.20% | 96.89% | 11 | |6|[ZigZag Conversion](https://github.com/Dod-o/LeetCode/blob/master/1-10/6.ZigZag_Conversion.py) | Medium|100%| 46.36% | 73.40% | 12 | |7|[Reverse Integer](https://github.com/Dod-o/LeetCode/blob/master/1-10/7.Reverse_Integer.py) | Easy|100%| 75.87% | 51.71% | 13 | |8|[String to Integer (atoi)](https://github.com/Dod-o/LeetCode/blob/master/1-10/8.String_to_Integer_(atoi).py) | Medium|100%| 69.07% | 93.85% | 14 | |9|[Palindrome Number](https://github.com/Dod-o/LeetCode/blob/master/1-10/9.Palindrome_Number.py) | Easy|100%| 72.01% | 54.91% | 15 | |10| Regular Expression Matching| Hard| NA| NA | NA | 16 | |11|[Container With Most Water](https://github.com/Dod-o/LeetCode/blob/master/11-20/11.Container_With_Most_Water.py) | Medium|100%| 89.85% | 89.38% | 17 | |12|[Integer to Roman](https://github.com/Dod-o/LeetCode/blob/master/11-20/12.Integer%20to%20Roman.py) | Medium|100%| 96.37% | 60.36% | 18 | |13|[Roman to Integer](https://github.com/Dod-o/LeetCode/blob/master/11-20/13.Roman_to_Integer.py) | Easy|100%| 19.97% | 82.06% | 19 | |14|[Longest Common Prefix](https://github.com/Dod-o/LeetCode/blob/master/11-20/14.Longest_Common_Prefix.py) | Easy|100%| 95.19% | 86.36% | 20 | |15|[3Sum](https://github.com/Dod-o/LeetCode/blob/master/11-20/15.3Sum.py) | Medium|100%| 53.45% | 72.00% | 21 | |16|[3Sum Closest](https://github.com/Dod-o/LeetCode/blob/master/11-20/16.3Sum_Closest.py) | Medium|100%| 99.32% | 55.94% | 22 | |17|[Letter Combinations of a Phone Number](https://github.com/Dod-o/LeetCode/blob/master/11-20/17.Letter_Combinations_of_a_Phone_Number.py) | Medium|100%| 84.69% | 82.70% | 23 | |18|[4Sum](https://github.com/Dod-o/LeetCode/blob/master/11-20/18.4Sum.py) | Medium|100%| 91.72% | 97.78% | 24 | |19|[Remove Nth Node From End of List](https://github.com/Dod-o/LeetCode/blob/master/11-20/19.Remove_Nth_Node_From_End_of_List.py) | Medium|100%| 81.09% | 37.66% | 25 | |20|[Valid Parentheses](https://github.com/Dod-o/LeetCode/blob/master/11-20/20.Valid_Parentheses.py) | Easy|100%| 90.98% | 45.17% | 26 | |21|[Merge Two Sorted Lists](https://github.com/Dod-o/LeetCode/blob/master/21-30/21.%20Merge_Two_Sorted_Lists.py) | Easy|100%| 95.34% | 61.16% | 27 | |22|[Generate Parentheses](https://github.com/Dod-o/LeetCode/blob/master/21-30/22.%20Generate_Parentheses.py) | Medium|100%| 85.24% | 84.59% | 28 | |23|[Generate Parentheses](https://github.com/Dod-o/LeetCode/blob/master/21-30/23.%20Merge_k_Sorted_Lists.py) | Hard|100%| 90.62% | 33.20% | 29 | |24|[Swap Nodes in Pairs](https://github.com/Dod-o/LeetCode/blob/master/21-30/24.%20Swap_Nodes_in_Pairs.py) | Medium|100%| 99.87% | 50.81% | 30 | |25|[Reverse Nodes in k-Group](https://github.com/Dod-o/LeetCode/blob/master/21-30/25.%20Reverse_Nodes_in_k-Group.py) | Hard|100%| 72.26% | 54.89% | 31 | |26|[Remove Duplicates from Sorted Array](https://github.com/Dod-o/LeetCode/blob/master/21-30/26.%20Remove_Duplicates_from_Sorted_Array.py) | Easy|100%| 62.26% | 92.52% | 32 | |27|[Remove Element](https://github.com/Dod-o/LeetCode/blob/master/21-30/27.%20Remove_Element.py) | Easy|100%| 48.15% | 70.71% | 33 | |28|[Implement strStr()](https://github.com/Dod-o/LeetCode/blob/master/21-30/28.%20Implement_strStr().py) | Easy|100%| 85.56% | 67.81% | 34 | |29|[Divide Two Integers](https://github.com/Dod-o/LeetCode/blob/master/21-30/29.%20Divide_Two_Integers.py) | Medium|100%| 51.85% | 97.37% | 35 | |30|[Substring with Concatenation of All Words](https://github.com/Dod-o/LeetCode/blob/master/21-30/30.%20Substring%20with%20Concatenation%20of%20All%20Words.py) | Hard|100%| 31.18% | 62.29% | 36 | |31|[Next Permutation](https://github.com/Dod-o/LeetCode/blob/master/31-40/31.%20Next%20Permutation.py) | Medium|100%| 93.52% | 37.16% | 37 | |32|[Longest Valid Parentheses](https://github.com/Dod-o/LeetCode/blob/master/31-40/32.%20Longest%20Valid%20Parentheses.py) | Hard|100%| 83.21% | 34.66% | 38 | |33|[Search in Rotated Sorted Array](https://github.com/Dod-o/LeetCode/blob/master/31-40/33.%20Search%20in%20Rotated%20Sorted%20Array.py) | Medium|100%| 47.34% | 81.96% | 39 | |34|[Find First and Last Position of Element in Sorted Array](https://github.com/Dod-o/LeetCode/blob/master/31-40/34.%20Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.py) | Medium|100%| 86.60% | 97.78% | 40 | |35|[Search Insert Position](https://github.com/Dod-o/LeetCode/blob/master/31-40/35.%20Search%20Insert%20Position.py) | Easy|100%| 98.87% | 76.67% | 41 | |36|[Valid Sudoku](https://github.com/Dod-o/LeetCode/blob/master/31-40/36.%20Valid%20Sudoku.py) | Medium|100%| 47.30% | 35.87% | 42 | |37|[Sudoku Solver](https://github.com/Dod-o/LeetCode/blob/master/31-40/37.%20Sudoku%20Solver.py) | Hard|100%| 92.58% | 47.74% | 43 | |38|[Count and Say](https://github.com/Dod-o/LeetCode/blob/master/31-40/38.%20Count%20and%20Say.py) | Easy|100%| 82.14% | 19.94% | 44 | ||[]() | |100%| 0.00% | 0.00% | 45 | ||[]() | |100%| 0.00% | 0.00% | 46 | ||[]() | |100%| 0.00% | 0.00% | 47 | ||[]() | |100%| 0.00% | 0.00% | 48 | ||[]() | |100%| 0.00% | 0.00% | 49 | ||[]() | |100%| 0.00% | 0.00% | 50 | ||[]() | |100%| 0.00% | 0.00% | 51 | ||[]() | |100%| 0.00% | 0.00% | 52 | ||[]() | |100%| 0.00% | 0.00% | 53 | ||[]() | |100%| 0.00% | 0.00% | 54 | ||[]() | |100%| 0.00% | 0.00% | 55 | ||[]() | |100%| 0.00% | 0.00% | 56 | ||[]() | |100%| 0.00% | 0.00% | 57 | ||[]() | |100%| 0.00% | 0.00% | 58 | ||[]() | |100%| 0.00% | 0.00% | 59 | ||[]() | |100%| 0.00% | 0.00% | 60 | ||[]() | |100%| 0.00% | 0.00% | 61 | ||[]() | |100%| 0.00% | 0.00% | 62 | ||[]() | |100%| 0.00% | 0.00% | 63 | ||[]() | |100%| 0.00% | 0.00% | 64 | ||[]() | |100%| 0.00% | 0.00% | 65 | 66 | -------------------------------------------------------------------------------- /21-30/30. Substring with Concatenation of All Words.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def sub_find_sub(self, s, words): 3 | if len(words) == 0: return True 4 | if len(words) == 1: 5 | if s[:len(words[0])] == words[0]: return True 6 | return False 7 | 8 | len_word = len(words[0]) 9 | for i in range(len(words)): 10 | if s[:len_word] == words[i]: 11 | cur_result = self.sub_find_sub(s[len_word:], words[:i] + words[i + 1:]) 12 | if cur_result == True: return True 13 | return False 14 | 15 | 16 | def findSubstring(self, s, words): 17 | """ 18 | :type s: str 19 | :type words: List[str]n 20 | :rtype: List[int] 21 | """ 22 | if len(words) == 0: return [] 23 | if len(words) * len(words[0]) > len(s): return [] 24 | 25 | 26 | words_dict = {} 27 | for i in range(len(words)): 28 | if words[i] in words_dict.keys(): words_dict[words[i]] += 1 29 | else: words_dict[words[i]] = 1 30 | 31 | final_result = [] 32 | len_sub = len(words) * len(words[0]) 33 | len_word = len(words[0]) 34 | for i in range(len(s) - len_sub + 1): 35 | window_words_dict = {key:0 for key, val in words_dict.items()} 36 | flag = True 37 | for j in range(i, i + len_sub, len_word): 38 | if s[j:j + len_word] in window_words_dict.keys(): 39 | window_words_dict[s[j:j + len_word]] += 1 40 | else: 41 | flag = False 42 | break 43 | if flag == True: 44 | all_right = True 45 | for key, val in words_dict.items(): 46 | if val != window_words_dict[key]: 47 | all_right = False 48 | break 49 | if all_right == True: 50 | final_result.append(i) 51 | return final_result 52 | 53 | 54 | 55 | 56 | if __name__ == '__main__': 57 | # print(Solution().findSubstring("barfoothefoobarman", ["foo","bar"])) 58 | print(Solution().findSubstring("abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab", ["ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba","ab","ba"])) -------------------------------------------------------------------------------- /31-40/32. Longest Valid Parentheses.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def longestValidParentheses(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | if len(s) <= 1: return 0 8 | 9 | dp = [0 for i in range(len(s))] 10 | for i in range(1, len(s)): 11 | if s[i] == '(': continue 12 | if s[i - 1] == '(': 13 | if i - 2 >= 0: dp[i] = dp[i - 2] + 2 14 | else: 15 | dp[i] = 2 16 | else: 17 | if i - dp[i - 1] - 1 >= 0 and s[i - dp[i - 1] - 1] == '(': 18 | if i - dp[i - 1] - 2 >= 0: 19 | dp[i] = dp[i - 1] + dp[i - dp[i - 1] - 2] + 2 20 | else: 21 | dp[i] = dp[i - 1] + 2 22 | return max(dp) 23 | 24 | 25 | 26 | if __name__ == '__main__': 27 | print(Solution().longestValidParentheses("((())))()())))(((()()(())))((()(())()((()))())())())()())))))))(((()(())(()))(()()(()()((()))()(())(()(())))))()(())(()()(((()(()()))))((()()))))))()((()())()()))((())()((((()))()()()((()())))())((())))))))(()()((((((()))(((((((()()))((())()(()())()()()(()())(()())(())))()()))))()(((())(())(()())()))()(()))(())((()))))(())))()))((()((()(())(()()()()()))(())())()))))()(()(((())))()()()(((()((()))(()((((((())((()))(()(())(()))(())())))()()))))())(()((()()())()))((((()(()))()()))(()())))((()))(()((((()(())(())()((()))(()))())))(((()(())))((())()(()(((())))())())()()()())((()()))))))(()))(())()(((()))()()((()))(()))(((()))))))))(()(())())(()((())(()()))((())))(()())((((())))(()(()))())(((()(()((()(())((())())(()))(())))()()(())((()()))((()()((()()())())()))())()))())()))())(()(()))(()))()(())))((((())()())()()())((()())(()())(()()))()(())(())))))()()()((()(())(((()(())()()))(()()((()(((()))))))))(((()((()()((()(((((())((()((()((((((((())()))())((())((()((()(()((())(((()(()))())))))))))))))()((()(())())))()(()))(((()))())()(((()))))((()(())(()())(((()(((()((((())()))))(())((()(((((()((()(()()()()((()((((((((((((())()(()))()()(()())()(()(((()((()(()()()())))((())()))())()()))())(((()(())))))()()()(((())))((()(()(((())(())(()((((()(((()(())(((((())()))())())()()(()())((((()(())))((()())))))))))()(()(())))))))()))()())))((())(()()()()()()()(())(()())))))())((()()))))()))))((())((()(((()))))(((()()))()(()((()()())()))(((()(()((())(()(()(()()))()((()(())))()((())))))(())()(())()))((())(((((()))()())(())))((((()((())())(())))(())))))((())())())((((()((())))()()((()()()))()())())(()())(((()))()()))))(()(())(()))()())(()())(()))(((((((()(()))())()())()())((()(((((()())(((())))()())))(()(()(())()((())()))(())))())()))((((()))())((()))(())))))(()))))))(()))))(())))())()()())()()(())()()(((((()))(((()()))()(()((((()(()(()(())))())))())(()()())()(()))())(()()))(()()((()()))))))(())((()()))(())))())())(())((((()))))()))()))()()()))))((((()((())(()))(()()))(())()())(()())))(()(()(())((()())()((())(()))()))()))))((())))(())(()))()()()()()))((())(((()(())))(((((((()(()))(()))())()((()))(()(())((()((()((())))()()((())))))((((())()())(()()(((()()((()))()()((())))(((()())((((()(())())))())()()()(())()))))))()()((()))())(()(((()()))((())))())())())((((()(((()(())())()())((()((()(()((())()(()))()((())))()(()))))(((()))())())(()((()))))()()(((((()))())))(()(()(())((((())())))((()()())(((((((()(()(()))(())))))()))(()(((((())()))((()()()()((()))()(()()()()))(()))))())())()))()(()()(((())((()))(()())))((()()(((())())))))))(())))((()(()(((())((((()))))(()()()))))(((((((())(()(()))(()(())((())(()(()(()(()())(())()(())(()()(()(()))())(())()()(((()())(())(()(((()()(())()((((()()))())(((()(((((()())()(())))()))))(()(()()(()(()()(((()))()))((()())))()(()(())))))))())((((()()))(()))))()((()))(()))())()))()))))(()(())()()()))(((((()))()())())(()())())))()())))))()()()())))))(())(((()))((())((()()))))()((((()(()(()))))(()(())(((())(()()(((()(())()())(()()(()(()())))()())))(((()()((()())()()((()))()))(((()((((()(((()(((()(()())((()))))()(()())(())()(()(((())((()))(())()(())()(()(())()))())()))()())(()))))()))))((()()()((()(()()(())))())(())()(()()))))))))()((()))((((())))())))((()()()(()(()((((()((()))()()((())((())(()))))(())())(((()()(()))))))(()()))()))((()(()(())()))(((())()))(())(()((((()((()()()))()()))(()()(())())((((((())(())((()())()(()())))()))())(()()(()(()()()(()()()()))(()(()()())())((()()()(((()((()())()()((()()(()((()())()())()((()))(()((()())))))))(())((((())(((((())(((())(()))(((()((()()())()((()(()))()()()(()((((())))(())())))((())))(()(((((()()()((())((((((((()()((((())))())())())))))))(((()())(((()))())))()))((())())())))))))))(()()(((())))))(())()()))((())()))(()(()))((()(()((((()(()(((()))))()))(()(()))())())()()(((())())(((()))))(((()())))()(()())()())()))())())(()()(((()()))(())(((()((())((((())))))((()))))(()((()(())))()(())((()(())((()(()())())))()))))(())())(()())()()()((())))((()()))()()()((((()())))))()))))()))())()((()(())()()(())(((()((()))(()(()()))(()))()))))))))))))(()()))(((())((()(((()()()(()())((((()(()()()))())))())(()())))(()((((()))((()()())(((()))()())(()(()((()(()))))(())()()((()())((()(()(()))((()((()())(((()(((((()()()))(()()(()(((()(()())()()()))((()(()())))())(()(()))(())()())))()()()))()())(()(((((()))()()((((()()()()))()()(()((()))(()))))))))))()))()(()((((((())(()))()((())))(((((())))))(()))))()()(()()()(((((()))()())()((((()()))()(())())))(((()((())))))))))(()()()((()))(()())((())))()()((()())))()()(()))))))))()(((()(()))()())((((((())))(((()(()())())))(())())())()()((((()(()(((())(()()(((((()))(()(())()))))))()))()())))()()(()))(((()))()())))((())(((()()))((((((())))(((())()()(()((()))())(()((()()(((())())()))()()())())(()()((((((((())))()(((())(()))))()()())()(())))(((((()())(((())()()))))()((())())(())()(()(()()((()))()(()(((()))))()()())(())()()()(((()((()()()(()())())(())()(((((()())(())()((((()()()))()((())()((()(()(((()(()))()())())()())()(()()(()(((()))()(())(()())(())((())()((()()())(()))))()(()()))))((())()()((()((()()(()((()()())(())))))())))()))))(((((()(()())(()))((()))()(()())())())))()(()()(()((())))))()()))((())((((()))))())((()))())((())((()(()((()))()()()))()((((((())((((((()((((((((()))(()(((()(((((((((())(())())()())))))))())())))()))(()))))()(()))(())))()()()((()()))(())(()))(()()(()())))()(()()()()())))(())((((()))(((((())(()(((((())((()((((()))(((((()))(()())()))))())()))()(()()))((((()))()())(())))()((())))(((((()()((()()((()))))()((())())()))(((((((((()((())((((())()())))(())())()))())))())()))()(()()(()))(()()()((())((()))())))()(()())()(((((((()))))(()()()((()(())))())()))((())())(()(()(())()()())))))(()()()))())()))()())(((())(())))()(())())))()((()(()(())()()()((()))()))((())((((()((((((()()()))()))())())))))()(())(()())))()(((()())(((())))((())()()))((())())()()(()()())()))())(((()((()(((()())(()(())(((())))()))))))())()((((((()))))))()(()))()))())))())((((())(())()(())()))()))((((((((()()(())())((((())))((((()(())()()(())()))())()))(((()((()))()(((((()()()))))(()(()())))(((()(((()(())())((((())(()((()((()(()()(()()))()))()()))()))))))())()(())())))(((())))((()))((()(())())((())))((()))()))(((()))))(()())()())())()())))())))(())))(())())()((()())()()))((()()())(((((()())))())))()()()((((((())())()((())()))(()))()(()())()())(())()())((()((())(())()()()()((())(()())()()((())))()(((()(()(((((()(())))()(()))()(()))()))())()))()())()(()))))()()())(((())((()((())(()(()))()((()))))))(())(()(())())()()((())((())((((())))))(()()())(()()())(())())(((()()(())(())))()()))(())))))())(())()(((())())))((()(((())))(()((())()))()))((()()())()(((((())((((())))(())()()((()()(()()))(()((()))((())())))))))()())))())())((()(()()()()()))))()))((())(((((()())(()))((())))((()(())))))))))(((())(()(())(()(())((()((()))()((())())()())()((()(())())()(((()()((()(()())))))())((())(((()())(((()(()((())((()(((())(()()((((((()))())))())(()(()(()()())())((()))((())(())(())())))()(()())()))())(())((((())()((())))))(()()((())(((((()))()()))()()())(()(((()))())()()()))(((()()))(()(()((())(())))()()((((()()))()(())()())()()()()()(()()))(((())(((()()()((((((((((()()()(((()))))))())))()(((((((()((((((((()))()(((())())())())((((((()()))(()))()))))(())()())))())(()))(((())()()()((()()((())(()))((()(()())))()(()((()((())()()()()(())()()((())())())()()))()()))))((()()((())(((())(())())))((())())())(()))))())))))()((()(()(()))))()))((((())((())())(()))))()((()))(())((()()))()()((())(())())))(())))))()()(()())((()(())(((()((())))()())))()))()))))(())()(()))((()()()()))(())))(()()(())(((()(((()()))()((()))())()))(()(()))())))))))()((()(()))(((())())(())(()))(())(()((()))))))(()())(()()()(((()(((((()))((()))))(()))(())())(((()(()())(()()()()))())(()((()(()))()))())))(((()(()))))()))(()()((())())(()()())((()))(())))()()))(())))())))(()((())((()))((()))))())()()()((((((())((())()))(()))(())(())())))()())()((())))((()()())(()))(((()))())())))(())(())())()())()))((((()()()()))(())))((((())))(())(()((((()))())()))))))()()()))())))()((())))))((())())))()()(()()(()(()()()())((((())))(())(((())(()(()((((())(()()()(()(()((())(())(()())((((()((()((((((()((((())(((()())()((((()((())()(()(()(()((()()()(()(()())(((()(())(()(())(())(()))()((((((((()()(())))(()()(((())()(()(((((()())((()(())()())(((()(()(())()((((((((())()((()()((((())(((()(()((()((((()((((()(()(())())()(((()()))))))(()(((())()(((()())))((()))))(()()))))(()))))))((())())((())))()()()(()((()))()))()))()()()()()))(((((((()((()))((())()(()(()))()((((((((((((()(())))))(()())))()(()()(()(()()))))(((((()()((())()))())()()()))(())())()())()()((()()(()(()()(()))))))()()))(()()((()))))()((()()()())))(((()(((()()(())(())(()(((())(()((()(()))(()()((())()(()()())()))))))(()()((())((()())))(())(()))()(()))(()))()))()(())()(()())))(()))(()()(((()))))())))))((())())))))()()()))(()))((()())())()()))(((())((()((())()(()))()((()))()(())))))))()()())())))(()()(())(()))(())))))()(()))(()()))))))))((((()()()()()))(()))((()((())))(()())(((()()()(())))))()))()())())(()()()))))))((()())))((())))(())()((()))()(()())())))))(((()()(()(())()())(((((()))((()(())(())))))))()()))))))((()((((()()))()))(()()))(()()(())))))(((()()))(()())))(())()((()((()(((()()()()((()())())(()(((((((()((((())(()((((()()(())))))(()())))))(()())))())(())))((()(()))(()())(((())))((((())))))((()))()(((((((())())())((())))))))(()))))))))()((()()())((())))(())))((()(((()(())(())))()()()()))(())(()(())()())(())))()())((()((()((()()((())())))(()((())()()))()))((()()(()))(((((((()))((())((())((())()()((((((((()())()()()))(()()(((()(())()))()))()))()()(()(((((()))))((())(((()))()((((((((()()()()(()))()(()))()(())))))))()((((()()((()(())()((()))((()()(()()))))))))))(())(()))()()((((())))()((())(()((()((()(())()))()()((((()))))()))())))))())(((()()))()))()(()))(()))()((()((((((())())))()))()((())(()(())))))))()))(()()()())())()))((()))(()((()((()())))))((((())()()())(())())()((()((()())()())()(()))))((()())))()))()()))))()((())))())(()))()))(()((())(()))))()()))(()()((((()()))(((()()())(()(()(((()))())))((((()())()()()(())()()()((()))))((()()(()()))()())))(((((()(())())))))(()))))())))(())())()))))((()))))))(((())(((())()(((())))(()))()())(((()(()(((()))))()(()()(())())))))())())()()((())))()(())((()))((())(()())(()()()(()()())((())())))))((()(()())()()))))(()()(()()()(()()))((((((()))(()())(())(())())((())(()(()))((()()(()))))()))()(())))())))())(()((())))((())(()()()(()))((()((((((()())()()))))()))((()((())()))()((((()()()(((())())))()()()())())())(()())()))()(())(())()))())((()(((((()))(())(((((()))(()())(()(()(())()((()(()(()))()(()))))()(((())(()((((((()))(()(((()()())()())((()())))((()((()())()((((((())()))(()))))(()()()()))())())((((((((())((((()()()))(())()()))(()(()()(()(()))))(()))(()()()(())()()(())(()))())((()()((()(()))()))))())((()())())(((((()(()()))((()()()))()()(()(()(((()())(((((((((()))()())(()(()(())(((((()()))))(()())(()())())(())))))((()))())(((()((((()))()))(()(()(((()()(()(((()()))(())))((((()(()()))))((((()()())()))())()))))((())((((((())()()))()))()(((()((())(()((((()())())((((((((((()(((((()())()()(()))))))()((((())())(((()()((((()()())()(((((())))()))(())())(((()(((())()))()()()()(())))(()(((()(()))())))()(((()()()()()(()(((()(((()))()(())(())()()))()((()))))))()(((((()(()()((())(())((())))()(()())(())))())((())(()(()()(((())((()()(()()((()))))())))()(()))()))))))())())))((((((()())))(())(()))()()))()(())))))))((()))(()()()()))()())()()()()))()()())))))))((())(())))(()))(())((()())))(()(((()))((((())())))(())((())())))))(((()())(())()(())))((()()()((()(()))()))(())))((()(()()((()()()))((()))((()))()))(()())()()(((((((((()(()))()())()((())((((((((()(())()(((()((())()((((((((()))())))(()((()((())())())((()()())))(()(()((((((()))))((((())))((()()(())()())()()())(())(((()(()()(())(((())((((())()()(()()(((())()(())((()(()(((()(()())))()))((()()())(())))))(()(()))()))()(()))))(()((()))()())(())(())(()))((()())()))())()())((((()))))())())(((()))(((()()((()((())(())()()))))(((()((((()(((((((((())()()()(())((()(()()(()()(()()(())()())(((((()))))()(())(((()((((()())(()(((()))))()))())((((()()((()(()))))((())(())(()(()))()()(((()))(((((((((()())))((())()(()(((((((()))))))()()(())(((()(()())()()))((()()))((((()(())())))((()())))))()))))))))()()(((())())((()))())((())((()()))())((((((((())((()((())())))))()()))))))()()(())))))()))()()(((()))))(())((((()()()()))((()((((()()(())(((((()())()))))))())())()((((((((((()))()))((()))(())())(()(()(())((()()(()((())(())((((())(()()(()((()((()(((((()(()()((((())(())())(()()())()())((()(())()(())()))))")) 28 | # print(Solution().longestValidParentheses("(()())")) 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /11-20/15.3Sum.py: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def twoSum(self, nums, target): 3 | result = [] 4 | left, right = 0, len(nums) - 1 5 | while left < right: 6 | if target < 0 and (nums[left] > 0 and nums[right] > 0): 7 | return result 8 | if target > 0 and (nums[left] < 0 and nums[right] < 0): 9 | return result 10 | 11 | if nums[left] + nums[right] < target: 12 | left += 1 13 | elif nums[left] + nums[right] > target: 14 | right -= 1 15 | else: 16 | result.append([nums[left], nums[right]]) 17 | left += 1 18 | right -= 1 19 | while left < right and nums[left] == nums[left - 1]: left += 1 20 | while left < right and nums[right] == nums[right + 1]: right -= 1 21 | 22 | return result 23 | 24 | def threeSum(self, nums): 25 | """ 26 | :type nums: List[int] 27 | :rtype: List[List[int]] 28 | """ 29 | if len(nums) < 3: return [] 30 | if len(nums) == 3: 31 | if sum(nums) == 0: return [nums] 32 | return [] 33 | 34 | result = [] 35 | nums = sorted(nums) 36 | if nums[0] > 0 or nums[-1] < 0: return [] 37 | 38 | for first in range(0, len(nums) - 2): 39 | if first > 0 and nums[first] == nums[first - 1]: continue 40 | if nums[first] > 0: break 41 | 42 | target = 0 - nums[first] 43 | cur_result = self.twoSum(nums[first + 1:], target) 44 | if len(cur_result) != 0: 45 | for i in range(len(cur_result)): 46 | result.append([nums[first]] + cur_result[i]) 47 | 48 | # # result = set(result) 49 | # final_result = [] 50 | # for i in range(len(result)): 51 | # if result[i] not in final_result: 52 | # final_result.append(result[i]) 53 | # return final_result 54 | return result 55 | 56 | 57 | 58 | 59 | 60 | if __name__ == '__main__': 61 | s = Solution() 62 | result = s.threeSum([82597,-9243,62390,83030,-97960,-26521,-61011,83390,-38677,12333,75987,46091,83794,19355,-71037,-6242,-28801,324,1202,-90885,-2989,-95597,-34333,35528,5680,89093,-90606,50360,-29393,-27012,53313,65213,99818,-82405,-41661,-3333,-51952,72135,-1523,26377,74685,96992,92263,15929,5467,-99555,-43348,-41689,-60383,-3990,32165,65265,-72973,-58372,12741,-48568,-46596,72419,-1859,34153,62937,81310,-61823,-96770,-54944,8845,-91184,24208,-29078,31495,65258,14198,85395,70506,-40908,56740,-12228,-40072,32429,93001,68445,-73927,25731,-91859,-24150,10093,-60271,-81683,-18126,51055,48189,-6468,25057,81194,-58628,74042,66158,-14452,-49851,-43667,11092,39189,-17025,-79173,13606,83172,92647,-59741,19343,-26644,-57607,82908,-20655,1637,80060,98994,39331,-31274,-61523,91225,-72953,13211,-75116,-98421,-41571,-69074,99587,39345,42151,-2460,98236,15690,-52507,-95803,-48935,-46492,-45606,-79254,-99851,52533,73486,39948,-7240,71815,-585,-96252,90990,-93815,93340,-71848,58733,-14859,-83082,-75794,-82082,-24871,-15206,91207,-56469,-93618,67131,-8682,75719,87429,-98757,-7535,-24890,-94160,85003,33928,75538,97456,-66424,-60074,-8527,-28697,-22308,2246,-70134,-82319,-10184,87081,-34949,-28645,-47352,-83966,-60418,-15293,-53067,-25921,55172,75064,95859,48049,34311,-86931,-38586,33686,-36714,96922,76713,-22165,-80585,-34503,-44516,39217,-28457,47227,-94036,43457,24626,-87359,26898,-70819,30528,-32397,-69486,84912,-1187,-98986,-32958,4280,-79129,-65604,9344,58964,50584,71128,-55480,24986,15086,-62360,-42977,-49482,-77256,-36895,-74818,20,3063,-49426,28152,-97329,6086,86035,-88743,35241,44249,19927,-10660,89404,24179,-26621,-6511,57745,-28750,96340,-97160,-97822,-49979,52307,79462,94273,-24808,77104,9255,-83057,77655,21361,55956,-9096,48599,-40490,-55107,2689,29608,20497,66834,-34678,23553,-81400,-66630,-96321,-34499,-12957,-20564,25610,-4322,-58462,20801,53700,71527,24669,-54534,57879,-3221,33636,3900,97832,-27688,-98715,5992,24520,-55401,-57613,-69926,57377,-77610,20123,52174,860,60429,-91994,-62403,-6218,-90610,-37263,-15052,62069,-96465,44254,89892,-3406,19121,-41842,-87783,-64125,-56120,73904,-22797,-58118,-4866,5356,75318,46119,21276,-19246,-9241,-97425,57333,-15802,93149,25689,-5532,95716,39209,-87672,-29470,-16324,-15331,27632,-39454,56530,-16000,29853,46475,78242,-46602,83192,-73440,-15816,50964,-36601,89758,38375,-40007,-36675,-94030,67576,46811,-64919,45595,76530,40398,35845,41791,67697,-30439,-82944,63115,33447,-36046,-50122,-34789,43003,-78947,-38763,-89210,32756,-20389,-31358,-90526,-81607,88741,86643,98422,47389,-75189,13091,95993,-15501,94260,-25584,-1483,-67261,-70753,25160,89614,-90620,-48542,83889,-12388,-9642,-37043,-67663,28794,-8801,13621,12241,55379,84290,21692,-95906,-85617,-17341,-63767,80183,-4942,-51478,30997,-13658,8838,17452,-82869,-39897,68449,31964,98158,-49489,62283,-62209,-92792,-59342,55146,-38533,20496,62667,62593,36095,-12470,5453,-50451,74716,-17902,3302,-16760,-71642,-34819,96459,-72860,21638,47342,-69897,-40180,44466,76496,84659,13848,-91600,-90887,-63742,-2156,-84981,-99280,94326,-33854,92029,-50811,98711,-36459,-75555,79110,-88164,-97397,-84217,97457,64387,30513,-53190,-83215,252,2344,-27177,-92945,-89010,82662,-11670,86069,53417,42702,97082,3695,-14530,-46334,17910,77999,28009,-12374,15498,-46941,97088,-35030,95040,92095,-59469,-24761,46491,67357,-66658,37446,-65130,-50416,99197,30925,27308,54122,-44719,12582,-99525,-38446,-69050,-22352,94757,-56062,33684,-40199,-46399,96842,-50881,-22380,-65021,40582,53623,-76034,77018,-97074,-84838,-22953,-74205,79715,-33920,-35794,-91369,73421,-82492,63680,-14915,-33295,37145,76852,-69442,60125,-74166,74308,-1900,-30195,-16267,-60781,-27760,5852,38917,25742,-3765,49097,-63541,98612,-92865,-30248,9612,-8798,53262,95781,-42278,-36529,7252,-27394,-5021,59178,80934,-48480,-75131,-54439,-19145,-48140,98457,-6601,-51616,-89730,78028,32083,-48904,16822,-81153,-8832,48720,-80728,-45133,-86647,-4259,-40453,2590,28613,50523,-4105,-27790,-74579,-17223,63721,33489,-47921,97628,-97691,-14782,-65644,18008,-93651,-71266,80990,-76732,-47104,35368,28632,59818,-86269,-89753,34557,-92230,-5933,-3487,-73557,-13174,-43981,-43630,-55171,30254,-83710,-99583,-13500,71787,5017,-25117,-78586,86941,-3251,-23867,-36315,75973,86272,-45575,77462,-98836,-10859,70168,-32971,-38739,-12761,93410,14014,-30706,-77356,-85965,-62316,63918,-59914,-64088,1591,-10957,38004,15129,-83602,-51791,34381,-89382,-26056,8942,5465,71458,-73805,-87445,-19921,-80784,69150,-34168,28301,-68955,18041,6059,82342,9947,39795,44047,-57313,48569,81936,-2863,-80932,32976,-86454,-84207,33033,32867,9104,-16580,-25727,80157,-70169,53741,86522,84651,68480,84018,61932,7332,-61322,-69663,76370,41206,12326,-34689,17016,82975,-23386,39417,72793,44774,-96259,3213,79952,29265,-61492,-49337,14162,65886,3342,-41622,-62659,-90402,-24751,88511,54739,-21383,-40161,-96610,-24944,-602,-76842,-21856,69964,43994,-15121,-85530,12718,13170,-13547,69222,62417,-75305,-81446,-38786,-52075,-23110,97681,-82800,-53178,11474,35857,94197,-58148,-23689,32506,92154,-64536,-73930,-77138,97446,-83459,70963,22452,68472,-3728,-25059,-49405,95129,-6167,12808,99918,30113,-12641,-26665,86362,-33505,50661,26714,33701,89012,-91540,40517,-12716,-57185,-87230,29914,-59560,13200,-72723,58272,23913,-45586,-96593,-26265,-2141,31087,81399,92511,-34049,20577,2803,26003,8940,42117,40887,-82715,38269,40969,-50022,72088,21291,-67280,-16523,90535,18669,94342,-39568,-88080,-99486,-20716,23108,-28037,63342,36863,-29420,-44016,75135,73415,16059,-4899,86893,43136,-7041,33483,-67612,25327,40830,6184,61805,4247,81119,-22854,-26104,-63466,63093,-63685,60369,51023,51644,-16350,74438,-83514,99083,10079,-58451,-79621,48471,67131,-86940,99093,11855,-22272,-67683,-44371,9541,18123,37766,-70922,80385,-57513,-76021,-47890,36154,72935,84387,-92681,-88303,-7810,59902,-90,-64704,-28396,-66403,8860,13343,33882,85680,7228,28160,-14003,54369,-58893,92606,-63492,-10101,64714,58486,29948,-44679,-22763,10151,-56695,4031,-18242,-36232,86168,-14263,9883,47124,47271,92761,-24958,-73263,-79661,-69147,-18874,29546,-92588,-85771,26451,-86650,-43306,-59094,-47492,-34821,-91763,-47670,33537,22843,67417,-759,92159,63075,94065,-26988,55276,65903,30414,-67129,-99508,-83092,-91493,-50426,14349,-83216,-76090,32742,-5306,-93310,-60750,-60620,-45484,-21108,-58341,-28048,-52803,69735,78906,81649,32565,-86804,-83202,-65688,-1760,89707,93322,-72750,84134,71900,-37720,19450,-78018,22001,-23604,26276,-21498,65892,-72117,-89834,-23867,55817,-77963,42518,93123,-83916,63260,-2243,-97108,85442,-36775,17984,-58810,99664,-19082,93075,-69329,87061,79713,16296,70996,13483,-74582,49900,-27669,-40562,1209,-20572,34660,83193,75579,7344,64925,88361,60969,3114,44611,-27445,53049,-16085,-92851,-53306,13859,-33532,86622,-75666,-18159,-98256,51875,-42251,-27977,-18080,23772,38160,41779,9147,94175,99905,-85755,62535,-88412,-52038,-68171,93255,-44684,-11242,-104,31796,62346,-54931,-55790,-70032,46221,56541,-91947,90592,93503,4071,20646,4856,-63598,15396,-50708,32138,-85164,38528,-89959,53852,57915,-42421,-88916,-75072,67030,-29066,49542,-71591,61708,-53985,-43051,28483,46991,-83216,80991,-46254,-48716,39356,-8270,-47763,-34410,874,-1186,-7049,28846,11276,21960,-13304,-11433,-4913,55754,79616,70423,-27523,64803,49277,14906,-97401,-92390,91075,70736,21971,-3303,55333,-93996,76538,54603,-75899,98801,46887,35041,48302,-52318,55439,24574,14079,-24889,83440,14961,34312,-89260,-22293,-81271,-2586,-71059,-10640,-93095,-5453,-70041,66543,74012,-11662,-52477,-37597,-70919,92971,-17452,-67306,-80418,7225,-89296,24296,86547,37154,-10696,74436,-63959,58860,33590,-88925,-97814,-83664,85484,-8385,-50879,57729,-74728,-87852,-15524,-91120,22062,28134,80917,32026,49707,-54252,-44319,-35139,13777,44660,85274,25043,58781,-89035,-76274,6364,-63625,72855,43242,-35033,12820,-27460,77372,-47578,-61162,-70758,-1343,-4159,64935,56024,-2151,43770,19758,-30186,-86040,24666,-62332,-67542,73180,-25821,-27826,-45504,-36858,-12041,20017,-24066,-56625,-52097,-47239,-90694,8959,7712,-14258,-5860,55349,61808,-4423,-93703,64681,-98641,-25222,46999,-83831,-54714,19997,-68477,66073,51801,-66491,52061,-52866,79907,-39736,-68331,68937,91464,98892,910,93501,31295,-85873,27036,-57340,50412,21,-2445,29471,71317,82093,-94823,-54458,-97410,39560,-7628,66452,39701,54029,37906,46773,58296,60370,-61090,85501,-86874,71443,-72702,-72047,14848,34102,77975,-66294,-36576,31349,52493,-70833,-80287,94435,39745,-98291,84524,-18942,10236,93448,50846,94023,-6939,47999,14740,30165,81048,84935,-19177,-13594,32289,62628,-90612,-542,-66627,64255,71199,-83841,-82943,-73885,8623,-67214,-9474,-35249,62254,-14087,-90969,21515,-83303,94377,-91619,19956,-98810,96727,-91939,29119,-85473,-82153,-69008,44850,74299,-76459,-86464,8315,-49912,-28665,59052,-69708,76024,-92738,50098,18683,-91438,18096,-19335,35659,91826,15779,-73070,67873,-12458,-71440,-46721,54856,97212,-81875,35805,36952,68498,81627,-34231,81712,27100,-9741,-82612,18766,-36392,2759,41728,69743,26825,48355,-17790,17165,56558,3295,-24375,55669,-16109,24079,73414,48990,-11931,-78214,90745,19878,35673,-15317,-89086,94675,-92513,88410,-93248,-19475,-74041,-19165,32329,-26266,-46828,-18747,45328,8990,-78219,-25874,-74801,-44956,-54577,-29756,-99822,-35731,-18348,-68915,-83518,-53451,95471,-2954,-13706,-8763,-21642,-37210,16814,-60070,-42743,27697,-36333,-42362,11576,85742,-82536,68767,-56103,-63012,71396,-78464,-68101,-15917,-11113,-3596,77626,-60191,-30585,-73584,6214,-84303,18403,23618,-15619,-89755,-59515,-59103,-74308,-63725,-29364,-52376,-96130,70894,-12609,50845,-2314,42264,-70825,64481,55752,4460,-68603,-88701,4713,-50441,-51333,-77907,97412,-66616,-49430,60489,-85262,-97621,-18980,44727,-69321,-57730,66287,-92566,-64427,-14270,11515,-92612,-87645,61557,24197,-81923,-39831,-10301,-23640,-76219,-68025,92761,-76493,68554,-77734,-95620,-11753,-51700,98234,-68544,-61838,29467,46603,-18221,-35441,74537,40327,-58293,75755,-57301,-7532,-94163,18179,-14388,-22258,-46417,-48285,18242,-77551,82620,250,-20060,-79568,-77259,82052,-98897,-75464,48773,-79040,-11293,45941,-67876,-69204,-46477,-46107,792,60546,-34573,-12879,-94562,20356,-48004,-62429,96242,40594,2099,99494,25724,-39394,-2388,-18563,-56510,-83570,-29214,3015,74454,74197,76678,-46597,60630,-76093,37578,-82045,-24077,62082,-87787,-74936,58687,12200,-98952,70155,-77370,21710,-84625,-60556,-84128,925,65474,-15741,-94619,88377,89334,44749,22002,-45750,-93081,-14600,-83447,46691,85040,-66447,-80085,56308,44310,24979,-29694,57991,4675,-71273,-44508,13615,-54710,23552,-78253,-34637,50497,68706,81543,-88408,-21405,6001,-33834,-21570,-46692,-25344,20310,71258,-97680,11721,59977,59247,-48949,98955,-50276,-80844,-27935,-76102,55858,-33492,40680,66691,-33188,8284,64893,-7528,6019,-85523,8434,-64366,-56663,26862,30008,-7611,-12179,-70076,21426,-11261,-36864,-61937,-59677,929,-21052,3848,-20888,-16065,98995,-32293,-86121,-54564,77831,68602,74977,31658,40699,29755,98424,80358,-69337,26339,13213,-46016,-18331,64713,-46883,-58451,-70024,-92393,-4088,70628,-51185,71164,-75791,-1636,-29102,-16929,-87650,-84589,-24229,-42137,-15653,94825,13042,88499,-47100,-90358,-7180,29754,-65727,-42659,-85560,-9037,-52459,20997,-47425,17318,21122,20472,-23037,65216,-63625,-7877,-91907,24100,-72516,22903,-85247,-8938,73878,54953,87480,-31466,-99524,35369,-78376,89984,-15982,94045,-7269,23319,-80456,-37653,-76756,2909,81936,54958,-12393,60560,-84664,-82413,66941,-26573,-97532,64460,18593,-85789,-38820,-92575,-43663,-89435,83272,-50585,13616,-71541,-53156,727,-27644,16538,34049,57745,34348,35009,16634,-18791,23271,-63844,95817,21781,16590,59669,15966,-6864,48050,-36143,97427,-59390,96931,78939,-1958,50777,43338,-51149,39235,-27054,-43492,67457,-83616,37179,10390,85818,2391,73635,87579,-49127,-81264,-79023,-81590,53554,-74972,-83940,-13726,-39095,29174,78072,76104,47778,25797,-29515,-6493,-92793,22481,-36197,-65560,42342,15750,97556,99634,-56048,-35688,13501,63969,-74291,50911,39225,93702,-3490,-59461,-30105,-46761,-80113,92906,-68487,50742,36152,-90240,-83631,24597,-50566,-15477,18470,77038,40223,-80364,-98676,70957,-63647,99537,13041,31679,86631,37633,-16866,13686,-71565,21652,-46053,-80578,-61382,68487,-6417,4656,20811,67013,-30868,-11219,46,74944,14627,56965,42275,-52480,52162,-84883,-52579,-90331,92792,42184,-73422,-58440,65308,-25069,5475,-57996,59557,-17561,2826,-56939,14996,-94855,-53707,99159,43645,-67719,-1331,21412,41704,31612,32622,1919,-69333,-69828,22422,-78842,57896,-17363,27979,-76897,35008,46482,-75289,65799,20057,7170,41326,-76069,90840,-81253,-50749,3649,-42315,45238,-33924,62101,96906,58884,-7617,-28689,-66578,62458,50876,-57553,6739,41014,-64040,-34916,37940,13048,-97478,-11318,-89440,-31933,-40357,-59737,-76718,-14104,-31774,28001,4103,41702,-25120,-31654,63085,-3642,84870,-83896,-76422,-61520,12900,88678,85547,33132,-88627,52820,63915,-27472,78867,-51439,33005,-23447,-3271,-39308,39726,-74260,-31874,-36893,93656,910,-98362,60450,-88048,99308,13947,83996,-90415,-35117,70858,-55332,-31721,97528,82982,-86218,6822,25227,36946,97077,-4257,-41526,56795,89870,75860,-70802,21779,14184,-16511,-89156,-31422,71470,69600,-78498,74079,-19410,40311,28501,26397,-67574,-32518,68510,38615,19355,-6088,-97159,-29255,-92523,3023,-42536,-88681,64255,41206,44119,52208,39522,-52108,91276,-70514,83436,63289,-79741,9623,99559,12642,85950,83735,-21156,-67208,98088,-7341,-27763,-30048,-44099,-14866,-45504,-91704,19369,13700,10481,-49344,-85686,33994,19672,36028,60842,66564,-24919,33950,-93616,-47430,-35391,-28279,56806,74690,39284,-96683,-7642,-75232,37657,-14531,-86870,-9274,-26173,98640,88652,64257,46457,37814,-19370,9337,-22556,-41525,39105,-28719,51611,-93252,98044,-90996,21710,-47605,-64259,-32727,53611,-31918,-3555,33316,-66472,21274,-37731,-2919,15016,48779,-88868,1897,41728,46344,-89667,37848,68092,-44011,85354,-43776,38739,-31423,-66330,65167,-22016,59405,34328,-60042,87660,-67698,-59174,-1408,-46809,-43485,-88807,-60489,13974,22319,55836,-62995,-37375,-4185,32687,-36551,-75237,58280,26942,-73756,71756,78775,-40573,14367,-71622,-77338,24112,23414,-7679,-51721,87492,85066,-21612,57045,10673,-96836,52461,-62218,-9310,65862,-22748,89906,-96987,-98698,26956,-43428,46141,47456,28095,55952,67323,-36455,-60202,-43302,-82932,42020,77036,10142,60406,70331,63836,58850,-66752,52109,21395,-10238,-98647,-41962,27778,69060,98535,-28680,-52263,-56679,66103,-42426,27203,80021,10153,58678,36398,63112,34911,20515,62082,-15659,-40785,27054,43767,-20289,65838,-6954,-60228,-72226,52236,-35464,25209,-15462,-79617,-41668,-84083,62404,-69062,18913,46545,20757,13805,24717,-18461,-47009,-25779,68834,64824,34473,39576,31570,14861,-15114,-41233,95509,68232,67846,84902,-83060,17642,-18422,73688,77671,-26930,64484,-99637,73875,6428,21034,-73471,19664,-68031,15922,-27028,48137,54955,-82793,-41144,-10218,-24921,-28299,-2288,68518,-54452,15686,-41814,66165,-72207,-61986,80020,50544,-99500,16244,78998,40989,14525,-56061,-24692,-94790,21111,37296,-90794,72100,70550,-31757,17708,-74290,61910,78039,-78629,-25033,73172,-91953,10052,64502,99585,-1741,90324,-73723,68942,28149,30218,24422,16659,10710,-62594,94249,96588,46192,34251,73500,-65995,-81168,41412,-98724,-63710,-54696,-52407,19746,45869,27821,-94866,-76705,-13417,-61995,-71560,43450,67384,-8838,-80293,-28937,23330,-89694,-40586,46918,80429,-5475,78013,25309,-34162,37236,-77577,86744,26281,-29033,-91813,35347,13033,-13631,-24459,3325,-71078,-75359,81311,19700,47678,-74680,-84113,45192,35502,37675,19553,76522,-51098,-18211,89717,4508,-82946,27749,85995,89912,-53678,-64727,-14778,32075,-63412,-40524,86440,-2707,-36821,63850,-30883,67294,-99468,-23708,34932,34386,98899,29239,-23385,5897,54882,98660,49098,70275,17718,88533,52161,63340,50061,-89457,19491,-99156,24873,-17008,64610,-55543,50495,17056,-10400,-56678,-29073,-42960,-76418,98562,-88104,-96255,10159,-90724,54011,12052,45871,-90933,-69420,67039,37202,78051,-52197,-40278,-58425,65414,-23394,-1415,6912,-53447,7352,17307,-78147,63727,98905,55412,-57658,-32884,-44878,22755,39730,3638,35111,39777,74193,38736,-11829,-61188,-92757,55946,-71232,-63032,-83947,39147,-96684,-99233,25131,-32197,24406,-55428,-61941,25874,-69453,64483,-19644,-68441,12783,87338,-48676,66451,-447,-61590,50932,-11270,29035,65698,-63544,10029,80499,-9461,86368,91365,-81810,-71914,-52056,-13782,44240,-30093,-2437,24007,67581,-17365,-69164,-8420,-69289,-29370,48010,90439,13141,69243,50668,39328,61731,78266,-81313,17921,-38196,55261,9948,-24970,75712,-72106,28696,7461,31621,61047,51476,56512,11839,-96916,-82739,28924,-99927,58449,37280,69357,11219,-32119,-62050,-48745,-83486,-52376,42668,82659,68882,38773,46269,-96005,97630,25009,-2951,-67811,99801,81587,-79793,-18547,-83086,69512,33127,-92145,-88497,47703,59527,1909,88785,-88882,69188,-46131,-5589,-15086,36255,-53238,-33009,82664,53901,35939,-42946,-25571,33298,69291,53199,74746,-40127,-39050,91033,51717,-98048,87240,36172,65453,-94425,-63694,-30027,59004,88660,3649,-20267,-52565,-67321,34037,4320,91515,-56753,60115,27134,68617,-61395,-26503,-98929,-8849,-63318,10709,-16151,61905,-95785,5262,23670,-25277,90206,-19391,45735,37208,-31992,-92450,18516,-90452,-58870,-58602,93383,14333,17994,82411,-54126,-32576,35440,-60526,-78764,-25069,-9022,-394,92186,-38057,55328,-61569,67780,77169,19546,-92664,-94948,44484,-13439,83529,27518,-48333,72998,38342,-90553,-98578,-76906,81515,-16464,78439,92529,35225,-39968,-10130,-7845,-32245,-74955,-74996,67731,-13897,-82493,33407,93619,59560,-24404,-57553,19486,-45341,34098,-24978,-33612,79058,71847,76713,-95422,6421,-96075,-59130,-28976,-16922,-62203,69970,68331,21874,40551,89650,51908,58181,66480,-68177,34323,-3046,-49656,-59758,43564,-10960,-30796,15473,-20216,46085,-85355,41515,-30669,-87498,57711,56067,63199,-83805,62042,91213,-14606,4394,-562,74913,10406,96810,-61595,32564,31640,-9732,42058,98052,-7908,-72330,1558,-80301,34878,32900,3939,-8824,88316,20937,21566,-3218,-66080,-31620,86859,54289,90476,-42889,-15016,-18838,75456,30159,-67101,42328,-92703,85850,-5475,23470,-80806,68206,17764,88235,46421,-41578,74005,-81142,80545,20868,-1560,64017,83784,68863,-97516,-13016,-72223,79630,-55692,82255,88467,28007,-34686,-69049,-41677,88535,-8217,68060,-51280,28971,49088,49235,26905,-81117,-44888,40623,74337,-24662,97476,79542,-72082,-35093,98175,-61761,-68169,59697,-62542,-72965,59883,-64026,-37656,-92392,-12113,-73495,98258,68379,-21545,64607,-70957,-92254,-97460,-63436,-8853,-19357,-51965,-76582,12687,-49712,45413,-60043,33496,31539,-57347,41837,67280,-68813,52088,-13155,-86430,-15239,-45030,96041,18749,-23992,46048,35243,-79450,85425,-58524,88781,-39454,53073,-48864,-82289,39086,82540,-11555,25014,-5431,-39585,-89526,2705,31953,-81611,36985,-56022,68684,-27101,11422,64655,-26965,-63081,-13840,-91003,-78147,-8966,41488,1988,99021,-61575,-47060,65260,-23844,-21781,-91865,-19607,44808,2890,63692,-88663,-58272,15970,-65195,-45416,-48444,-78226,-65332,-24568,42833,-1806,-71595,80002,-52250,30952,48452,-90106,31015,-22073,62339,63318,78391,28699,77900,-4026,-76870,-45943,33665,9174,-84360,-22684,-16832,-67949,-38077,-38987,-32847,51443,-53580,-13505,9344,-92337,26585,70458,-52764,-67471,-68411,-1119,-2072,-93476,67981,40887,-89304,-12235,41488,1454,5355,-34855,-72080,24514,-58305,3340,34331,8731,77451,-64983,-57876,82874,62481,-32754,-39902,22451,-79095,-23904,78409,-7418,77916]) 63 | print(result) --------------------------------------------------------------------------------