python3-算法刷题-数学-经典算法（更新中）

最大公约数

1979. 找出数组的最大公约数

https://leetcode.cn/problems/find-greatest-common-divisor-of-array/
给你一个整数数组 nums ，返回数组中最大数和最小数的 最大公约数 。
两个数的 最大公约数 是能够被两个数整除的最大正整数。
示例 1：
输入：nums = [2,5,6,9,10]
输出：2
解释：
nums 中最小的数是 2
nums 中最大的数是 10
2 和 10 的最大公约数是 2

思路：先排序，然后辗转相除法

class Solution:
    def findGCD(self, nums: List[int]) -> int:
        nums.sort()
        m = nums[-1]
        n = nums[0]
        r = m % n
        while r != 0:
            m = n
            n = r
            r = m % n
        return n

数字规律

202. 快乐数

https://leetcode.cn/problems/happy-number/
编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

思路：
如果n是1或者n在循环中，则需要跳出，否则继续计算各位的平方和。

class Solution:
    def getSum(self, n:int) -> int:
        s = 0
        while n > 0:
            m = n % 10
            s += m * m
            n = n // 10
        return s

    def isHappy(self, n: int) -> bool:
        nums = [4, 16, 37, 58, 89, 145, 42, 20]
        while n != 1 and n not in nums:
            n = self.getSum(n)
        return n == 1

263. 丑数

https://leetcode.cn/problems/ugly-number/

丑数 就是只包含质因数 2、3 和 5 的正整数。
给你一个整数 n ，请你判断 n 是否为 丑数 。如果是，返回 true ；否则，返回 false 。

思路： 这题的重点就一个，考虑0

class Solution:
    def isUgly(self, n: int) -> bool:
        if n == 0: return False
        while n % 2 == 0:
            n = n // 2
        while n % 3 == 0:
            n = n // 3
        while n % 5 == 0:
            n = n // 5
        return n == 1

1588. 所有奇数长度子数组的和

https://leetcode.cn/problems/sum-of-all-odd-length-subarrays/
给你一个正整数数组 arr ，请你计算所有可能的奇数长度子数组的和。
子数组 定义为原数组中的一个连续子序列。
请你返回 arr 中 所有奇数长度子数组的和 。

示例 1：
输入：arr = [1,4,2,5,3]
输出：58
解释：所有奇数长度子数组和它们的和为：
[1] = 1
[4] = 4
[2] = 2
[5] = 5
[3] = 3
[1,4,2] = 7
[4,2,5] = 11
[2,5,3] = 10
[1,4,2,5,3] = 15
我们将所有值求和得到 1 + 4 + 2 + 5 + 3 + 7 + 11 + 10 + 15 = 58

思路：
核心是计算每个元素在多少个奇数长度子数组中出现，用出现次数乘元素值，再累加即可。
假设arr的长度为n，那么对于元素arr[i]，其左侧的元素数目为i，右侧的元素数目为 n - i - 1。如果arr[i]在奇数长度数组中，那么它左侧和右侧要么同时有奇数个数字，要么同时有偶数个数字。
对于[0, x]区间，奇数和偶数的出现次数如下表所示：

x	0	1	2	3
奇数	0	1	1	2
偶数	1	1	2	2

由此可知，奇数的出现次数为floor((x + 1) / 2)，偶数的出现次数为floor(x / 2) + 1。

那么，当arr[i]左侧和右侧有奇数个数字时，就是分别在[0, i]和[0, n-i-1]中计算奇数出现的次数，然后基于组合，直接相乘（比如如果左侧取到1，就是arr[i]左边有1个元素）；当arr[i]左侧和右侧有偶数个数字时，还是在上面的范围中计算偶数出现的次数，然后基于组合，直接相乘。两种情况的和，就是arr[i]在所有奇数长度子数组中出现的总次数。

class Solution:
    def sumOddLengthSubarrays(self, arr: List[int]) -> int:
        ans = 0
        for i in range(len(arr)):
            leftCount = i
            rightCount = len(arr) - i - 1
            leftOdd = (leftCount + 1) // 2
            rightOdd = (rightCount + 1) // 2
            leftEven = leftCount // 2 + 1
            rightEven = rightCount // 2 + 1
            ans += arr[i] * (leftOdd * rightOdd + leftEven * rightEven)
        return ans

质数

204. 计数质数

https://leetcode.cn/problems/count-primes

给定整数 n ，返回 所有小于非负整数 n 的质数的数量 。

示例 1：
输入：n = 10
输出：4
解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

示例 2：
输入：n = 0
输出：0

示例 3：
输入：n = 1
输出：0

思路：
筛选质数。从2开始，每个数的倍数处都是合数，那么剩下的就是质数。

class Solution:
    def countPrimes(self, n: int) -> int:
        isPrime = [1] * n
        i = 2
        while i * i < n:
            if isPrime[i] == 1:
                j = i * i
                while j < n:
                    isPrime[j] = 0
                    j += i
            i += 1
        cnt = 0
        for i in range(2, n, 1):
            if isPrime[i] == 1:
                cnt += 1
        return cnt