LeetCode算法-字符串-简单 P1
13. 罗马数字转整数
罗马数字包含以下七种字符: 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:
输入: "III"
输出: 3
示例 2:
输入: "IV"
输出: 4
示例 3:
输入: "IX"
输出: 9
class Solution(object):
def romanToInt(self, s):
"""
:type s: str
:rtype: int
"""
res = 0
sr = list(s)
sr.reverse()
i = 0
while i < len(sr):
if sr[i] == 'I':
res += 1
elif sr[i] == 'V':
if i+1 < len(sr) and sr[i+1] == 'I':
res += 4
i += 1
else:
res += 5
elif sr[i] == 'X':
if i+1 < len(sr) and sr[i+1] == 'I':
res += 9
i += 1
else:
res += 10
elif sr[i] == 'L':
if i+1 < len(sr) and sr[i+1] == 'X':
res += 40
i += 1
else:
res += 50
elif sr[i] == 'C':
if i+1 < len(sr) and sr[i+1] == 'X':
res += 90
i += 1
else:
res += 100
elif sr[i] == 'D':
if i+1 < len(sr) and sr[i+1] == 'C':
res += 400
i += 1
else:
res += 500
elif sr[i] == 'M':
if i+1 < len(sr) and sr[i+1] == 'C':
res += 900
i += 1
else:
res += 1000
i+=1
return res
哈希方法:
class Solution(object):
def romanToInt(self, s):
"""
:type s: str
:rtype: int
"""
res = 0
d = {'I':1, 'IV':3, 'V':5, 'IX':8, 'X':10,
'XL':30, 'L':50, 'XC':80, 'C':100, 'CD':300,
'D':500, 'CM':800, 'M':1000}
for i,c in enumerate(s):
res += d.get(s[max(i-1,0):i+1], d[c])
return res
14. 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1:
输入: ["flower","flow","flight"]
输出: "fl"
示例 2:
输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。
class Solution(object):
def longestCommonPrefix(self, strs):
"""
:type strs: List[str]
:rtype: str
"""
# 在Python里字符串是可以比较的，按照ascII值排
# 举例abb， aba，abac，最大为abb，最小为aba。
if not strs: return ""
str0 = min(strs)
str1 = max(strs)
for i in range(len(str0)):
if str0[i] != str1[i]:
return str0[:i]
return str0
20. 有效的括号
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: "()"
输出: true
示例 2:
输入: "()[]{}"
输出: true
示例 3:
输入: "(]"
输出: false
示例 4:
输入: "([)]"
输出: false
class Solution(object):
def isValid(self, s):
"""
:type s: str
:rtype: bool
"""
d = {')':'(',
']':'[',
'}':'{'}
l = []
for c in s:
if c not in d:
l.append(c)
else:
if l and d[c] == l[-1]:
del l[-1]
else:
l.append(c)
break
return True if not l else False
'''
dic = {'{': '}', '[': ']', '(': ')', '?': '?'}
stack = ['?']
for c in s:
if c in dic: stack.append(c)
elif dic[stack.pop()] != c: return False
return len(stack) == 1
'''
28. 实现 strStr()
- 实现 strStr()
实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1:
输入: haystack = "hello", needle = "ll"
输出: 2
示例 2:
输入: haystack = "aaaaa", needle = "bba"
输出: -1
class Solution(object):
def strStr(self, haystack, needle):
"""
:type haystack: str
:type needle: str
:rtype: int
"""
if needle in haystack:
return haystack.index(needle)
else:
return -1
38. 外观数列
给定一个正整数 n（1 ≤ n ≤ 30），输出外观数列的第 n 项。
注意：整数序列中的每一项将表示为一个字符串。
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。前五项如下：
-
1 -
11 -
21 -
1211 -
111221
第一项是数字 1
描述前一项，这个数是 1 即 “一个 1 ”，记作 11
描述前一项，这个数是 11 即 “两个 1 ” ，记作 21
描述前一项，这个数是 21 即 “一个 2 一个 1 ” ，记作 1211
描述前一项，这个数是 1211 即 “一个 1 一个 2 两个 1 ” ，记作 111221
示例 1:
输入: 1
输出: "1"
解释：这是一个基本样例。
示例 2:
输入: 4
输出: "1211"
解释：当 n = 3 时，序列是 "21"，其中我们有 "2" 和 "1" 两组，"2" 可以读作 "12"，也就是出现频次 = 1 而 值 = 2；类似 "1" 可以读作 "11"。所以答案是 "12" 和 "11" 组合在一起，也就是 "1211"。
class Solution(object):
def countAndSay(self, n):
"""
:type n: int
:rtype: str
"""
if n == 1: return '1'
res = '1'
for i in range(n-1):
old_c = ''
tmp = ''
for c in res:
if old_c != c:
if old_c:
tmp = tmp + str(count) + old_c
old_c = c
count = 0
count += 1
res = tmp + str(count) + old_c
return res
58. 最后一个单词的长度
给定一个仅包含大小写字母和空格 ' ' 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。
示例:
输入: "Hello World"
输出: 5
class Solution(object):
def lengthOfLastWord(self, s):
"""
:type s: str
:rtype: int
"""
if not s:
return 0
sl = s.strip().split(' ')
last = sl[-1]
return len(last)
67. 二进制求和
给你两个二进制字符串，返回它们的和（用二进制表示）。
输入为 非空 字符串且只包含数字 1 和 0。
示例 1:
输入: a = "11", b = "1"
输出: "100"
示例 2:
输入: a = "1010", b = "1011"
输出: "10101"
class Solution(object):
def addBinary(self, a, b):
"""
:type a: str
:type b: str
:rtype: str
"""
a = int(a,2)
b = int(b,2)
c = a+b
return bin(c)[2:]
模拟加法
class Solution:
def addBinary(self, a: str, b: str) -> str:
if not a or not b: return a or b
a, b, ans = a[::-1], b[::-1], []
# carry: 进位
i = j = carry = 0
while i < len(a) or j < len(b) or carry:
n1 = int(a[i]) if i < len(a) else 0
n2 = int(b[j]) if j < len(b) else 0
carry, cur = divmod(n1 + n2 + carry, 2)
ans.append(str(cur))
i, j = i + 1, j + 1
return ''.join(ans[::-1])
125. 验证回文串
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。
示例 1:
输入: "A man, a plan, a canal: Panama"
输出: true
示例 2:
输入: "race a car"
输出: false
class Solution(object):
def isPalindrome(self, s):
"""
:type s: str
:rtype: bool
"""
'''
if not s:
return True
l = 0
r = len(s)-1
while l<r:
if not (s[l].isalpha() or s[l].isdigit()):
l += 1
elif not (s[r].isalpha() or s[r].isdigit()):
r -= 1
else:
if s[l].lower() != s[r].lower():
return False
else:
l += 1
r -= 1
else:
return True
'''
s = re.sub(r'[^a-z0-9]', '', s.strip().lower())
return s == s[::-1]
344. 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
class Solution(object):
def reverseString(self, s):
"""
:type s: List[str]
:rtype: None Do not return anything, modify s in-place instead.
"""
l = 0
r = len(s)-1
while l < r:
s[l],s[r] = s[r],s[l]
l += 1
r -= 1
return s
345. 反转字符串中的元音字母
编写一个函数，以字符串作为输入，反转该字符串中的元音字母。
示例 1:
输入: "hello"
输出: "holle"
示例 2:
输入: "leetcode"
输出: "leotcede"
class Solution(object):
def reverseVowels(self, s):
"""
:type s: str
:rtype: str
"""
res = list(s)
vowel = ['a','e','i','o','u']
l = 0
r = len(res)-1
while l<r:
if res[l].lower() not in vowel:
l += 1
elif res[r].lower() not in vowel:
r -= 1
else:
res[l],res[r] = res[r],res[l]
l += 1
r -= 1
return ''.join(res)
383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：
你可以假设两个字符串均只含有小写字母。
canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true
class Solution(object):
def canConstruct(self, ransomNote, magazine):
"""
:type ransomNote: str
:type magazine: str
:rtype: bool
"""
s1 = list(ransomNote)
s2 = list(magazine)
for c in s1:
if c in s2:
s2.remove(c)
else:
return False
else:
return True
387. 字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
示例：
s = "leetcode"
返回 0
s = "loveleetcode"
返回 2
提示：你可以假定该字符串只包含小写字母。
class Solution(object):
def firstUniqChar(self, s):
"""
:type s: str
:rtype: int
"""
d={}
for c in s:
d[c]=d.get(c,0) + 1
for i in range(len(s)):
if d[s[i]] == 1:
return i
else:
return -1
415. 字符串相加
给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。
注意：
num1 和num2 的长度都小于 5100.
num1 和num2 都只包含数字 0-9.
num1 和num2 都不包含任何前导零。
你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式。
class Solution(object):
def addStrings(self, num1, num2):
"""
:type num1: str
:type num2: str
:rtype: str
"""
res = ""
i, j, carry = len(num1) - 1, len(num2) - 1, 0
while i >= 0 or j >= 0:
n1 = int(num1[i]) if i >= 0 else 0
n2 = int(num2[j]) if j >= 0 else 0
tmp = n1 + n2 + carry
carry = tmp // 10
res = str(tmp % 10) + res
i, j = i - 1, j - 1
return "1" + res if carry else res
434. 字符串中的单词数
统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。
请注意，你可以假定字符串里不包括任何不可打印的字符。
示例:
输入: "Hello, my name is John"
输出: 5
解释: 这里的单词是指连续的不是空格的字符，所以 "Hello," 算作 1 个单词。
class Solution(object):
def countSegments(self, s):
"""
:type s: str
:rtype: int
"""
return len(s.split())
443. 压缩字符串
给定一组字符，使用原地算法将其压缩。
压缩后的长度必须始终小于或等于原数组长度。
数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。
在完成原地修改输入数组后，返回数组的新长度。
进阶：
你能否仅使用O(1) 空间解决问题？
示例 1：
输入：
["a","a","b","b","c","c","c"]
输出：
返回 6 ，输入数组的前 6 个字符应该是：["a","2","b","2","c","3"]
说明：
"aa" 被 "a2" 替代。"bb" 被 "b2" 替代。"ccc" 被 "c3" 替代。
示例 2：
输入：
["a"]
输出：
返回 1 ，输入数组的前 1 个字符应该是：["a"]
解释：
没有任何字符串被替代。
示例 3：
输入：
["a","b","b","b","b","b","b","b","b","b","b","b","b"]
输出：
返回 4 ，输入数组的前4个字符应该是：["a","b","1","2"]。
解释：
由于字符 "a" 不重复，所以不会被压缩。"bbbbbbbbbbbb" 被 “b12” 替代。
注意每个数字在数组中都有它自己的位置。
class Solution(object):
def compress(self, chars):
"""
:type chars: List[str]
:rtype: int
"""
p = 0
q = 1
while q < len(chars):
if chars[p] != chars[q]:
if q-p > 1:
chars[p:q] = [chars[p]] + list(str(q-p))
p += 2
else:
p = q
q = p + 1
else:
q += 1
if q-p > 1:
chars[p:q] = [chars[p]] + list(str(q-p))
return len(chars)
459. 重复的子字符串
给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
示例 1:
输入: "abab"
输出: True
解释: 可由子字符串 "ab" 重复两次构成。
示例 2:
输入: "aba"
输出: False
示例 3:
输入: "abcabcabcabc"
输出: True
解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)
class Solution(object):
def repeatedSubstringPattern(self, s):
"""
:type s: str
:rtype: bool
"""
'''
n = len(s)
for i in range(n//2):
if n % (i+1) == 0:
k = n/(i+1)
if s[:i+1] * k == s:
return True
else:
return False
'''
s2 = s+s
return s in s2[1:len(s2)-1]
520. 检测大写字母
给定一个单词，你需要判断单词的大写使用是否正确。
我们定义，在以下情况时，单词的大写用法是正确的：
全部字母都是大写，比如"USA"。
单词中所有字母都不是大写，比如"leetcode"。
如果单词不只含有一个字母，只有首字母大写， 比如 "Google"。
否则，我们定义这个单词没有正确使用大写字母。
示例 1:
输入: "USA"
输出: True
示例 2:
输入: "FlaG"
输出: False
注意: 输入是由大写和小写拉丁字母组成的非空单词。
class Solution(object):
def detectCapitalUse(self, word):
"""
:type word: str
:rtype: bool
"""
if word.isupper() or word.islower():
return True
elif len(word) > 1 and word.istitle():
return True
else:
return False
521. 最长特殊序列 Ⅰ
给你两个字符串，请你从这两个字符串中找出最长的特殊序列。
「最长特殊序列」定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。
子序列 可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。
输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。
示例 1：
输入: "aba", "cdc"
输出: 3
解释: 最长特殊序列可为 "aba" (或 "cdc")，两者均为自身的子序列且不是对方的子序列。
示例 2：
输入：a = "aaa", b = "bbb"
输出：3
示例 3：
输入：a = "aaa", b = "aaa"
输出：-1
class Solution(object):
def findLUSlength(self, a, b):
"""
:type a: str
:type b: str
:rtype: int
"""
return max(len(a),len(b)) if a!=b else -1
541. 反转字符串 II
给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例:
输入: s = "abcdefg", k = 2
输出: "bacdfeg"
class Solution(object):
def reverseStr(self, s, k):
"""
:type s: str
:type k: int
:rtype: str
"""
sl = list(s)
i = 0
flag = True
while i*k < len(sl):
if flag:
tmp = sl[i*k:(i+1)*k]
tmp.reverse()
sl[i*k:(i+1)*k] = tmp
flag = not flag
i += 1
if flag:
tmp = sl[(i+1)*k:]
tmp.reverse()
sl[(i+1)*k:] = tmp
return ''.join(sl)
551. 学生出勤记录 I
给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：
'A' : Absent，缺勤
'L' : Late，迟到
'P' : Present，到场
如果一个学生的出勤记录中不超过一个'A'(缺勤)并且不超过两个连续的'L'(迟到),那么这个学生会被奖赏。
你需要根据这个学生的出勤记录判断他是否会被奖赏。
示例 1:
输入: "PPALLP"
输出: True
示例 2:
输入: "PPALLL"
输出: False
class Solution(object):
def checkRecord(self, s):
"""
:type s: str
:rtype: bool
"""
if s.count('A') <= 1 and s.count('LLL') == 0:
return True
else:
return False
557. 反转字符串中的单词 III
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
示例 1:
输入: "Let's take LeetCode contest"
输出: "s'teL ekat edoCteeL tsetnoc"
注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。
class Solution(object):
def reverseWords(self, s):
"""
:type s: str
:rtype: str
"""
sl = s.split(' ')
for i in range(len(sl)):
sl[i] = sl[i][::-1]
return ' '.join(sl)
606. 根据二叉树创建字符串
你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。
空节点则用一对空括号 "()" 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。
示例 1:
输入: 二叉树: [1,2,3,4]
1
/ \
2 3
/
4
输出: "1(2(4))(3)"
解释: 原本将是“1(2(4)())(3())”，
在你省略所有不必要的空括号对之后，
它将是“1(2(4))(3)”。
示例 2:
输入: 二叉树: [1,2,3,null,4]
1
/ \
2 3
\
4
输出: "1(2()(4))(3)"
解释: 和第一个示例相似，
除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def tree2str(self, t):
"""
:type t: TreeNode
:rtype: str
"""
if not t:
return ""
if t.left and t.right:
return str(t.val) + "(" + self.tree2str(t.left) + ")(" + self.tree2str(t.right) + ")"
elif t.left:
return str(t.val) + "(" + self.tree2str(t.left) + ")"
elif t.right:
return str(t.val) + "()(" + self.tree2str(t.right) + ")"
else:
return str(t.val)
657. 机器人能否返回原点
在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。
移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。
注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。
示例 1:
输入: "UD"
输出: true
解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。
示例 2:
输入: "LL"
输出: false
解释：机器人向左移动两次。它最终位于原点的左侧，距原点有两次 “移动” 的距离。我们返回 false，因为它在移动结束时没有返回原点。
class Solution(object):
def judgeCircle(self, moves):
"""
:type moves: str
:rtype: bool
"""
if moves.count('U') == moves.count('D') \
and moves.count('L') == moves.count('R'):
return True
else:
return False
680. 验证回文字符串 Ⅱ
给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。
示例 1:
输入: "aba"
输出: True
示例 2:
输入: "abca"
输出: True
解释: 你可以删除c字符。
class Solution(object):
def validPalindrome(self, s):
"""
:type s: str
:rtype: bool
"""
l = 0
r = len(s)-1
while l<r:
if s[l] == s[r]:
l += 1
r -= 1
else:
s1 = s[:l]+s[l+1:]
s2 = s[:r] + s[r+1:]
if s1[::-1] == s1 or s2[::-1] == s2:
return True
else:
return False
else:
return True
686. 重复叠加字符串匹配
给定两个字符串 A 和 B, 寻找重复叠加字符串A的最小次数，使得字符串B成为叠加后的字符串A的子串，如果不存在则返回 -1。
举个例子，A = "abcd"，B = "cdabcdab"。
答案为 3， 因为 A 重复叠加三遍后为 “abcdabcdabcd”，此时 B 是其子串；A 重复叠加两遍后为"abcdabcd"，B 并不是其子串。
注意:
A 与 B 字符串的长度在1和10000区间范围内。
class Solution(object):
def repeatedStringMatch(self, A, B):
"""
:type A: str
:type B: str
:rtype: int
"""
s = ''
c = 0
# 用A把B覆盖需要最大的长度
while c < len(B)//len(A)+2:
c += 1
s = s + A
if B in s:
return c
else:
return -1
696. 计数二进制子串
给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。
重复出现的子串要计算它们出现的次数。
示例 1 :
输入: "00110011"
输出: 6
解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。
请注意，一些重复出现的子串要计算它们出现的次数。
另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。
示例 2 :
输入: "10101"
输出: 4
解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。
class Solution(object):
def countBinarySubstrings(self, s):
"""
:type s: str
:rtype: int
"""
l = []
old = ''
count = 0
for c in s:
if not old:
old = c
count += 1
else:
if old == c:
count += 1
else:
old = c
l.append(count)
count = 1
l.append(count)
res = 0
for i in range(len(l)-1):
res += min(l[i],l[i+1])
return res
别人写的，比较简洁，但是分数没我高
length = len(s)
cur = 1
prev = 0
res = 0
for i in range(1, length):
if s[i] == s[i - 1]:
cur += 1
else:
res += min(cur, prev)
prev = cur
cur = 1
return res + min(cur, prev)
709. 转换成小写字母
实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。
示例 1：
输入: "Hello"
输出: "hello"
示例 2：
输入: "here"
输出: "here"
示例 3：
输入: "LOVELY"
输出: "lovely"
class Solution(object):
def toLowerCase(self, str):
"""
:type str: str
:rtype: str
"""
# return str.lower()
s = []
for i in str:
if 65 <= ord(i) <= 90:
s.append(chr(ord(i) + 32))
else:
s.append(i)
return ''.join(s)
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/roman-to-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
