leetcode-algorithm

tips

字典

dic = {}
dic.keys()
dic.values()
dic.items()

set()函数

取set中的元素

set类型没法直接取里面的元素 需要利用list()函数进行转化后才能取

e.g.

nums[i] = list(sets)[i]

去重

set()函数无法直接对部分对象去重 但可以开始就创建set() 然后用add()函数添加元素 然后去重

e.g.

a = set()
a.add((1,2,3,4))
a.add((1,2,3,4))
print(a)  #{(1, 2, 3, 4)}

set()函数判断最长公共前缀

对所有字符的的第一个字符使用set()函数 可判断是否一样

e.g.

a = ["flower","flow","flight"]
print(set(string[0] for string in a))  #  {'f'}

如果字符串不够长，会报错，所以可以使用while True

i = 0
result = ''

while True:
    sets = set(string[i] for string in strs)
    if len(sets) == 1:
        result += sets.pop()
        i += 1
    else:
        break

多指针

双指针可以用于那种求几个元素相应运算的极值

11.盛最多水的容器

12.三数之和

16.最接近的三数之和

18.四数之和

reverse()函数

.reverse()操作仅适用于列表且返回值是一个None 其作用的结果需要通过打印被作用的列表才可以查看出具体的效果 并且无法赋值

e.g.

a = [2,3,4,5]
a.reverse()
print(a)   # [5, 4, 3, 2] 

reversed()函数

reversed()函数字符串与列表都适用，但返回值需要用list()函数

sc = 'abc'
sc2 = list(reversed(sc))
print(sc2)  #['c', 'b', 'a']
print(''.join(sc2))  #cba
a = [1,2,3]
print(list(reversed(a)))  #[3, 2, 1]

sort()函数

a = [2,3,4,23,4,5]
print(sorted(a)) #不改变对象的值
print(a) #[2, 3, 4, 4, 5, 23]
a.sort() #返回值为None 但对象值改变
print(a) #[2, 3, 4, 4, 5, 23]

sorted函数

a = [2,3,4,23,4,5]
print(sorted(a)) #不改变对象的值
print(a) #[2, 3, 4, 4, 5, 23]

重复

是否重复可以利用in或者not in来判断

数组转字符串

s = ''
for i in digits:  #digits为数字数组
    s += str(i)
#方法2
temp1 = ''.join(s[i:i+2])

字符串转数组

ans = []
for i in s: #s为整数
    ans.append(i)

二维数组转一位数组

a = [[1,2,3],[4,5,6]]
li = sum(a,[])
print(li) #[1, 2, 3, 4, 5, 6]

二进制十进制互相转换

a = "11"
print(int(a,2)) #二进制转十进制 3
print(bin(11)) #十进制转二进制 0b1011

str.format

c = 0b101
print('{0:b}'.format(c)) #不要二进制前面的0b

str.isXXX()

a = 'jhdoaDJS123'
print(a.isalpha()) #是否只含字母并且非空 false
print(a.isalnum()) #是否只含数字和字母并且非空 true
print(a.isdecimal()) #是否只有数字 false
print(a.isspace())  #是否只含空格 制表符 换行并且非空 false
print(a.istitle())  #是否大写字母开头后面跟随小写字母 false

26字母转数字

print(chr(65)) #A
print(chr(97)) #a

统计单词字母频率

for ch in s:
    dict1[ch] = dict1.get(ch,0) + 1  #如果字典中没有ch 就取0

Array

Easy

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        
        dic = {}

        for i in range(len(nums)):
            if target - nums[i] not in dic:
                dic[nums] = i
            else:
                return [dic[target - nums[i]], i]

21. 合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution(object):
    def mergeTwoLists(self, list1, list2):
        """
        :type list1: Optional[ListNode]
        :type list2: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        
        curr = dummy = ListNode(0)

        while list1 and list2:
            if list1.val < list2.val:
                curr.next = list1
                list1 = list1.next
            else:
                curr.next = list2
                list2 = list2.next
            curr = curr.next
        curr.next = list1 or list2
        return dummy.next

26. 删除有序数组中的重复项

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        sets = set(nums)
        for i in range(len(nums)):
            if i < len(sets):
                nums[i] = list(sets)[i]
            else:
                nums[i] = '_'
        return nums

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """

        i = 0
        last = len(nums) - 1
        while i <= last:
            if nums[i] == val:
                nums[i],nums[last] = nums[last],nums[i]
                last -= 1
            else:
                i += 1
        return last+1

35. 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """

        for i in range(len(nums)):
            if nums[i] == target:
                return i
            elif target < nums[0]:
                return 0
            elif i < len(nums) -1 and nums[i] < target and nums[i+1] >target or i == len(nums) -1 :
                return i+1
            else:
                continue

66. 加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """

        s = ""
        for i in digits:
            s = s + str(i)

        a = int(s)
        a = a + 1
        a = str(a)

        list1 = []
        for i in a:
            list1.append(i)

        return list1

88. 合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """

        nums1[m:] = nums2
        nums1.sort()
        return nums1

108. 将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """

        if not nums:
            return None
        mid = len(nums) // 2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

Medium

11. 盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

class Solution(object):
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int
        """

        left = 0
        right = len(height) - 1

        res = 0

        while left < right:
            h = min(height[left], height[right])
            water =  h * (right - left)
            if water > res:
                res = water
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
                
        return res

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """

        res = []
        nums = sorted(nums)
        for i in range(len(nums)):
            if nums[i] > 0: 
                continue
            if i > 0 and nums[i] == nums[i-1]:  #从第二个元素开始 若后一个与前一个相同 则跳过
                continue
            left = i + 1
            right = len(nums) - 1
            while left < right:
                if nums[i]+nums[left]+nums[right] == 0:
                    res.append([nums[i],nums[left],nums[right]])
                    #两个while负责去重
                    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 nums[i]+nums[left]+nums[right] > 0:
                    right -= 1  #三数之和>0说明右指针的值较大，若与右指针左边的值重复，则右指针左移
                else:
                    left += 1  #三数之和<0说明左指针的值较小，若与左指针右边的值重复，则左指针右移
        return res

16. 最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

class Solution(object):
    def threeSumClosest(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """

        def sum(i,left,right,nums):
            return nums[i]+nums[left]+nums[right]
        lens = len(nums)
        res = sum(0, 1, lens - 1, nums) #初始值设置为第1 2 最后一个元素之和
        nums.sort()
        
        for i in range(lens-2):
            if i > 0 and nums[i] == nums[i - 1]: #从第二个元素开始 若后一个与前一个相同 则跳过
                continue
            left = i + 1
            right = lens - 1
            while left < right:
                val = sum(i,left,right,nums)
                if abs(val - target) < abs(res - target): #与目标值差值变小则成为新的res
                    res = val
                if val == target:
                    return target
                elif val > target: #三数之和>目标值 右指针左移
                   right -= 1
                else: #三数之和<目标值 左指针右移
                    left += 1
        return res

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """

        if len(nums) < 4:
            return []
        nums.sort()
        ans = []
        for i in range(len(nums) - 3):
            for j in range(i+1,len(nums) - 2):
                temp = nums[i] + nums[j]
                p = j + 1
                q = len(nums) - 1
                while p < q:
                    if nums[p] + nums[q] + temp == target:
                        if (nums[i],nums[j],nums[p],nums[q]) not in ans:
                            ans.append((nums[i],nums[j],nums[p],nums[q]))
                    if nums[p] + nums[q] + temp > target:
                        q -= 1
                    else:
                        p += 1
        return ans

31. 下一个排列

整数数组的一个 排列  就是将其所有成员以序列或线性顺序排列。

例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。
整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。
类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。
给你一个整数数组 nums ，找出 nums 的下一个排列。

必须 原地 修改，只允许使用额外常数空间

class Solution(object):
    def nextPermutation(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        #e.g. 9 8 6 9 4 6 5 3
        if sorted(nums, reverse=True) == nums:  #nums是倒序排列
            nums.reverse() #输出最小的 e.g. [3,2,1]倒序 按照题目要求应该输出最小排列即倒序后的[1,2,3]
            return nums

        for i in range(len(nums) - 1, 0, -1):
            if nums[i - 1] >= nums[i]:
                continue
            else: #找到第一个破坏降序的数字下标i-1 此处就是nums[i-1] = 4
                left = i-1
                min = nums[i]
                right = i

                for k in range(i,len(nums)):
                    if nums[k] <= min and nums[k] > nums[left]: #在i-1之后找到第一个比i-1所对应的数值大的数字 此处找到5
                        min = nums[k]
                        right = k
                break

        nums[left], nums[right] = nums[right], nums[left] #尽可能小幅度地变大 4和5交换
        nums[left + 1:] = nums[left + 1:][::-1] #i-1之后的序列倒序 6 4 3倒序为3 4 6

        return nums

33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """

        left = 0
        right = len(nums) - 1
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            if nums[left] <= nums[mid]: #middle在分割线之前
                if nums[left] <= target and target < nums[mid]: #target值在middle之前
                    right = mid - 1
                else:  #target值在middle之后 分割线之前
                    left = mid + 1
            else:  #middle在分割线之后
                if nums[mid] < target and target <= nums[right]:  #target值在middle之后
                    left = mid + 1
                else:  #target值在分割线之后 middle之前
                    right = mid - 1
        return -1

34. 在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

class Solution2(object):
    def searchRange(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """

        if target not in nums:
            return [-1,-1]
        start = nums.index(target)
        finish = len(nums) - 1 -nums[::-1].index(target) #结束位置的元素在数组倒序后就是开始位置 注意-1

        return [start,finish]

36. 有效的数独

请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

注意：

一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
空白格用 ‘.’ 表示。

class Solution(object):
    def isValidSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: bool
        """

        for i in range(9):
            temp_hang = []
            temp_lie = []
            for item in board[i]: #判断每一行是否重复
                if item in temp_hang and item != '.':
                    return False
                else:
                    temp_hang.append(item)
            for item in (a[i] for a in board): #判断每一列是否重复
                if item in temp_lie and item != '.':
                    return False
                else:
                    temp_lie.append(item)

        for k in range(0,7,3):  #遍历每一个3*3的方块
            for j in range(0,7,3):
                temp = [board[k][j],board[k][j+1],board[k][j+2],
                        board[k+1][j],board[k+1][j+1],board[k+1][j+2],
                        board[k+2][j],board[k+2][j+1],board[k+2][j+2]]
                list = []
                for item in temp:  #判断方块里的数字是否重复
                    if item in list and item != '.':
                        return False
                    else:
                        list.append(item)
        return True

74. 搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

class Solution(object):
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        li = sum(matrix,[]) #转为一维数组后使用二分查找
        left = 0
        right = len(li) - 1
        while left <= right:
            mid = (left + right) // 2
            if li[mid] == target:
                return True
            elif li[mid] > target:
                right = mid - 1
            else:
                left = mid + 1
        else:
            return False

class Solution2(object):
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        for line in matrix:
            if target in line:
                return True
        return False

String

Easy

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。
给定一个罗马数字，将其转换成整数。

class Solution1(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """

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

        sum = 0
        i = 0
        while i < len(s):
            temp1 = ''.join(s[i:i+2])
            temp2 = s[i]
            if temp1 in dic2.keys():
                sum += dic2[temp1]
                i += 2
            else:
                sum += dic1[temp2]
                i += 1
        return sum

class Solution2(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """

        dic = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        result = 0

        for i in range(len(s)):
            if i > 0 and dic[s[i]] > dic[s[i-1]]: #六个特殊案例
                result += dic[s[i]] - 2 * dic[s[i-1]]  #2是因为之前已经加了一次dic[s[i-1]]
            else:
                result += dic[s[i]]
        return result

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """

        i = 0
        result = ''
        while True:
            sets = set(string[i] for string in strs) #遍历每个短语同一位置的字母 若长度不一样时while会自动退出
            if len(sets) == 1: #出现不同的字母
                result += sets.pop()
                i += 1
            else:
                break
        return result

20.有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """

        dic = {"(":")","{":"}","[":"]"}
        stack = []
        for i in s:
            if i in dic.keys():
                stack.append(i)
            elif len(stack) == 0 or i != dic[stack.pop()] : #若匹配栈顶元素 则栈顶元素出栈
                return False
        return len(stack) == 0

58. 最后一个单词的长度

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。

单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

class Solution(object):
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        return len(s.split()[-1])

67.二进制求值

给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。

class Solution:

def addBinary(self, a, b) -> str:
    return '{0:b}'.format(int(a, 2) + int(b, 2))#先二进制转为十进制计算，计算后再转为二进制，但是二进制前面的0b不能要

125. 验证回文串

如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。

字母和数字都属于字母数字字符。

给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。

class Solution2(object):
    def isPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        s= [x for x in s.lower() if x.isalnum()]
        return s==s[::-1]

168. Excel表列名称

给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。

例如：

A -> 1
B -> 2
C -> 3
…
Z -> 26
AA -> 27
AB -> 28
…

class Solution(object):
    def convertToTitle(self, columnNumber):
        """
        :type columnNumber: int
        :rtype: str
        """

        res = ''

        while columnNumber > 0:
            temp = columnNumber % 26
            if temp:
                res += str(chr(temp+64)) #65是A
            else:#末尾0说明是Z
                res += 'Z'
            if columnNumber % 26 == 0:
                columnNumber = columnNumber // 26 - 1
            else:
                columnNumber = columnNumber // 26

        return res[::-1]

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

class Solution1(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        return sorted(s) == sorted(t)

class Solution2(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        dict1 = {}
        dict2 = {}
        for ch in s:
            dict1[ch] = dict1.get(ch,0) + 1  #如果没有ch 就取0
        for ch in t:
            dict2[ch] = dict2.get(ch,0) + 1
        return dict1 == dict2

Medium

5.最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
		
        def long(self,s,l,r):
        while l >=0 and r < len(s) and s[l] == s[r]:
            l -= 1
            r += 1
        return s[l+1:r]
      
        res = ''
        for i in range(len(s)):
            len1 = len(self.long(s, i, i)) #有对称中心
            if len1 > len(res):
                res = self.long(s, i, i)

            len2 = len(self.long(s, i, i+1)) #无对称中心
            if len2 > len(res):
                res = self.long(s, i, i+1)

        return res

    

6. N 字形变换

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “PAYPALISHIRING” 行数为 3 时，排列如下：

P   A   H   N
A P L S I I G
Y   I   R

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

请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows == 1:
            return s
        rows = [''] * numRows
        num = (numRows-1) * 2 #每组含有的字母数(一个竖着的+一个斜着的 不包括与之相联的一个组的第一个)
        for i, item in enumerate(s):
            if i % num >= numRows: #在斜着的
                rows[(num - i % num)] += item
            else: #在竖着的
                rows[i % num] += item
        return ''.join(rows)

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。
给你一个整数，将其转为罗马数字。

class Solution(object):
    def intToRoman(self, num):
        """
        :type num: int
        :rtype: str
        """

        v = [1000,900,500,400,100,90,50,40,10,9,5,4,1]
        n = ['M','CM','D','CD','C','XC','L','XL','X','IX','V','IV','I']
        result = ''
        for i in range(len(v)):
            while num >= v[i]:
                num -= v[i]
                result += n[i]
        return result

17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

class Solution(object):
    def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """

        if len(digits) == 0:
            return []
        dic = {
            2:'abc',
            3:'def',
            4:'ghi',
            5:'jkl',
            6:'mno',
            7:'pqrs',
            8:'tuv',
            9:'wxyz'
        }

        res = ['']
        for digit in digits: #遍历每一个数字
            temp_list = []
            for item in dic[int(digit)]: #遍历每一个数字对应的字母表
                for result in res:
                    temp_list.append(result + item)
            res = temp_list

        return res