首先是 2418. Sort the People (easy)
https://leetcode.com/problems/sort-the-people/

他會提供兩個串列，一個紀錄人名names，一個紀錄高度heights，name與height用索引值對應著。
這題希望，以身高進行排序，由低到高排出一個名單出來。
方法如下：

1. 將heights與names對應在一起(Tuple或list皆可)
2. 排序
3. 建立ans串列，抓出排序完的人名，結束

class Solution:
    def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
        D = zip(heights,names)
        D = list(D)
        # D.sort(key=lambda x:x[1])
        #第一次寫的時候把height丟到後面去，導致sort要用到lambda增加自己麻煩
        ans = []
        for i in D:
            ans.append(i[1])
        return ans[::-1]

再來是 2419. Longest Subarray With Maximum Bitwise AND (medium)
https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/

這題簡單來說，從nums 找到最大值是誰，然後找出這個最大值最長的連續次數。
想法：

1. 找到最大值
2. 設立變數用來計算最大值重複次數
3. 設立變數用來計算最大值的最大重複次數

class Solution:
    #最大值
    #連接在一起最長的
    #硬幹法
    def longestSubarray(self, nums: List[int]) -> int:
        temp = max(nums)
        c = 0
        maxC = 0
        nums.append(0)#最後添加個0可以少比較一次
        for i in nums:
            if i == temp:
                c+=1
            else:
                maxC = max(c,maxC)
                c=0
        # maxC = max(c,maxC)
        return maxC

再來是 2420. Find All Good Indices (medium)
https://leetcode.com/problems/find-all-good-indices

這題會給一個串列nums以及一個k值，要檢查，當索引值為i時，從i-k~i-1時是否為遞減數列，以及i+1~i+k時是否為遞增串列。
暴力法：

1. 直接從第k開始抓
2. 抓0~k-1的值，進行sort(reverse = True)，看跟原本一不一樣
3. 抓k+1~2k的值，進行sort，看跟原本一不一樣
4. 持續進行到結束
5. 看有沒有TLE(沒TLE我反而感到訝異)

class Solution:
    #TLE
    def goodIndices(self, nums: List[int], k: int) -> List[int]:
        numsLen = len(nums)
        ans = []
        if k == 1:
            return list(range(1,numsLen-1))
        flag = 1
        for i in range(k,numsLen-k):
            if flag:
                numsL = nums[i-k:i]
                numsR = nums[i+1:i+k+1]
                if numsL == sorted(numsL,reverse =True) and numsR == sorted(numsR):
                    ans.append(i)
                    flag = 0
            else:
                if nums[i-1]<=nums[i-2] and nums[i+k]>=nums[i+k-1]:
                    ans.append(i)
                else:
                    flag = 1
        return ans

那當然結果TLE，畢竟這是O(n^2)的作法
那接著當然要改一下作法

1. 首先先由前往後，找出到底有哪幾個點位是可以的(但不是用sort，而是單純比大小)
2. 紀錄
3. 接著由後往前
4. 紀錄
5. 比較紀錄的那些點位是一樣的
6. return

def goodIndices(self, nums: List[int], k: int) -> List[int]:
        numsLen = len(nums)
        if k == 1:#遇到1直接不需要比較，除了頭尾一定都是
            return list(range(1,numsLen-1))
        recordFront = []
        flag = 1
        #前面
        for i in range(1,numsLen):
            if nums[i] <= nums[i-1]:
                flag += 1
                if flag >= k:
                    recordFront.append(i+1)
            else:
                flag = 1
        #後面
        recordBack = []
        flag = 1
        for i in range(-2,-numsLen-1,-1):
            if nums[i]<=nums[i+1]:
                flag += 1
                if flag >= k:
                    recordBack.append(i+numsLen-1)
            else:
                flag = 1
        recordBack = recordBack[::-1]
        print(recordFront,recordBack)
        ans = sorted(list(set(recordFront) & set(recordBack)))#找出共同被記錄到的點位
        return ans 

基本上來說，我覺得這樣寫最簡單易懂

以上即為今天的練習，感謝各位