做一名合格的pythoner

• ​​旋转矩阵题​​
• ​​字母异位词分组​​
• ​​合并区间​​

旋转矩阵题

今天在做一道题的时候，题目是这样的

这道题就是先转置然后左右镜像对称，所以我写了这样的代码

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        for i in range(len(matrix[0])):
            for j in range(i,len(matrix[0])):
                tmp=matrix[i][j]
                matrix[i][j]=matrix[j][i]
                matrix[j][i]=tmp
        
        print(matrix)

        for i in range(len(matrix)):
            for j in range(len(matrix)//2):
                tmp=matrix[i][j]
                matrix[i][j]=matrix[i][len(matrix)-j-1]
                matrix[i][len(matrix)-j-1]=tmp
        print(matrix)
        return      

结果还不错，超过了95%的提交记录。

然后我看到了一个的代码是这样的，然后觉着，我真不够pythoner。

代码大体就是这么写的，我根据他的写法稍微优化了下。

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        length=len(matrix)
        for i in range(length):
            for j in range(i+1,length):
                matrix[i][j],matrix[j][i]=matrix[j][i],matrix[i][j]
        
        for i in range(length):
            matrix[i]=matrix[i][::-1]

        return      

这才是一个pythoner正确的写法。

字母异位词分组

拿到题，想到用散列，遂写如下代码：

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        res=dict()
        for i in range(len(strs)):
            tmp="".join(sorted(strs[i]))
            print(tmp)
            if tmp in res:
                res[tmp].append(strs[i])
            else:
                res[tmp]=[strs[i]]

        return list(res.values())      

也还不错，但是更好的写法是：

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        mp=collections.defaultdict(list)

        for i in range(len(strs)):
            tmp="".join(sorted(strs[i]))
            mp[tmp].append(strs[i])

        return list(mp.values())      

应该使用collections提供的defaultdict()方法来避免判断键的问题。

合并区间

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        merged=[]
        intervals.sort(key=lambda x:x[0])
        for interval in intervals:
            if not merged or merged[-1][1]<interval[0]:
                merged.append(interval)
            else:
                merged[-1][1]=max(merged[-1][1],interval[1])
        return