算法其他（简单）

384. 打乱数组

class Solution:

    def __init__(self, nums: List[int]):
        self.array = nums
        self.original = nums.copy()

    def reset(self) -> List[int]:
        """
        Resets the array to its original configuration and return it.
        """
        self.array = self.original
        self.original = self.original.copy()
        return self.array

    def shuffle(self) -> List[int]:
        """
        Returns a random shuffling of the array.
        """
        for i in range(len(self.array)):
            idx = random.randrange(i,len(self.array))
            self.array[i], self.array[idx] = self.array[idx],self.array[i]
        return self.array

洗牌算法
1、从数组中每次随机取出一个，可通过计算概率是一样的，pop，但是pop是线性复杂度，所以O(n^2)
2、Fisher-Yates算法，模拟的仍是随机取元素的过程，O(n)

204. 计数质数

class Solution:
    def countPrimes(self, n: int) -> int:
        """
        求n以内的所有质数个数（纯python代码）
        """
        # 最小的质数是 2
        if n < 2:
            return 0

        isPrime = [1] * n
        isPrime[0] = isPrime[1] = 0   # 0和1不是质数，先排除掉

        # 埃式筛，把不大于根号n的所有质数的倍数剔除
        for i in range(2, int(n ** 0.5) + 1):
            if self.isprimes(i):
                isPrime[i * i:n:i] = [0] * ((n - 1 - i * i) // i + 1)

        return sum(isPrime)

    def isprimes(self,n):
        flag = 1
        if n <= 3:
            return True

        for i in range(2,int(n**0.5)+2):
            if n%i == 0:
                flag = 0
                break
        if flag:
            return True
        else:
            return False

这道题优化空间很大：
思路一：暴力做法，判断每个数是否是素数
优化一：判断素数时，不需要判断到n，只需要判断到n的根号
优化二：判断每个数是否是素数，也只需要判断到n的根号，如果是素数，删除掉素数的倍数，留下的就是素数
优化三：都不用判断是否是素数了，在剔除不是素数的过程中，本身就是素数

326. 3的幂
     思路一：不断的除3，看是否除得尽
     思路二：log3(n)，看是否是整数
     思路三：转为3进制数，最高位为1，其他位为0

327. 2的幂
     思路一:不断的除2
     思路二：位运算，n & (n -1) == 0

328. 4的幂
     思路一：不断的除4
     思路二：转为4进制数，最高位为1，其他位为0
     思路三：
     2^(2k) mod 3 = 4 ^ k mod 3 = (1 + 3) ^ k mod 3 = 1
     2^(2k + 1) mod 3 = 2 * 4 ^ k mod 3 = 2 * (1 + 3) ^ k mod 3 = 2

329. 位1的个数
     思路一：与用1进行与运算，看是否为0，每次左移1
     思路二：n & (n-1)会将删去一个1

330. 多数元素
     1、哈希表
     2、用count计数