牛客——模拟

1.旋转数组

没有那么复杂，直接就取一截就行，但是比较重要的就是需要考虑到m>n的情况，需要通过取余来使得他更简单一点。

class Solution:
    def solve(self , n: int, m: int, a: List[int]) -> List[int]:
        # write code here
        m=m%n
        b=a[n-m:]
        c=a[:n-m]
        b.extend(c)
        return b

2.螺旋矩阵

这个就是旋转着把矩阵输成一个向量

class Solution:
    def spiralOrder(self , matrix: List[List[int]]) -> List[int]:
        # write code here
        res =[]
        if not matrix:
            return res
        top = 0
        left = 0
        right = len(matrix[0])-1
        bottom = len(matrix)-1
        while left <= right and top <=bottom:
            for x in range(left,right+1):
                res.append(matrix[top][x])
            for x in range(top+1,bottom+1):
                res.append(matrix[x][right])
            for x in range(right-1,left-1,-1):
                if not top == bottom:
                    res.append(matrix[bottom][x])
            for x in range(bottom-1,top,-1):
                if not left == right:
                    res.append(matrix[x][left])
            top += 1
            bottom -= 1
            left += 1
            right -= 1
        return res

上面的这个方法在视频里也讲过。
不符合题意的解法

class Solution:
    def spiralOrder(self , matrix ):
        # write code here
        res = []
        while matrix:
            #弹出第1行并和之前的结果列表相加
            res += list(matrix.pop(0))
            #将剩余的列表逆时针旋转90度,先对矩阵解包，然后进行zip打包得到一个元组序列，
            #再将元组序列变成列表，最后从后向前取就得到矩阵的旋转90度结果
            matrix =  list(zip(*matrix))[-1::-1]
        return res

3.顺时针旋转矩阵

class Solution:
    def rotateMatrix(self , mat: List[List[int]], n: int) -> List[List[int]]:
        # write code here
        final = []
        res = list(reversed(mat))
        for i in range(n):
            tmp = []
            for k in range(n):
                tmp.append(res[k][i])
            final.append(tmp)
        return final

一个白痴方法

class Solution:
    def rotateMatrix(self , mat: List[List[int]], n: int) -> List[List[int]]:
        # write code here
         return [x[::-1] for x in zip(*mat)]

4.设计LRU缓存结构

一点没看

class Solution:

    def __init__(self, capacity: int):
        # write code here
        self.capacity = capacity
        self.nums = {}
        self.lru = []

    def get(self, key: int) -> int:
        # write code here
        val = '-1'
        if key in self.nums:
            val = self.nums[key]
            self.lru.remove(key)
            self.lru.append(key)
        return val

    def set(self, key: int, value: int) -> None:
        # write code here
        if len(self.lru) == self.capacity:
            self.nums.pop(self.lru[0])
            del self.lru[0]
        self.nums[key] = value
        self.lru.append(key)
         

# Your Solution object will be instantiated and called as such:
# solution = Solution(capacity)
# output = solution.get(key)
# solution.set(key,value)

5.设计LFU缓存结构

from collections import OrderedDict,defaultdict
class Solution:
    def LFU(self , operators: List[List[int]], k: int) -> List[int]:
        # write code here
        self.freq=defaultdict(OrderedDict)#{freq:{key:value}}有序字典，存顺序
        self.key_to_freq={}
        self.k=k
        self.min_freq=0
        self.out=[]
        for op in operators:
            if op[0]==1:
                self.set(op[1],op[2])
            else:
                self.out.append(self.get(op[1]))
        return self.out
    def set(self,key,value):
        if self.k==0:return
        if key in self.key_to_freq:
            key_freq=self.key_to_freq[key]
            self.freq[key_freq].pop(key)
            if not self.freq[key_freq] and key_freq==self.min_freq:
                self.min_freq+=1
            self.freq[key_freq+1][key]=value
            self.key_to_freq[key]=key_freq+1
        else:
            if len(self.key_to_freq)==self.k:
                k,v=self.freq[self.min_freq].popitem(last=False)
                self.key_to_freq.pop(k)
            self.key_to_freq[key]=1
            self.freq[1][key]=value
            self.min_freq=1
    def get(self,key):
        if key not in self.key_to_freq:return -1
        key_freq=self.key_to_freq[key]
        value=self.freq[key_freq][key]
        self.freq[key_freq].pop(key)
        if not self.freq[key_freq] and key_freq==self.min_freq:
                self.min_freq+=1
        self.freq[key_freq+1][key]=value
        self.key_to_freq[key]=key_freq+1
        return value