做一名合格的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