LeetCode刷题1：第四周

LeetCode刷题1：第四周

相关系列笔记：
LeetCode刷题：前言
LeetCode刷题1：第一周
LeetCode刷题1：第二周
LeetCode刷题1：第三周
LeetCode刷题1：第四周
LeetCode刷题1：第五周
LeetCode刷题1：第六周
LeetCode刷题1：第七周

一、前言

  week4 Topic字符串，题目列表如下：
    (1) 520.检测大写字母
    (2) 680. 验证回文字符串 Ⅱ
    (3) 12.整数转罗马数字
    (4) 93.复原IP地址
    (5) 5. 最长回文子串

二、知识点

1.Python 字符串

  字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。

  创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!' 
var2 = "Runoob"

Python 访问字符串中的值

  Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

  Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

变量[头下标:尾下标]

  索引值以 0 为开始值，-1 为从末尾的开始位置。

Python 字符串更新

  你可以截取字符串的一部分并与其他字段拼接

Python转义字符

  在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：

Python字符串运算符

  下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

操作符	描述	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	‘H’ in a 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	‘M’ not in a 输出结果 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r’\n’ ) print( R’\n’ )
%	格式字符串	请看下一节内容。

Python字符串格式化

  Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

  在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

  python字符串格式化符号:

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

  格式化操作符辅助指令:

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
	在正数前面显示空格
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

Python三引号

  python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

  三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

  一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。

f-string

  f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

  之前我们习惯用百分号 (%):

  f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

Unicode 字符串

  在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

  在Python3中，所有的字符串都是Unicode字符串。

Python 的字符串内建函数

  Python 的字符串常用内建函数如下：

序号	方法及描述
1	capitalize() 将字符串的第一个字符转换为大写
2	center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3	count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4	bytes.decode(encoding=“utf-8”, errors=“strict”) Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5	encode(encoding=‘UTF-8’,errors=‘strict’) 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
6	endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7	expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8	find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9	index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常。
10	isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
11	isalpha() 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
12	isdigit() 如果字符串只包含数字则返回 True 否则返回 False…
13	islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14	isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15	isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
16	istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False
17	isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18	join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19	len(string) 返回字符串长度
20	ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21	lower() 转换字符串中所有大写字符为小写.
22	lstrip() 截掉字符串左边的空格或指定字符。
23	maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24	max(str) 返回字符串 str 中最大的字母。
25	min(str) 返回字符串 str 中最小的字母。
26	replace(old, new [, max]) 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
27	rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.
28	rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29	rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30	rstrip() 删除字符串字符串末尾的空格.
31	split(str="", num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32	splitlines([keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33	startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34	strip([chars]) 在字符串上执行 lstrip()和 rstrip()
35	swapcase() 将字符串中大写转换为小写，小写转换为大写
36	title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37	translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38	upper() 转换字符串中的小写字母为大写
39	zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
40	isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

2.python编程里字符串的内置方法

capitalize()	把字符串的第一个字符改为大写
casefold()	把整个字符串的所有字符改为小写
center(width)	将字符串居中，并使用空格填充至长度 width 的新字符串
count(sub[, start[, end]])	返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。
encode(encoding=‘utf-8’, errors=‘strict’)	以 encoding 指定的编码格式对字符串进行编码。
endswith(sub[, start[, end]])	检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。
expandtabs([tabsize=8])	把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。
find(sub[, start[, end]])	检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。
index(sub[, start[, end]])	跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。
isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
isdecimal()	如果字符串只包含十进制数字则返回 True，否则返回 False。
isdigit()	如果字符串只包含数字则返回 True，否则返回 False。
islower()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False。
isspace()	如果字符串中只包含空格，则返回 True，否则返回 False。
istitle()	如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。
isupper()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。
join(sub)	以字符串作为分隔符，插入到 sub 中所有的字符之间。
ljust(width)	返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。
lower()	转换字符串中所有大写字符为小写。
lstrip()	去掉字符串左边的所有空格
partition(sub)	找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 (‘原字符串’, ‘’, ‘’)
replace(old, new[, count])	把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。
rfind(sub[, start[, end]])	类似于 find() 方法，不过是从右边开始查找。
rindex(sub[, start[, end]])	类似于 index() 方法，不过是从右边开始。
rjust(width)	返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。
rpartition(sub)	类似于 partition() 方法，不过是从右边开始查找。
rstrip()	删除字符串末尾的空格。
split(sep=None, maxsplit=-1)	不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。
splitlines(([keepends]))	在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。
startswith(prefix[, start[, end]])	检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。
strip([chars])	删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。
swapcase()	翻转字符串中的大小写。
title()	返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。
translate(table)	根据 table 的规则（可以由 str.maketrans(‘a’, ‘b’) 定制）转换字符串中的字符。
upper()	转换字符串中的所有小写字符为大写。
zfill(width)	返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。

三、LeetCode例题

520. 检测大写字母

  给定一个单词，你需要判断单词的大写使用是否正确。
    我们定义，在以下情况时，单词的大写用法是正确的：
      1. 全部字母都是大写，比如"USA"。
      2. 单词中所有字母都不是大写，比如"leetcode"。
      3. 如果单词不只含有一个字母，只有首字母大写， 比如 “Google”。
    否则，我们定义这个单词没有正确使用大写字母。
      示例 1:
        输入: “USA”
        输出: True
      示例 2:
        输入: “FlaG”
        输出: False

  实现：

class Solution:
    def detectCapitalUse(self, word: str) -> bool:
        # 内置函数
        # islower()字符都是小写
        # isupper()字符都是大写
        # istitle()字符串标题化（大写开头，其余均小写）
        return word.islower() or word.isupper() or word.istitle() 

680. 验证回文字符串 Ⅱ

  给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。
    示例 1:
      输入: “aba”
      输出: True
    示例 2:
      输入: “abca”
      输出: True
    解释: 你可以删除c字符。
    注意:
      1. 字符串只包含从 a-z 的小写字母。字符串的最大长度是50000。

  实现：

class Solution:
    def validPalindrome(self, s: str) -> bool:
        # 双指针法
        # 出现不同时，左右两种情况进行比较，达到剪枝效果
        i,j=0,len(s)-1
        while i<=j:
            if s[i]==s[j]:
                i+=1
                j-=1
            else:
                x=s[i:j]
                y=s[i+1:j+1]
                return True if x[::-1]==x or y[::-1]==y else False
        return True

12. 整数转罗马数字

  罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。
    字符    数值
    I       1
    V       5
    X       10
    L      50
    C       100
    D       500
    M       1000
  例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
  通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
    • I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
    • X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
    • C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
    给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。
    示例 1:
      输入: 3
      输出: “III”
    示例 2:
      输入: 4
      输出: “IV”
    示例 3:
      输入: 9
      输出: “IX”
    示例 4:
      输入: 58
      输出: “LVIII”
    解释: L = 50, V = 5, III = 3.
    示例 5:
      输入: 1994
      输出: “MCMXCIV”
    解释: M = 1000, CM = 900, XC = 90, IV = 4.

  实现：

  先定义字典，tmp为当前的进位（1，10，100。。。）

class Solution:
    def intToRoman(self, num: int) -> str:

        hashmap = {1000:'M',900:'CM', 500:'D', 400:'CD', 100:'C', 90:'XC', 50:'L', 40:'XL', 10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I'}

        # 初始位为1
        tmp = 1
        ans = ''
        while num:
            # 最右边一位数在原数字中的数目    
            c = num % 10 * tmp
            # 更新num
            num = num // 10
            if c in hashmap.keys():
                ans = hashmap[c] + ans
            else:
                if c < 5 * tmp:
                    ans = hashmap[tmp] * (c // tmp) + ans
                else:
                    ans = hashmap[5 * tmp] + hashmap[tmp] * ((c-5 * tmp) // tmp) + ans
            tmp *= 10
        return ans

93. 复原IP地址

  给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
    有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
      例如：“0.1.2.201” 和 “192.168.1.1” 是 有效的 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效的 IP 地址。
      示例 1：
        输入：s = “25525511135”
        输出：[“255.255.11.135”,“255.255.111.35”]
      示例 2：
        输入：s = “0000”
        输出：[“0.0.0.0”]
      示例 3：
        输入：s = “1111”
        输出：[“1.1.1.1”]
      示例 4：
        输入：s = “010010”
        输出：[“0.10.0.10”,“0.100.1.0”]
      示例 5：
        输入：s = “101023”
        输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]
      提示：
          • 0 <= s.length <= 3000
          • s 仅由数字组成

  实现：

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        if not s: return []
        self.res = []

        def is_valid(s):
            #判断遍历到的字符串是否有效
            if 0 <= int(s) <= 255 and str(int(s)) == s:
                return  True
            return False 

        def backtrack(s, temp,  k):
            #递归终止条件
            if k == 0:
                #判断生成的ip地址是否符合要求
                if len(temp) == 4 and not s:
                    self.res.append(".".join(temp))
                return
            #遍历字符串，取其前1~3位
            #注意当s的长度小于3时，s[:i] 当i=2,i=3时结果是一样的，会产生重复结果，所以我们需要这个min(4, len(s)+1)来避免产生重复结果
            for i in range(1, min(4, len(s)+1)):
                #验证有效性
                if is_valid(s[:i]):
                    #回溯算法的模板
                    temp.append(s[:i])
                    backtrack(s[i:], temp, k-1)
                    temp.pop()
                #提前剪枝（可以去掉）
                else: break

        backtrack(s, [], 4)
        return self.res

5. 最长回文子串

  给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
    示例 1：
      输入: “babad”
      输出: “bab”
    注意: “aba” 也是一个有效答案。
    示例 2：
      输入: “cbbd”
      输出: “bb”

  实现：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s:
            return ''
        for i in range(len(s),0,-1): # 控制字符的个数
            for j in range(len(s)-i+1):  # 控制字符起始位置
                if s[j:i+j]==s[j:i+j][::-1]:
                    return s[j:i+j]