feat: rename file to ignorecase false

Author: vv13

leetcode/001.two-sum/Solution.py

@@ -0,0 +1,29 @@
+from typing import List
+
+
+class Solution(object):
+    # brute force
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        for i in range(len(nums)):
+            for j in range(i + 1, len(nums)):
+                if (nums[i] + nums[j]) == target:
+                    return [i, j]
+
+    # mistaken attempt, only for orderly array
+    def twoSum2(self, nums: List[int], target: int) -> List[int]:
+        for left in range(len(nums)):
+            for right in range(len(nums) - 1, left, -1):
+                if nums[left] + nums[right] > target:
+                    continue
+                elif nums[left] + nums[right] < target:
+                    break
+                else:
+                    return [left, right]
+
+    def twoSum3(self, nums: List[int], target: int) -> List[int]:
+        map = {}
+        for index, cur in enumerate(nums):
+            expect = target - cur
+            if expect in map:
+                return [index, map[expect]]
+            map[cur] = index

leetcode/002.add-two-numbers/Solution.py

@@ -0,0 +1,17 @@
+from ListNode import ListNode
+
+
+class Solution:
+    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
+        l3 = l = ListNode(0)
+        carry = 0
+        while l1 or l2 or carry:
+            sum = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
+            carry, digit = divmod(sum, 10)
+            l.next = ListNode(digit)
+            l = l.next
+            if l1:
+                l1 = l1.next
+            if l2:
+                l2 = l2.next
+        return l3.next

leetcode/003.longest-substring-without-repeating-characters/Solution.py

@@ -0,0 +1,27 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        ans = 0
+        arr = []
+        for i in s:
+            if i in arr:
+                if len(arr) > ans:
+                    ans = len(arr)
+                arr = arr[arr.index(i) + 1:]
+            arr.append(i)
+        return ans if len(arr) < ans else len(arr)
+
+    def lengthOfLongestSubstring1(self, s: str) -> int:
+        ans = l = r = 0
+        smap = {}
+        slen = len(s)
+        while l < slen and r < slen:
+            if smap.get(s[r]):
+                smap[s[l]] = False
+                l += 1
+            else:
+                smap[s[r]] = True
+                r += 1
+                if r - l > ans:
+                    ans = r - l
+
+        return ans

leetcode/004.median-of-two-sorted-arrays/Solution.py

@@ -0,0 +1,12 @@
+from typing import List
+
+
+class Solution:
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
+        arrs = nums1 + nums2
+        arrs.sort()
+        arrs_len = len(arrs)
+        if arrs_len % 2 == 1:
+            return arrs[arrs_len // 2]
+        else:
+            return (arrs[arrs_len // 2 - 1] + arrs[arrs_len // 2]) / 2

leetcode/005.longest-palindromic-substring/Solution.py

@@ -0,0 +1,21 @@
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        sLen = len(s)
+        # 2d array
+        dp = [[False] * sLen for i in range(sLen)]
+
+        start = end = max = 0
+        for j in range(sLen):
+            for i in range(j, -1, -1):
+                if i == j:
+                    dp[i][i] = True
+                elif i + 1 == j:
+                    dp[i][j] = (s[i] == s[j])
+                else:
+                    dp[i][j] = s[i] == s[j] and dp[i + 1][j - 1]
+                if dp[i][j] and j - i > max:
+                    start = i
+                    end = j
+                    max = j - i
+        return s[start:end + 1]
+

leetcode/006.zigzag-conversion/Solution.py

@@ -0,0 +1,15 @@
+class Solution:
+    def convert(self, s: str, numRows: int) -> str:
+        if numRows == 1 or numRows >= len(s):
+            return s
+        arrs = [[] for i in range(len(s))]
+        incre = 1
+        index = 0
+        for i in range(len(s)):
+            arrs[index].append(s[i])
+            if index == 0:
+                incre = 1
+            elif index == numRows - 1:
+                incre = -1
+            index += incre
+        return ''.join([i for item in arrs for i in item])

leetcode/007.reverse-integer/Solution.py

@@ -0,0 +1,4 @@
+class Solution:
+    def reverse(self, x: int) -> int:
+        result = int(str(x)[::-1]) if x >= 0 else -int(str(x)[1:][::-1])
+        return result if abs(result) < pow(2, 31) else 0

leetcode/008.string-to-integer-atoi/Solution.py

@@ -0,0 +1,29 @@
+
+class Solution:
+    def myAtoi(self, str: str) -> int:
+        MAX_NUM = pow(2, 31) - 1
+        # discard whitespace
+        str = str.strip()
+        # check if can convert to int
+        if not str or (not str[0].isnumeric() and str[0] not in ['-', '+']):
+            return 0
+
+        ret = ''
+        index = 0
+        signal = 1
+        # set sigm
+        if str[0] == '-':
+            index += 1
+            signal = -1
+        elif str[0] == '+':
+            index += 1
+
+        while index < len(str):
+            if not str[index].isnumeric():
+                break
+            ret += str[index]
+            index += 1
+            if int(ret) > MAX_NUM:
+                return MAX_NUM if signal == 1 else -MAX_NUM - 1
+
+        return int(ret) * signal if ret else 0

leetcode/009.palindrome-number/Solution.py

@@ -0,0 +1,17 @@
+import math
+
+
+class Solution:
+    def isPalindrome(self, x: int) -> bool:
+        if x < 0:
+            return False
+        elif x < 10:
+            return True
+        elif x % 10 == 0:
+            return False
+        s = str(x)
+        slen = len(s)
+        for i in range(math.ceil(slen / 2)):
+            if s[i] != s[slen - 1 - i]:
+                return False
+        return True

leetcode/010.regular-expression-matching/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        if not p:
+            return not s
+        first_match = bool(s) and p[0] in (s[0], '.')
+        if len(p) >= 2 and p[1] == '*':
+            return self.isMatch(s, p[2:]) or first_match and self.isMatch(s[1:], p)
+        else:
+            return first_match and self.isMatch(s[1:], p[1:])

leetcode/011.container-with-most-water/Solution.py

@@ -0,0 +1,17 @@
+from typing import List
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        l = 0
+        r = len(height) - 1
+        max = 0
+        while l < r:
+            ret = min(height[l], height[r]) * (r - l)
+            if ret > max:
+                max = ret
+            if height[l] < height[r]:
+                l += 1
+            else:
+                r -= 1
+        return max

leetcode/012.integer-to-roman/Solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def intToRoman(self, num: int) -> str:
+        M = ['', 'M', 'MM', 'MMM']
+        C = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM']
+        X = ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC']
+        I = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX']
+        return (
+            M[num // 1000] +
+            C[num % 1000 // 100] +
+            X[(num % 100) // 10] +
+            I[num % 10]
+        )

leetcode/013.roman-to-integer/Solution.py

@@ -0,0 +1,19 @@
+class Solution:
+    def romanToInt(self, s: str) -> int:
+        map = {
+            '': 0,
+            'I': 1,
+            'V': 5,
+            'X': 10,
+            'L': 50,
+            'C': 100,
+            'D': 500,
+            'M': 1000,
+        }
+        prev = ''
+        ret = 0
+        for i in s[::-1]:
+            ret += map[i] * (-1 if map[prev] > map[i] else 1)
+            prev = i
+
+        return ret

leetcode/014.longest-common-prefix/Solution.py

@@ -0,0 +1,19 @@
+from typing import List
+
+
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        str_nums = len(strs)
+        strs.sort(key=lambda a: len(a))
+        if not str_nums or ('' in strs):
+            return ''
+        elif str_nums == 1:
+            return strs[0]
+        strs_first = strs[0]
+        offset = 0
+        while offset < len(strs_first):
+            for o in strs[1:]:
+                if strs_first[offset] != o[offset]:
+                    return strs_first[0:offset]
+            offset += 1
+        return strs_first

leetcode/015.3sum/Solution.py

@@ -0,0 +1,48 @@
+'''
+将 threeSum 转为 twoSum 问题
+'''
+from typing import List
+
+
+class Solution:
+    # Time Limit Exceeded
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        result = []
+        for index, a in enumerate(nums):
+            map = {}
+            for offset in range(index + 1, len(nums), 1):
+                b = nums[offset]
+                c = -a - b
+                if c in map:
+                    three_sum = sorted([a, b, c])
+                    if three_sum in result:
+                        continue
+                    result.append(three_sum)
+                else:
+                    map[b] = offset
+        return result
+
+    def threeSum1(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        result = []
+        for index, first_num in enumerate(nums[:-2]):
+            if index > 0 and nums[index] == nums[index - 1]:
+                continue
+            left = index + 1
+            right = len(nums) - 1
+            target = -first_num
+            while left < right:
+                two_sum = nums[left] + nums[right]
+                if two_sum == target:
+                    result.append([first_num, nums[left], nums[right]])
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+                    left += 1
+                    right -= 1
+                elif two_sum < target:
+                    left += 1
+                else:
+                    right -= 1
+        return result

leetcode/016.3sum-closest/Solution.py

@@ -0,0 +1,24 @@
+from typing import List
+import math
+
+
+class Solution:
+    def threeSumClosest(self, nums: List[int], target: int) -> int:
+        nums.sort()
+        closest_sum = math.inf
+        if len(nums) == 3:
+            return sum(nums)
+        for index, a in enumerate(nums):
+            left = index + 1
+            right = len(nums) - 1
+            while left < right:
+                sum_three = sum([a, nums[left], nums[right]])
+                if abs(target - sum_three) < abs(target - closest_sum):
+                    closest_sum = sum_three
+                    if sum_three == target:
+                        return closest_sum
+                if sum_three > target:
+                    right -= 1
+                else:
+                    left += 1
+        return closest_sum

leetcode/017.letter-combinations-of-a-phone-number/Solution.py

@@ -0,0 +1,16 @@
+from typing import List
+
+
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        if not len(digits):
+            return []
+        map_list = ['', '', 'abc', 'def', 'ghi',
+                    'jkl', 'mno', 'pqrs', 'tuv', 'wxyz']
+        result = list(map_list[int(digits[0])])
+        for i in range(1, len(digits), 1):
+            while len(result[0]) == i:
+                prefix = result.pop(0)
+                for j in map_list[int(digits[i])]:
+                    result.append(prefix + j)
+        return result

leetcode/018.4sum/Solution.py

@@ -0,0 +1,39 @@
+'''
+将 fourSum 转换为 threeSum 解决
+'''
+from typing import List
+
+
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        nums.sort()
+        result = []
+        if len(nums) < 4 or nums[-1] * 4 < target or nums[0] * 4 > target:
+            return result
+        for i in range(len(nums) - 3):
+            first_num = nums[i]
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+            for j in range(i + 1, len(nums) - 2, 1):
+                second_num = nums[j]
+                if j > i + 1 and nums[j] == nums[j - 1]:
+                    continue
+                left = j + 1
+                right = len(nums) - 1
+                expect = target - first_num - second_num
+                while left < right:
+                    two_sum = nums[left] + nums[right]
+                    if two_sum == expect:
+                        result.append(
+                            [first_num, second_num, nums[left], nums[right]])
+                        while left < right and nums[left] == nums[left + 1]:
+                            left += 1
+                        while left < right and nums[right] == nums[right - 1]:
+                            right -= 1
+                        left += 1
+                        right -= 1
+                    elif two_sum < expect:
+                        left += 1
+                    else:
+                        right -= 1
+        return result