【程序人生】leetcode（一）_在目标字符串中找出回文数 正则

说在前面

这篇博客中部分题目答案来自leetcode评论区，不是本人原创。感谢原作者的工作。这里记录在这篇博客中，方便日后回顾、学习

两数之和(转载)

给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素

class Solution:
    def twoSum(self, nums, target):
        for idx, n in enumerate(nums):
            if (target - n) in nums[idx + 1:]:
                return [idx, nums[idx + 1:].index(target - n) + idx + 1]
        return None
1
2
3
4
5
6

整数反转(原创)

给出一个32位的有符号整数，你需要将这个整数中每位上的数字进行反转

class Solution:
    def reverse(self, x):
        x = str(x)
        if x[0] == "-":
            x = x[1:][::-1]
            x = "-"+x
        else:
            x = x [::-1]

        x = int(x)
        
        if (x < -2**31) or (x > (2**31 -1)):
            return 0

        return x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

两数相加(转载)

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字0之外，这两个数都不会以0开头。

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
    def addTwoNumbers(self, l1, l2):
        re = ListNode(0)
        r = re
        carry = 0  # 进位
        while(l1 or l2):
            x = l1.val if l1 else 0
            y = l2.val if l2 else 0
            s = carry + x + y
            carry = s // 10
            r.next = ListNode(s % 10)
            r = r.next
            if(l1 != None):
                l1 = l1.next
            if(l2 != None):
                l2 = l2.next
        if(carry > 0):
            r.next = ListNode(1)
        return re.next
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

无重复字符的最长子串(转载)

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。注意是子串，不是子序列，即必须是在原字符串中连续的子字符串

class Solution:
    def lengthOfLongestSubstring(self, s):
        value2lastidx = {}
        ptr = 0 
        max_lenght = 0

        for i in range(len(s)):
            if s[i] in value2lastidx:
                ptr = max(ptr, value2lastidx[s[i]])
            
            value2lastidx[s[i]] = i + 1
            max_lenght = max(max_lenght, i - ptr + 1)
        
        return max_lenght
1
2
3
4
5
6
7
8
9
10
11
12
13
14

回文数(原创)

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution:
    def isPalindrome(self, x):
        x = str(x)
        y = x[::-1]
        if x == y:
            return True
        else:
            return False
1
2
3
4
5
6
7
8

最长回文子串(转载)

给定一个字符串s，找到s中最长的回文子串。你可以假设s的最大长度为1000。

class Solution:
	# 扩展函数
    def spread(self, s, left, right):
        """
        当left = right, 回文串的长度是奇数
        当right = left + 1, 回文串的长度是偶数
        """
        while left >= 0 and right < len(s) and s[left] == s[right]:
            # 向外扩展
            left -= 1
            right += 1
        # 扩展不动了, 即, 已经取到了s[left] != s[right]的点，返回以当前节点为中心的最长回文串
        return s[left + 1: right]

    def longestPalindrome(self, s):
        if s == s[::-1]:
            return s
        res = []
        for i in range(len(s)):
            # 奇数
            res_odd = self.spread(s, i, i)
            # 偶数
            res_even = self.spread(s, i, i + 1)
            # 最长回文子串
            res.append(res_odd)
            res.append(res_even)
        sort_res = sorted(res, key=lambda x: len(x))
        return sort_res[-1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Z字形变换(原创)

将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“LCIRETOESIIGEDHN”。

class Solution(object):
    def convert(self, s, numRows):
        if numRows == 1:
            return s

        result_list = [""] * numRows
        
        flag = False
        idx_key = -1
        
        for i in range(len(s)):
            if i == 0:
                idx_key = idx_key + 1
                result_list[idx_key] = result_list[idx_key] + s[i]
            else:
                if (i - 1) % (numRows - 1) == 0:
                    if flag is True:
                        flag = False
                    else:
                        flag = True

                if flag is True:
                    idx_key = idx_key + 1
                    result_list[idx_key] = result_list[idx_key] + s[i]
                else:
                    idx_key = idx_key - 1
                    result_list[idx_key] = result_list[idx_key] + s[i]
        
        return "".join(result_list)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

字符串转换整数(原创)

请你来实现一个函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下：

• 如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。
• 假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。
• 该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。
• 注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换，即无法进行有效转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0 。

提示：
本题中的空白字符只包括空格字符 ’ ’ 。
假设我们的环境只能存储32位大小的有符号整数，那么其数值范围为 [$-2^{31}$, $2^{31}-1$]。如果数值超过这个范围，请返回 INT_MAX ($2^{31}-1$) 或 INT_MIN ($-2^{31}$) 。

class Solution(object):
    def myAtoi(self, s):
        s = s.strip()
        sign = "+"

        if len(s) == 0:
            return 0 
        
        if len(s) == 1:
            try:
                return int(s)
            except ValueError:
                return 0
    
        if s[0] == "-":
            sign = "-"
            s = s[1:]
        
        elif s[0] == "+":
            s = s[1:]
        
        idx = 0
        for i in range(len(s)):
            idx = i
            try:
                tmp = int(s[:i+1])
            except ValueError:
                idx = idx - 1
                break
        
        if idx == -1:
            return 0 
    
        num = int(s[:idx+1])

        if sign == "-":
            num = - num
        
        if num > 2**31 -1:
            num = 2**31 -1
        
        if num < -2 ** 31:
            num = -2 ** 31

        return num
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

正则表达式匹配(转载)

给你一个字符串s和一个字符规律p，请你来实现一个支持${}^{\prime }{.}^{\prime }$ 和${}^{\prime }{\ast }^{\prime }$的正则表达式匹配。
${}^{\prime }{.}^{\prime }$匹配任意单个字符
${}^{\prime }{\ast }^{\prime }$匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖整个字符串s的，而不是部分字符串。

说明：

• s可能为空，且只包含从a-z的小写字母。
• p可能为空，且只包含从a-z的小写字母，以及字符 . 和 *。

class Solution:
    def isMatch(self, s, p):
    	# 如果p是空：如果s也是空，返回True，否则返回False
        if not p:
            return not s
		# 如果s是空，p不是空，则first_match为False
		# 如果p的第一个字母，不等于s的第一个字母，或不是.，则first_match为False
        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:])
1
2
3
4
5
6
7
8
9
10
11
12
13

如果p串中有星号，它会出现在第二个位置，即p[1] 。这种情况下，我们可以直接忽略p串中这一部分，或者删除s串的第一个字符，前提是它能够匹配p串当前位置字符，即 p[0] 。如果两种操作中有任何一种使得剩下的字符串能匹配，那么初始时，s串和p串就可以被匹配。

最长公共前缀(原创)

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串""。

class Solution:
    def longestCommonPrefix(self, strs):
        result = ""
        if len(strs) == 0:
            return result
            
        strslength = min([len(each) for each in strs])
        for i in range(0, strslength + 1):
            if len(set([each[0:i] for each in strs])) == 1:
                result = strs[0][0:i]
            else:
                break

        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结语

如果您有修改意见或问题，欢迎留言或者通过邮箱和我联系。
如果我的文章对您有帮助，转载请注明出处。